# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# GraphQL playground
Source: https://developer.jtl-software.com/api-reference/graphql-playground
Interactive GraphQL IDE to explore and test the JTL Platform API
Explore the JTL ERP API using GraphQL. Use the schema explorer on the left to
browse available queries and mutations, or type directly in the editor. Log in
to run queries against your own ERP instance.
Best Viewed on Desktop
The GraphQL playground is a full interactive IDE built for larger screens.
Open this page on a desktop or tablet to browse the schema and run queries.
# Build with AI
Source: https://developer.jtl-software.com/get-started/build-with-ai
Build faster on JTL platform by consuming the docs in your AI-coding tools (like Cursor, Claude, etc)
JTL provides a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that gives AI tools direct access to the full developer documentation, so they can answer questions, generate code, and help you build Cloud Apps with accurate, up-to-date information.
## Connect to your AI Tool
Choose your AI coding tool below and follow the setup instructions.
Add the JTL docs MCP server with a single command:
```bash theme={null}
claude mcp add --transport http jtl-docs https://developer.jtl-software.com/mcp
```
Restart Claude Code, then run `/mcp`. You'll see `jtl-docs · ✔ connected` as part of the MCP servers.
Add the following to your project's `.vscode/mcp.json` (create the file if it doesn't exist):
```json theme={null}
{
"servers": {
"jtl-docs": {
"type": "http",
"url": "https://developer.jtl-software.com/mcp"
}
}
}
```
Restart VS Code and Copilot will pick up the MCP server.
Start Copilot CLI and then run the command below:
```bash theme={null}
/mcp add
```
Copilot will open an interactive form asking for the MCP server details. Fill in the following:
* **Server Name:** `jtl-docs`
* **Server Type:** Press 3 to select HTTP
* **URL:** `https://developer.jtl-software.com/mcp`
Use the **Tab** key to navigate and **ctrl+s** to save.
Once it's saved, run `/mcp show`. You'll see `✓ jtl-docs` in the list of available MCP servers.
Open **Cursor Settings** > **Tools & MCPs** > **Add Custom MCP**. Then paste the following:
```json theme={null}
{
"mcpServers": {
"jtl-docs": {
"type": "http",
"url": "https://developer.jtl-software.com/mcp"
}
}
}
```
Alternatively, add it to your project's `.cursor/mcp.json` (create the file if it doesn’t exist):
```json theme={null}
{
"mcpServers": {
"jtl-docs": {
"type": "http",
"url": "https://developer.jtl-software.com/mcp"
}
}
}
```
Open **Devin Settings > Devin Local > Open Devin MCP marketplace > Add custom MCP** and add a new server, or add it manually by editing `~/.codeium/windsurf/mcp_config.json`:
```json theme={null}
{
"mcpServers": {
"jtl-docs": {
"type": "http",
"url": "https://developer.jtl-software.com/mcp"
}
}
}
```
You can also connect directly from any page in these docs. Click the contextual menu (top of any page) and select **Connect to Cursor** or **Connect to VS Code** to add the MCP server with one click.
```text icon="sparkles" AI Assistant Prompt theme={null}
Help me build a JTL Cloud App from scratch. Use the jtl-docs MCP
server for any platform details. Follow the From Scratch quickstart:
1. Scaffold the frontend with Vite, TanStack Router, AppBridge, and
Platform UI, with the AppBridge provider scoped to the shell route
group. 2. Set up a backend (Node, C#, or PHP) that verifies the
session token and exposes the connect-tenant and items endpoints. 3.
Generate a manifest.json with configurationUrl and the correct
capabilities and scopes. 4. Suggest relevant next steps such as
submitting to the App Store.
```
## What the AI Can Do
Once connected, your AI tool can:
**Answer platform questions.** Ask "How do I verify a session token from AppBridge?" and the AI will pull the exact implementation from the authentication docs.
**Generate manifest files.** Describe what your app does and the AI will generate a complete `manifest.json` with the correct capabilities, scopes, and lifecycle URLs.
**Write API integration code.** Ask "Write a GraphQL query to fetch the first 20 items sorted by SKU" and the AI will generate the query, headers, and fetch logic based on the actual API docs.
**Debug authentication issues.** Paste an error message and the AI can reference the troubleshooting docs to suggest a fix.
**Scaffold entire apps.** Ask the AI to create a Cloud App with a specific feature, and it will follow the architecture patterns from the docs (AppBridge provider, session verification, API client).
## Tips for Better Results
**Be specific about what you're building.** "Help me build a JTL Cloud App" is vague. "Create a panel app that shows customer order history in the customer sidebar" gives the AI enough context to generate accurate code.
**Reference JTL concepts by name.** Use terms like "AppBridge," "manifest.json," "session token," "JTL-Wawi GraphQL API," or "lifecycle hooks." The AI will map these to the correct documentation pages.
**Ask follow-up questions.** After the AI generates code, ask "Does this follow the recommended AppBridge initialization pattern?" The AI will check its answer against the docs.
**Combine with the quickstarts.** Start with the [From Template](/get-started/quick-start/from-template) or [From Scratch](/get-started/quick-start/from-scratch) quickstart to get a running app, then use AI to extend it with features.
## Other Ways to Use the Docs with AI
Beyond the MCP server, there are a few more ways to feed JTL docs into AI tools:
**Copy as Markdown.** On any page, press `Cmd+C` / `Ctrl+C` or select **Copy** from the contextual menu to copy the page content as Markdown. Paste it directly into ChatGPT, Claude, or any other AI tool.
**Claude and ChatGPT links.** Select **Open in Claude** or **Open in ChatGPT** from the contextual menu on any page. This opens the AI tool with the page content pre-loaded.
**llms.txt.** The docs site hosts an `llms.txt` file that AI crawlers use to index the documentation. This helps general-purpose AI tools like ChatGPT and Perplexity get accurate answers about JTL's platform.
***
## What's Next
Clone the sample app and get a running Cloud App in 15 minutes.
Build a Cloud App step by step with React and your favourite backend (Node.js, C#, or PHP).
Understand how Cloud Apps are structured before you start building.
Call the Cloud ERP REST and GraphQL APIs from your app.
# Create a Developer Account
Source: https://developer.jtl-software.com/get-started/create-developer-account
Set up your development environment in three connected steps. Takes about 10 minutes.
To build on the JTL platform, you'll work across four connected environments. Each one plays a different role in your development workflow. Three of them are needed to start building, and the fourth comes in when you're ready to test your app.
This guide walks you through setting them up in one go. It takes about 10 minutes.
## Your Development Environment
Here's what each environment does and why you need it:
| Environment | What you'll use it for |
| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **[JTL-Wawi](/guides/erp-integration/integration-overview)** | The ERP system where merchant data lives: products, orders, customers, inventory. Your app reads and writes this data through APIs or GraphQL. |
| **[Partner Portal](https://partner.jtl-cloud.com/)** | Where you create and manage your apps. |
| **[JTL Hub](https://hub.jtl-cloud.com/)** | A dedicated environment where you can install and test your apps, verify the connection to JTL-Wawi, and manage the app lifecycle before going live. |
| **[ERP Cloud](https://erp.jtl-cloud.com/)** | The web-based interface where your installed app actually runs. Currently in development, with MVP release coming soon. You can already use it to test your app and validate how it integrates. See [Test your App](/get-started/test-your-app). |
**JTL-Wawi** is the ERP itself (the data), **Partner Portal** is where you
create and manage your apps, **JTL Hub** is where you install, and **ERP
Cloud** is where your app runs for the merchant.
Here's how they connect:
```mermaid theme={null}
flowchart LR
subgraph You["👤 Developer"]
direction TB
end
subgraph Create["1 · Partner Portal"]
direction TB
PP["**Create & configure apps**
Manage credentials
Handle submissions & payouts"]
end
subgraph Install["2 · JTL Hub"]
direction TB
HC["**Sandbox environment**
Install & test apps
Manage app lifecycle"]
end
subgraph Run["3 · ERP Cloud"]
direction TB
EP["**App runtime**
Where your installed
app actually renders"]
end
subgraph Data["JTL-Wawi"]
direction TB
WW["**ERP system**
Products, orders, customers, inventory & shipping"]
end
subgraph Ship["🚀 App Store"]
direction TB
ES["Distribute to 50,000+ merchants"]
end
You --> Create
Create -- "App credentials" --> Install
Install -- "Launches app" --> Run
Run -- "APIs" --> Data
Install -- "Submit" --> Ship
style Create fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style Install fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style Run fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style Data fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style Ship fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style You fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
```
The overall flow is: you **create your app** in the Partner Portal, **install it** in JTL Hub, **run it** in the ERP Cloud against **live data from JTL-Wawi**, and when everything looks good, **submit it** to the App Store.
Now let's get everything set up.
## Step 1: Set up your Partner Portal
This is your app management hub where you create apps and get your client credentials.
Open [Partner Portal](https://partner.jtl-cloud.com/) in your browser.
SSO is currently not supported with your JTL ID. You'll need to register separately with your email.
Once you navigate to the URL, you'll be prompted to log in with your **JTL ID**. Click on the **Register now** button to create a new JTL ID.
**JTL ID** provides a single access point to all JTL cloud-related services (JTL Hub, Partner Portal, ERP Cloud, etc.)
On registering, you'll be asked to fill in the confirmation code sent to your email address. Once you fill in the code, you'll be redirected to the log in page.
Once you log in with your credentials, choose one of the following:
* **New to JTL**: Click **Create organization** and fill in the required details if you don't have an existing Customer Center Account.
* **Existing JTL customer**: Click **Link your JTL customer account** and log in to your Customer Center Account. Then **Authorize** JTL Cloud when prompted.
**Customer Center Account** is your central hub for managing licenses, JTL
services, billing, and support.
After completing either option above, continue with the steps below:
1. Once your organization is created, you’ll see your organization name and custom URL path.
2. Click **Continue to JTL Hub** and you’ll be redirected to [JTL Hub dashboard](https://hub.jtl-cloud.com/).
It’s recommended to set up 2FA before proceeding.
3. On your JTL Hub dashboard, click the [Partner Portal](https://partner.jtl-cloud.com/) link.
You’ll be redirected to the Partner Portal domain. Click **Create an account**.
Next, select how you want to use the Partner Portal and then **Continue**.
4. Enter your business contact details and **Create account**.
Once your account is created, you’ll be redirected to the Partner Portal dashboard. This is where you'll create and manage your apps.
## Step 2: Connect to JTL-Wawi
The final step is to connect your JTL Cloud environment to JTL-Wawi. Your app uses this connection to read and write merchant data.
Log in to your JTL-Wawi instance.
In the **Admin** menu, click **JTL Cloud**, then click **Connect**.
Read the message in the dialog carefully and click **OK**. This opens a new tab with the JTL Cloud login page.
Log in using the JTL ID you created in [Step 1](#step-1-set-up-your-partner-portal).
Once authentication is successful, close the browser tab and return to your JTL-Wawi instance.
Back in JTL-Wawi, you'll see a **Connected** status, indicating the pairing was successful.
Pairing JTL-Wawi with JTL Cloud is not sufficient on its own. You must also configure and start the Wawi API so your app can access and sync data.
Open the **JTL Administrator** to start the Wawi API.
JTL creates a desktop shortcut for the JTL Administrator after installation.\
For older versions of JTL-Wawi, you can find it in the installation folder.
Create a new entry by selecting **Wawi-API**.
Select the desired profile and certificate, then enable the **Cloud Connection** checkbox.
Click **Save**.
Once the connection is established, you will see an **is running** status. This may take a few seconds.
You can start or stop the API service from the JTL Administrator.
If the API service is stopped, Cloud Apps cannot read or write data.
Navigate to the **Connection (JTL-Wawi)** menu in JTL Hub to see your connected Wawi instance.
You now have everything you need to start building Cloud Apps.
## What's Next?
Start from a template and get a Cloud App running in minutes. Recommended for most developers.
Build a Cloud App step by step to understand how everything fits together.
**Need help?** If you run into issues during account setup, reach out via the [support channel](/help/support).
# C#
Source: https://developer.jtl-software.com/get-started/quick-start/from-scratch/backend-csharp
Build the ASP.NET Core backend for your JTL Cloud App. Verify session tokens, fetch access tokens, and proxy requests to the JTL Cloud API.
Build the ASP.NET Core backend for a JTL Cloud App using .NET 8 and `NSec.Cryptography` for Ed25519 signature verification. By the end, the backend runs locally and the frontend's "Waiting for backend" placeholder turns into a real connection.
**Stack:** .NET 8, ASP.NET Core Web API, `NSec.Cryptography` for JWT verification.
## Prerequisites
You need:
* ✅ **A finished frontend** from the [Build the Frontend](/get-started/quick-start/from-scratch/frontend) page, running locally on `http://localhost:5173`
* ✅ **[.NET SDK](https://dotnet.microsoft.com/download) 8.0 or higher**. Run `dotnet --version` to check.
## What you're Building
During setup, your backend verifies that the session token from your frontend is valid and was issued by JTL.
To do this:
* Your backend authenticates with JTL using its client credentials
* Fetches JTL's public keys (JWKS)
* And uses them to verify the session token's signature
```mermaid theme={null}
sequenceDiagram
participant FE as Your Frontend
participant BE as Your Backend (ASP.NET Core)
participant Auth as JTL Auth
participant API as JTL Cloud API
FE->>BE: GET /api/connect-tenant (X-Session-ID: token)
BE->>Auth: POST /oauth2/token (client credentials)
Auth-->>BE: Access token (JWT)
BE->>API: GET /.well-known/jwks.json (with access token)
API-->>BE: Public keys (JWKS)
BE->>BE: Verify session token signature
BE-->>FE: Verified tenant info
```
Once verified, the token tells your backend which tenant (merchant) and user is using your app. Your backend can then make tenant-scoped requests to the JTL Cloud API on their behalf.
## 1. Set up the Project
Create a `Backend` folder alongside the existing `frontend` folder, then scaffold a Web API project inside it.
```bash theme={null}
cd my-jtl-app
dotnet new webapi -n Backend
```
Your project structure now looks like this:
```
my-jtl-app/
├── frontend/ # From the previous page
└── Backend/ # New
```
The `dotnet new webapi` template includes a sample `WeatherForecast` controller and model. You can leave these in place or delete them. They won't affect anything you build in this guide.
## 2. Install Packages
```bash theme={null}
cd Backend
dotnet add package NSec.Cryptography
```
| Package | Purpose |
| ------------------- | ------------------------------------------------------------------------------------------------ |
| `NSec.Cryptography` | Cryptographic primitives for Ed25519 signature verification, used to validate JTL session tokens |
## 3. Set up Environment Variables
ASP.NET Core uses `appsettings.json` for configuration. For local secrets, use the .NET user-secrets tool so credentials never end up in source control.
From the `Backend/` directory:
```bash theme={null}
dotnet user-secrets init
dotnet user-secrets set "Jtl:ClientId" "your-client-id-here"
dotnet user-secrets set "Jtl:ClientSecret" "your-client-secret-here"
```
The values are placeholders for now. You'll get real values from the [Partner Portal](https://partner.jtl-cloud.com/) in the next page and update them with the same `dotnet user-secrets set` commands.
For production, swap user-secrets for environment variables, Azure Key Vault, or whichever secrets manager fits your hosting platform.
## 4. Build the Auth Service
The first piece of the backend is a service that authenticates with JTL using your client credentials and returns an access token. This token has two uses: fetching the public keys for session token verification, and making tenant-scoped calls to the JTL Cloud API.
Create `Backend/Services/JtlAuthService.cs`:
```csharp theme={null}
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
namespace Backend.Services;
public class JtlAuthService
{
private readonly HttpClient _http;
private readonly IConfiguration _config;
public JtlAuthService(HttpClient http, IConfiguration config)
{
_http = http;
_config = config;
}
public string ApiBaseUrl => "https://api.jtl-cloud.com";
public string AuthEndpoint => "https://auth.jtl-cloud.com/oauth2/token";
public async Task GetJwtAsync()
{
var clientId = _config["Jtl:ClientId"];
var clientSecret = _config["Jtl:ClientSecret"];
if (string.IsNullOrEmpty(clientId) || string.IsNullOrEmpty(clientSecret))
{
throw new InvalidOperationException(
"Jtl:ClientId and Jtl:ClientSecret must be configured.");
}
var basic = Convert.ToBase64String(
Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}"));
var request = new HttpRequestMessage(HttpMethod.Post, AuthEndpoint);
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", basic);
request.Content = new FormUrlEncodedContent(new Dictionary
{
["grant_type"] = "client_credentials",
});
var response = await _http.SendAsync(request);
var body = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException(
$"Failed to fetch JWT ({(int)response.StatusCode}): {body}");
}
using var doc = JsonDocument.Parse(body);
return doc.RootElement.GetProperty("access_token").GetString()!;
}
}
```
The service reads its credentials from `IConfiguration` (which user-secrets feeds into automatically), encodes them as Basic auth, and sends a `client_credentials` grant request to JTL's auth endpoint. The token is short-lived, so the method fetches a fresh one on each call. For higher-traffic backends you'd add caching.
## 5. Build the Session Verifier
With an access token in hand, the backend can fetch the public keys it needs to verify session tokens. JTL signs session tokens with `Ed25519`.
Create `Backend/Services/SessionVerifier.cs`:
```csharp theme={null}
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using NSec.Cryptography;
namespace Backend.Services;
public record SessionTokenPayload(
long Exp,
string UserId,
string TenantId,
string? TenantSlug);
public class SessionVerifier
{
private readonly HttpClient _http;
private readonly JtlAuthService _auth;
private readonly ILogger _logger;
public SessionVerifier(
HttpClient http,
JtlAuthService auth,
ILogger logger)
{
_http = http;
_auth = auth;
_logger = logger;
}
public async Task VerifyAsync(string sessionToken)
{
var jwt = await _auth.GetJwtAsync();
var request = new HttpRequestMessage(
HttpMethod.Get,
$"{_auth.ApiBaseUrl}/account/.well-known/jwks.json");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", jwt);
var response = await _http.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException(
$"Failed to fetch JWKS ({(int)response.StatusCode})");
}
var jwksJson = await response.Content.ReadAsStringAsync();
var jwks = JsonSerializer.Deserialize(jwksJson);
// Select the signing key by its JWK properties (use=sig, alg=EdDSA)
JsonElement? signingKey = null;
foreach (var k in jwks.GetProperty("keys").EnumerateArray())
{
var use = k.TryGetProperty("use", out var u) ? u.GetString() : null;
var alg = k.TryGetProperty("alg", out var a) ? a.GetString() : null;
if (use == "sig" && alg == "EdDSA")
{
signingKey = k;
break;
}
}
if (signingKey is null)
throw new InvalidOperationException("No EdDSA signing key found in JWKS");
// JTL session tokens are signed with Ed25519 (OKP)
var publicKeyBytes = Base64UrlDecode(signingKey.Value.GetProperty("x").GetString()!);
return VerifyAndDecode(sessionToken, publicKeyBytes);
}
private SessionTokenPayload VerifyAndDecode(string token, byte[] publicKeyBytes)
{
var parts = token.Split('.');
if (parts.Length != 3)
{
throw new ArgumentException(
"Invalid JWT format. Expected 3 dot-separated parts.");
}
var signedData = Encoding.ASCII.GetBytes($"{parts[0]}.{parts[1]}");
var signature = Base64UrlDecode(parts[2]);
var algorithm = SignatureAlgorithm.Ed25519;
var publicKey = PublicKey.Import(
algorithm, publicKeyBytes, KeyBlobFormat.RawPublicKey);
if (!algorithm.Verify(publicKey, signedData, signature))
{
_logger.LogError("JWT signature verification failed");
throw new UnauthorizedAccessException("Invalid token signature.");
}
var payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(parts[1]));
var payload = JsonSerializer.Deserialize(payloadJson);
var exp = payload.GetProperty("exp").GetInt64();
if (DateTimeOffset.FromUnixTimeSeconds(exp) < DateTimeOffset.UtcNow)
{
throw new UnauthorizedAccessException("Token has expired.");
}
return new SessionTokenPayload(
Exp: exp,
UserId: payload.GetProperty("userId").GetString()!,
TenantId: payload.GetProperty("tenantId").GetString()!,
TenantSlug: payload.TryGetProperty("tenantSlug", out var slug)
? slug.GetString()
: null);
}
private static byte[] Base64UrlDecode(string input)
{
var padded = input.Replace('-', '+').Replace('_', '/');
padded += (padded.Length % 4) switch
{
2 => "==",
3 => "=",
_ => ""
};
return Convert.FromBase64String(padded);
}
}
```
There are two things going on inside this service. The public `VerifyAsync` method fetches the JWKS document and pulls out the first public key. The private `VerifyAndDecode` method splits the JWT into its three parts (header, payload, signature), reconstructs the signed data, and asks `NSec` to verify the signature against the public key. If the signature is valid and the token isn't expired, it returns the decoded payload as a strongly-typed record.
## 6. Build the Connect Tenant Controller
Now wire the verifier into a controller. The frontend's shell layout sends the session token to `/api/connect-tenant` and expects a tenant ID back.
Create `Backend/Controllers/ConnectTenantController.cs`:
```csharp theme={null}
using Backend.Services;
using Microsoft.AspNetCore.Mvc;
namespace Backend.Controllers;
[ApiController]
[Route("api/connect-tenant")]
public class ConnectTenantController : ControllerBase
{
private readonly SessionVerifier _verifier;
private readonly ILogger _logger;
public ConnectTenantController(
SessionVerifier verifier,
ILogger logger)
{
_verifier = verifier;
_logger = logger;
}
[HttpGet]
public async Task Get()
{
var sessionToken = Request.Headers["X-Session-ID"].FirstOrDefault();
if (string.IsNullOrWhiteSpace(sessionToken))
{
return BadRequest(new { error = "Session token is required" });
}
try
{
var payload = await _verifier.VerifyAsync(sessionToken);
// In a production app, you'd store the tenant connection in your database here
_logger.LogInformation("Tenant connected: {TenantId}", payload.TenantId);
return Ok(new
{
success = true,
tenantId = payload.TenantId,
userId = payload.UserId,
tenantSlug = payload.TenantSlug,
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Connection failed");
return Unauthorized(new { error = "Failed to verify session token" });
}
}
}
```
The controller reads the session token from the `X-Session-ID` request header, hands it to the verifier, and returns the tenant details on success or a 401 on failure. The `[ApiController]` attribute handles model binding and validation automatically.
See the [Tenant Mapping](/guides/cloud-apps/authentication-login#tenant-mapping) section for more on managing tenants in production.
## 7. Wire up Services and CORS
ASP.NET Core needs to know about the services it should inject and the controllers it should expose. Replace the contents of `Backend/Program.cs`:
```csharp theme={null}
using Backend.Services;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddHttpClient();
builder.Services.AddHttpClient();
// Allow the Vite dev server to call the API during development
builder.Services.AddCors(options =>
{
options.AddDefaultPolicy(policy =>
{
policy.WithOrigins("http://localhost:5173")
.AllowAnyHeader()
.AllowAnyMethod();
});
});
var app = builder.Build();
app.UseCors();
app.MapControllers();
app.Run();
```
`AddHttpClient` does two things at once: it registers the service in the DI container and gives each instance its own `HttpClient` from the built-in factory.
The CORS policy allows requests from the Vite dev server on port 5173. The dev proxy in `vite.config.ts` already routes frontend `fetch('/api/...')` calls to this backend, but the CORS middleware is a useful safety net during development.
## 8. Configure the Backend Port
By default, `dotnet new webapi` listens on a random port chosen at startup, but the frontend's Vite dev proxy expects the backend on `http://localhost:5273`. Pin the port in `Backend/Properties/launchSettings.json` by replacing the `applicationUrl` value in the `http` profile:
```json theme={null}
{
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": false,
"applicationUrl": "http://localhost:5273",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
```
You can leave the other profiles (`https`, `IIS Express`) in place. The `dotnet run` command picks the `http` profile by default during development.
## 9. Run the Backend
Start the backend:
```bash theme={null}
dotnet run
```
You should see output like:
```
Now listening on: http://localhost:5273
Application started. Press Ctrl+C to shut down.
```
In a second terminal, send a request with a fake session token to confirm the route is reachable:
```bash theme={null}
curl http://localhost:5273/api/connect-tenant \
-H "X-Session-ID: fake-token"
```
You should get back a `401` response with `{"error":"Failed to verify session token"}`. A real session token from the App Shell will follow the same path and succeed.
## Common Issues
This error means the backend started but couldn't find your credentials in configuration. The most common cause is that user-secrets weren't initialised, or were set in a different directory than the project expects.
User-secrets are scoped to a specific project, identified by the `UserSecretsId` GUID in the `.csproj` file. Running `dotnet user-secrets list` from inside the `Backend/` directory will show whether the secrets are present for this project. If the list comes back empty, running `dotnet user-secrets init` followed by the two `dotnet user-secrets set` commands from earlier in the guide will populate them.
It's also worth confirming that you ran the user-secrets commands from the `Backend/` directory and not the project root. The tool resolves the target project based on the current working directory.
A 401 from JTL's auth endpoint means the credentials being sent aren't recognised. Until you've registered your app in the Partner Portal, this is the expected response, since the placeholder values from earlier aren't real credentials. The next page in this guide walks through registration and provides the real values.
If you've already registered the app and are still seeing this error, the most likely causes are typos in the user-secrets values and forgetting to restart the backend after updating them. ASP.NET Core reads configuration once at startup, so changes to user-secrets take effect only on the next `dotnet run`. The `dotnet user-secrets list` command is the fastest way to confirm the stored values match what the Partner Portal showed you.
A CORS error usually means the request reached the backend but the browser blocked the response because the origin didn't match what the backend allows. The CORS policy in `Program.cs` is configured to allow `http://localhost:5173`, which matches the default Vite dev server port.
If the Vite dev server is running on a different port (for example, because port 5173 was already in use and Vite picked 5174 instead), the browser will see a mismatch. Updating the `WithOrigins` value in `Program.cs` to match the actual Vite port, or freeing up port 5173, should resolve it.
Worth noting: when the Vite dev proxy is forwarding `/api/*` requests, the browser shouldn't actually see CORS at all, since the requests look same-origin from the browser's perspective. CORS errors usually appear when something is calling the backend directly on `localhost:5273` instead of going through the proxy.
If `dotnet run` reports a different port (for example, 5000 or a random high number), the `launchSettings.json` change from earlier in the guide either hasn't been saved or isn't being picked up.
Confirming that `Backend/Properties/launchSettings.json` contains `"applicationUrl": "http://localhost:5273"` in the `http` profile, then stopping and restarting `dotnet run`, should pin the port. If `dotnet run` is using a different profile than expected, passing `--launch-profile http` explicitly will force it to use the right one.
An alternative if you'd rather not edit `launchSettings.json` is to set the `ASPNETCORE_URLS` environment variable: `ASPNETCORE_URLS=http://localhost:5273 dotnet run`. This works without any config file changes.
## Next: Connect and Fetch Data
The backend verifies session tokens and is ready to call the JTL Cloud API. The remaining work is registering your app with JTL to get real credentials, installing the app in the JTL Hub, and pulling product data from JTL-Wawi:
Register your app, install it in the JTL Hub, and fetch products from JTL-Wawi.
# Node.js
Source: https://developer.jtl-software.com/get-started/quick-start/from-scratch/backend-node
Build the Express backend for your JTL Cloud App. Verify session tokens, fetch access tokens, and proxy requests to the JTL Cloud API.
Build the Express backend for a JTL Cloud App using Node.js, TypeScript, and the `jose` library for JWT verification. By the end, the backend runs locally and the frontend's "Waiting for backend" placeholder turns into a real connection.
**Stack:** Node.js 24.16.0+, Express, TypeScript, `jose` for JWT verification.
## Prerequisites
You need:
* ✅ **A finished frontend** from the [Build the Frontend](/get-started/quick-start/from-scratch/frontend) page, running locally on `http://localhost:5173`
* ✅ **[Node.js](https://nodejs.org/) v24.16.0 or higher** (current LTS, includes `npm`). Verify with `node --version` and `npm --version`
## What you're Building
During setup, your backend verifies that the session token from your frontend is valid and was issued by JTL.
To do this:
* Your backend authenticates with JTL using its client credentials
* Fetches JTL's public keys (JWKS)
* And uses them to verify the session token's signature
```mermaid theme={null}
sequenceDiagram
participant FE as Your Frontend
participant BE as Your Backend (Express)
participant Auth as JTL Auth
participant API as JTL Cloud API
FE->>BE: POST /api/connect-tenant (session token)
BE->>Auth: POST /oauth2/token (client credentials)
Auth-->>BE: Access token (JWT)
BE->>API: GET /.well-known/jwks.json (with access token)
API-->>BE: Public keys (JWKS)
BE->>BE: Verify session token signature
BE-->>FE: Verified tenant info
```
Once verified, the token tells your backend which tenant (merchant) and user is using your app. Your backend can then make tenant-scoped requests to the JTL Cloud API on their behalf.
## 1. Set up the Project
Create a `backend` folder alongside the existing `frontend` folder, then initialize it.
```bash theme={null}
cd my-jtl-app
mkdir backend
cd backend
npm init -y
```
Your project structure now looks like this:
```
my-jtl-app/
├── frontend/ # From the previous page
└── backend/ # New
```
## 2. Install Packages
```bash theme={null}
npm install express cors jose
npm install -D typescript tsx @types/node @types/express @types/cors
```
| Package | Purpose |
| ------------ | ---------------------------------------------------------------------- |
| `express` | HTTP server and routing |
| `cors` | Allows the frontend dev server to call the backend during development |
| `jose` | Verifies JWTs using JTL's public keys |
| `typescript` | Type checking and `tsc` compiler |
| `tsx` | Runs TypeScript files directly during development without a build step |
| `@types/*` | Type definitions for the runtime packages |
## 3. Configure TypeScript
Create `backend/tsconfig.json`:
```json theme={null}
{
"compilerOptions": {
"target": "ES2022",
"module": "NodeNext",
"moduleResolution": "NodeNext",
"esModuleInterop": true,
"strict": true,
"skipLibCheck": true,
"outDir": "dist",
"rootDir": "src"
},
"include": ["src/**/*"]
}
```
This configuration uses Node's native ESM support (`NodeNext`) with strict type checking. The `outDir` and `rootDir` settings keep compiled output separate from source files when you eventually build for production.
## 4. Set up Environment Variables
The backend needs two secrets: a client ID and a client secret, both issued by JTL when you create your app. You will get the real values from the [Partner Portal](https://partner.jtl-cloud.com) in the next page. For now, create the file with placeholder values so the rest of the setup works.
Create `backend/.env`:
```dotenv theme={null}
CLIENT_ID=your-client-id-here
CLIENT_SECRET=your-client-secret-here
PORT=5273
```
The frontend's Vite dev proxy is already configured to forward `/api/*` requests to `localhost:5273`, so the `PORT` value matches that target.
Add `.env` to `backend/.gitignore` so the secrets don't end up in version control:
```
node_modules
dist
.env
```
## 5. Build the Auth Helper
The first piece of the backend is a function that authenticates with JTL using your client credentials and returns an access token. This token has two uses: fetching the public keys for session token verification, and making tenant-scoped calls to the JTL Cloud API.
Create `backend/src/jtl-auth.ts`:
```typescript theme={null}
const AUTH_ENDPOINT = 'https://auth.jtl-cloud.com/oauth2/token';
const API_BASE_URL = 'https://api.jtl-cloud.com';
export function getApiBaseUrl(): string {
return API_BASE_URL;
}
export async function getJwt(): Promise {
const clientId = process.env.CLIENT_ID;
const clientSecret = process.env.CLIENT_SECRET;
if (!clientId || !clientSecret) {
throw new Error('CLIENT_ID and CLIENT_SECRET must be defined in .env');
}
const authString = Buffer.from(`${clientId}:${clientSecret}`).toString(
'base64',
);
const response = await fetch(AUTH_ENDPOINT, {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
Authorization: `Basic ${authString}`,
},
body: new URLSearchParams({ grant_type: 'client_credentials' }),
});
const data = await response.json();
if (!response.ok) {
throw new Error(
`Failed to fetch JWT (${response.status}): ${data.error}`,
);
}
return data.access_token;
}
```
This encodes the client credentials as Base64, sends a `client_credentials` grant request to JTL's auth endpoint, and returns the resulting access token. The token is short-lived, so the function fetches a fresh one on each call. For higher-traffic backends you'd add caching.
## 6. Build the Session Verifier
With an access token in hand, the backend can fetch the public keys it needs to verify session tokens. The `jose` library handles the cryptographic work once it has the public key in the right format.
Create `backend/src/verify-session.ts`:
```typescript theme={null}
import { importJWK, jwtVerify } from 'jose';
import { getJwt, getApiBaseUrl } from './jtl-auth.js';
export interface SessionTokenPayload {
exp: number;
userId: string;
tenantId: string;
tenantSlug: string;
}
export async function verifySessionToken(
sessionToken: string,
): Promise {
const accessToken = await getJwt();
const baseUrl = getApiBaseUrl();
const response = await fetch(`${baseUrl}/account/.well-known/jwks.json`, {
headers: { Authorization: `Bearer ${accessToken}` },
});
if (!response.ok) {
throw new Error(`Failed to fetch JWKS (${response.status})`);
}
const jwks = await response.json();
// Select the signing key by its JWK properties (use=sig, alg=EdDSA)
const signingKey = jwks.keys.find(
(k: { use?: string; alg?: string }) =>
k.use === 'sig' && k.alg === 'EdDSA',
);
if (!signingKey) {
throw new Error('No EdDSA signing key found in JWKS');
}
const publicKey = await importJWK(signingKey, 'EdDSA');
const { payload } = await jwtVerify(sessionToken, publicKey);
return payload as unknown as SessionTokenPayload;
}
```
The function fetches the JWKS document from the JTL API, imports the first key as an EdDSA public key, and asks `jose` to verify the session token's signature against it. If the signature is valid and the token isn't expired, `jwtVerify` returns the decoded payload. If anything is wrong, it throws an error.
## 7. Build the Connect Tenant Endpoint
Now connect the verifier into an Express route. The frontend's shell layout sends the session token to `/api/connect-tenant` and expects a tenant ID back.
Create `backend/src/server.ts`:
```typescript theme={null}
import express, { type Request, type Response } from 'express';
import cors from 'cors';
import { verifySessionToken } from './verify-session.js';
const app = express();
const port = Number(process.env.PORT) || 5273;
app.use(cors({ origin: 'http://localhost:5173' }));
app.use(express.json());
app.get('/api/connect-tenant', async (req: Request, res: Response) => {
const sessionToken = req.headers['x-session-id'] as string;
if (!sessionToken) {
return res.status(400).json({ error: 'Session token is required' });
}
try {
const payload = await verifySessionToken(sessionToken);
// In a production app, you'd store the tenant connection in your database here
console.log('Tenant connected:', payload.tenantId);
return res.json({
success: true,
tenantId: payload.tenantId,
userId: payload.userId,
tenantSlug: payload.tenantSlug,
});
} catch (error) {
console.error('Connection failed:', error);
return res
.status(401)
.json({ error: 'Failed to verify session token' });
}
});
app.listen(port, () => {
console.log(`Backend listening on http://localhost:${port}`);
});
```
CORS is configured to allow requests from the Vite dev server on port 5173. The dev proxy in `vite.config.ts` already routes frontend `fetch('/api/...')` calls to this backend, but the CORS middleware is a useful safety net during development and stays out of the way in production.
See the [Tenant Mapping](/guides/cloud-apps/authentication-login#tenant-mapping) section for more on managing tenants in production.
## 8. Add Run Scripts
Open `backend/package.json` and replace the `scripts` block:
```json theme={null}
"scripts": {
"dev": "tsx watch --env-file=.env src/server.ts",
"build": "tsc",
"start": "node --env-file=.env dist/server.js"
}
```
The `dev` script uses `tsx watch` to run TypeScript directly, restarting the server when any source file changes. The `--env-file=.env` flag loads environment variables natively without needing `dotenv`. The `build` and `start` scripts compile to JavaScript and run the compiled output for production.
Also update the `"type": "commonjs"` to `"type": "module"` below the `scripts` in the `package.json` file so that Node can treat `.js` files as ES modules.
## 9. Run the Backend
Start the dev server:
```bash theme={null}
npm run dev
```
You should see:
```
Backend listening on http://localhost:5273
```
In a second terminal, send a request with a fake session token to confirm the route is reachable:
```bash theme={null}
curl http://localhost:5273/api/connect-tenant \
-H "x-Session-id: fake-token"
```
You should get back a `401` response with `{"error":"Failed to verify session token"}`. A real session token from the App Shell will follow the same path and succeed.
## Common Issues
This error usually means TypeScript and Node are resolving modules differently.
With `"type": "module"` in `package.json` and `"module": "NodeNext"` in `tsconfig.json`, Node expects ES module imports to include file extensions. Even if your source file is `jtl-auth.ts`, the import must use `./jtl-auth.js`.
TypeScript resolves this correctly during development, and Node finds the compiled `.js` file at runtime.
If you prefer not to use `.js` extensions, switch to `"module": "CommonJS"` in `tsconfig.json` and remove `"type": "module"` from `package.json`.
This means the backend started without loading your environment variables.
The most common cause is running Node without the `--env-file=.env` flag. In that case, the `.env` file exists but is never read.
The `dev` and `start` scripts already include this flag. If you're running the server manually, add it back or use `npm run dev`.
Also confirm that the `.env` file is inside the `backend/` directory. The path is resolved relative to where Node is executed.
A 401 from the auth endpoint means the credentials are not valid.
If you are still using placeholder values, this is expected. Real credentials are provided after registering your app in the Partner Portal.
If you have already registered:
* check for typos or extra spaces in `.env`
* restart the dev server after making changes
Environment variables are only read at startup, so updates to `.env` require a restart.
This means the browser blocked the response due to an origin mismatch.
The backend allows requests from `http://localhost:5173`, which is the default Vite dev server port. If Vite runs on a different port (for example, 5174), the request will be rejected.
Update the `origin` in `server.ts` to match the actual port, or restart Vite on 5173.
If you're using the Vite dev proxy for `/api/*`, CORS should not appear. Seeing this error usually means the request is being made directly to the backend instead of going through the proxy.
## Next: Connect and Fetch Data
The backend verifies session tokens and is ready to call the JTL Cloud API. The remaining work is registering your app with JTL to get real credentials, installing the app in the JTL Hub, and pulling product data from JTL-Wawi:
Register your app, install it in the JTL Hub, and fetch products from
JTL-Wawi.
# PHP
Source: https://developer.jtl-software.com/get-started/quick-start/from-scratch/backend-php
Build the Slim backend for your JTL Cloud App. Verify session tokens, fetch access tokens, and proxy requests to the JTL Cloud API.
Build the Slim 4 backend for a JTL Cloud App using PHP 8 and the built-in `sodium_crypto_sign_verify_detached` function for Ed25519 signature verification. By the end, the backend runs locally and the frontend's "Waiting for backend" placeholder turns into a real connection.
**Stack:** PHP 8.1+, Slim 4, Guzzle for HTTP requests, `vlucas/phpdotenv` for environment variables, native `ext-sodium` for JWT verification.
## Prerequisites
You need:
* ✅ **A finished frontend** from the [Build the Frontend](/get-started/quick-start/from-scratch/frontend) page, running locally on `http://localhost:5173`
* ✅ **[PHP](https://www.php.net/downloads) 8.1 or higher** with `ext-sodium` enabled. Run `php --version` and `php -m | grep sodium` to check.
* ✅ **[Composer](https://getcomposer.org/)** for dependency management. Run `composer --version` to check.
## What you're Building
During setup, your backend verifies that the session token from your frontend is valid and was issued by JTL.
To do this:
* Your backend authenticates with JTL using its client credentials
* Fetches JTL's public keys (JWKS)
* And uses them to verify the session token's signature
```mermaid theme={null}
sequenceDiagram
participant FE as Your Frontend
participant BE as Your Backend (Slim)
participant Auth as JTL Auth
participant API as JTL Cloud API
FE->>BE: GET /api/connect-tenant (X-Session-ID: token)
BE->>Auth: POST /oauth2/token (client credentials)
Auth-->>BE: Access token (JWT)
BE->>API: GET /.well-known/jwks.json (with access token)
API-->>BE: Public keys (JWKS)
BE->>BE: Verify session token signature
BE-->>FE: Verified tenant info
```
Once verified, the token tells your backend which tenant (merchant) and user is using your app. Your backend can then make tenant-scoped requests to the JTL Cloud API on their behalf.
## 1. Set up the Project
Create a `backend` folder alongside the existing `frontend` folder, then initialise a Composer project inside it.
```bash theme={null}
cd my-jtl-app
mkdir backend
cd backend
composer init --name="my-jtl-app/backend" --type=project --no-interaction
```
Your project structure now looks like this:
```
my-jtl-app/
├── frontend/ # From the previous page
└── backend/ # New
```
## 2. Install Packages
```bash theme={null}
composer require slim/slim slim/psr7 guzzlehttp/guzzle vlucas/phpdotenv
```
| Package | Purpose |
| ------------------- | ------------------------------------------------------------------ |
| `slim/slim` | The Slim 4 micro-framework: routing, request and response handling |
| `slim/psr7` | The PSR-7 implementation Slim uses by default |
| `guzzlehttp/guzzle` | HTTP client for making requests to JTL APIs |
| `vlucas/phpdotenv` | Loads environment variables from a `.env` file |
## 3. Set up Environment Variables
Create `backend/.env`:
```dotenv theme={null}
CLIENT_ID=your-client-id-here
CLIENT_SECRET=your-client-secret-here
PORT=5273
```
The frontend's Vite dev proxy is already configured to forward `/api/*` requests to `localhost:5273`, so the `PORT` value matches that target.
Add `.env` and `vendor/` to `backend/.gitignore` so secrets and dependencies don't end up in version control:
```
vendor
.env
```
## 4. Build the Auth Helper
The first piece of the backend is a function that authenticates with JTL using your client credentials and returns an access token. This token has two uses: fetching the public keys for session token verification, and making tenant-scoped calls to the JTL Cloud API.
Create `backend/src/JtlAuth.php`:
```php theme={null}
cachedToken !== null && time() < $this->tokenExpiresAt) {
return $this->cachedToken;
}
if (empty($this->clientId) || empty($this->clientSecret)) {
throw new \RuntimeException('CLIENT_ID and CLIENT_SECRET must be defined in .env');
}
$authString = base64_encode("{$this->clientId}:{$this->clientSecret}");
$response = $this->httpClient->request('POST', self::AUTH_ENDPOINT, [
'http_errors' => false,
'headers' => [
'Content-Type' => 'application/x-www-form-urlencoded',
'Accept' => 'application/json',
'Authorization' => "Basic {$authString}",
],
'form_params' => ['grant_type' => 'client_credentials'],
]);
$statusCode = $response->getStatusCode();
$body = $response->getBody()->getContents();
if ($statusCode < 200 || $statusCode >= 300) {
throw new \RuntimeException("Failed to fetch JWT ({$statusCode}): {$body}");
}
$data = json_decode($body, true);
$expiresIn = $data['expires_in'] ?? 3600;
$this->cachedToken = $data['access_token'];
$this->tokenExpiresAt = time() + $expiresIn - 30;
return $this->cachedToken;
}
}
```
The credentials are Base64-encoded and sent as a `client_credentials` grant to JTL's auth endpoint. The access token is cached in memory until 30 seconds before expiry, so repeat calls within the same request reuse it. For cross-request reuse, swap the in-memory cache for APCu or another shared cache.
## 5. Build the Session Verifier
With an access token in hand, the backend can fetch the public keys it needs to verify session tokens. The `sodium_crypto_sign_verify_detached` function verifies Ed25519 signatures directly against the public key.
Create `backend/src/SessionVerifier.php`:
```php theme={null}
auth->getJwt();
$response = $this->httpClient->request('GET', JtlAuth::API_BASE_URL . '/account/.well-known/jwks.json', [
'http_errors' => false,
'headers' => [
'Authorization' => "Bearer {$accessToken}",
'Accept' => 'application/json',
],
]);
$statusCode = $response->getStatusCode();
$body = $response->getBody()->getContents();
if ($statusCode < 200 || $statusCode >= 300) {
throw new \RuntimeException("Failed to fetch JWKS ({$statusCode})");
}
$jwks = json_decode($body, true);
// Select the signing key by its JWK properties (use=sig, alg=EdDSA)
$signingKey = null;
foreach ($jwks['keys'] as $k) {
if (($k['use'] ?? null) === 'sig' && ($k['alg'] ?? null) === 'EdDSA') {
$signingKey = $k;
break;
}
}
if ($signingKey === null) {
throw new \RuntimeException('No EdDSA signing key found in JWKS');
}
$publicKey = $this->base64UrlDecode($signingKey['x']);
return $this->verifyAndDecode($sessionToken, $publicKey);
}
private function verifyAndDecode(string $token, string $publicKey): array
{
$parts = explode('.', $token);
if (count($parts) !== 3) {
throw new \InvalidArgumentException('Invalid JWT format. Expected 3 dot-separated parts.');
}
[$header, $payload, $signature] = $parts;
$signedData = "{$header}.{$payload}";
$signatureBytes = $this->base64UrlDecode($signature);
if (!sodium_crypto_sign_verify_detached($signatureBytes, $signedData, $publicKey)) {
throw new \RuntimeException('Invalid token signature.');
}
$decodedPayload = json_decode($this->base64UrlDecode($payload), true);
if (($decodedPayload['exp'] ?? 0) < time()) {
throw new \RuntimeException('Token has expired.');
}
return [
'exp' => $decodedPayload['exp'],
'userId' => $decodedPayload['userId'],
'tenantId' => $decodedPayload['tenantId'],
'tenantSlug' => $decodedPayload['tenantSlug'] ?? null,
];
}
private function base64UrlDecode(string $input): string
{
$padded = strtr($input, '-_', '+/');
$remainder = strlen($padded) % 4;
if ($remainder > 0) {
$padded .= str_repeat('=', 4 - $remainder);
}
return base64_decode($padded);
}
}
```
The class fetches the JWKS document, selects the EdDSA signing key, and verifies the session token's signature using `sodium_crypto_sign_verify_detached`. If the signature is valid and the token isn't expired, the method returns the decoded payload as an associative array.
## 6. Build the Connect Tenant Endpoint
Now connect the verifier into a Slim route. The frontend's shell layout sends the session token to `/api/connect-tenant` via the `X-Session-ID` header.
Create `backend/public/index.php`:
```php theme={null}
load();
$httpClient = new Client();
$auth = new JtlAuth($_ENV['CLIENT_ID'] ?? '', $_ENV['CLIENT_SECRET'] ?? '', $httpClient);
$verifier = new SessionVerifier($auth, $httpClient);
$app = AppFactory::create();
$app->addBodyParsingMiddleware();
// Allow the Vite dev server to call the API during development
$app->add(function (Request $request, $handler) {
$response = $handler->handle($request);
return $response
->withHeader('Access-Control-Allow-Origin', 'http://localhost:5173')
->withHeader('Access-Control-Allow-Headers', 'X-Session-ID, Authorization, Content-Type')
->withHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
});
$app->options('/{routes:.+}', fn(Request $req, Response $res) => $res);
$app->get('/api/connect-tenant', function (Request $request, Response $response) use ($verifier) {
$sessionToken = $request->getHeaderLine('X-Session-ID');
if (empty($sessionToken)) {
$response->getBody()->write(json_encode(['error' => 'Session token is required']));
return $response->withStatus(400)->withHeader('Content-Type', 'application/json');
}
try {
$payload = $verifier->verify($sessionToken);
// In a production app, you'd store the tenant connection in your database here
error_log("Tenant connected: {$payload['tenantId']}");
$response->getBody()->write(json_encode([
'success' => true,
'tenantId' => $payload['tenantId'],
'userId' => $payload['userId'],
'tenantSlug' => $payload['tenantSlug'],
]));
return $response->withHeader('Content-Type', 'application/json');
} catch (\Throwable $e) {
error_log("Connection failed: {$e->getMessage()}");
$response->getBody()->write(json_encode(['error' => 'Failed to verify session token']));
return $response->withStatus(401)->withHeader('Content-Type', 'application/json');
}
});
$app->run();
```
The bootstrap loads `.env`, instantiates `JtlAuth` with the credentials, and passes that into `SessionVerifier`. Both instances are then captured by the route closure via `use ($verifier)` and shared across requests.
The CORS middleware allows requests from the Vite dev server on port 5173. The dev proxy in `vite.config.ts` already routes frontend `fetch('/api/...')` calls to this backend, but the CORS headers are a useful safety net during development.
See the [Tenant Mapping](/guides/cloud-apps/authentication-login#tenant-mapping) section for more on managing tenants in production.
## 7. Configure Composer Autoloading
Open `backend/composer.json` and add a `psr-4` autoload mapping for the `App\` namespace:
```json theme={null}
{
"name": "my-jtl-app/backend",
"type": "project",
"require": {
"slim/slim": "^4.15",
"slim/psr7": "^1.7",
"guzzlehttp/guzzle": "^7.9",
"vlucas/phpdotenv": "^5.6"
},
"autoload": {
"psr-4": {
"App\\": "src/"
}
}
}
```
Then regenerate the autoloader so Composer picks up the new mapping:
```bash theme={null}
composer dump-autoload
```
This tells Composer that any class in the `App\` namespace lives under the `src/` directory, which is how `JtlAuth` and `SessionVerifier` get loaded when `index.php` references them.
## 8. Run the Backend
Start the dev server:
```bash theme={null}
php -S localhost:5273 -t public
```
You should see:
```
PHP 8.x.x Development Server (http://localhost:5273) started
```
In a second terminal, send a request with a fake session token to confirm the route is reachable:
```bash theme={null}
curl http://localhost:5273/api/connect-tenant \
-H "X-Session-ID: fake-token"
```
You should get back a `401` response with `{"error":"Failed to verify session token"}`. That's the expected outcome for an invalid token. A real session token from the App Shell will follow the same path and succeed.
## Common Issues
This error means Composer's autoloader doesn't know where to find the class. The most common cause is forgetting to regenerate the autoload files after adding the `psr-4` mapping to `composer.json`.
Running `composer dump-autoload` from the `backend/` directory rebuilds `vendor/autoload.php` to include any new namespace mappings. The error should clear after the next request.
This error means the backend started but couldn't find your credentials in the environment. The most common cause is that `.env` is sitting in the wrong directory, or that the `Dotenv::createImmutable()` call is pointing at the wrong path.
This error means PHP's sodium extension isn't enabled. The extension ships with PHP 7.2 and later and is enabled by default on most distributions, but some minimal PHP installations (particularly Docker images and shared hosts) ship without it.
Running `php -m | grep sodium` will confirm whether the extension is loaded. If the command returns nothing, the extension needs to be enabled.
A 401 from the auth endpoint means the credentials are not valid.
If you are still using placeholder values, this is expected. Real credentials are provided after registering your app in the Partner Portal.
If you have already registered:
* check for typos or extra spaces in `.env`
* restart the dev server after making changes
Environment variables are only read at startup, so updates to `.env` require a restart.
A CORS error usually means the request reached the backend but the browser blocked the response because the origin didn't match what the backend allows. The CORS middleware in `index.php` is configured to allow `http://localhost:5173`, which matches the default Vite dev server port.
If the Vite dev server is running on a different port (for example, because port 5173 was already in use and Vite picked 5174 instead), the browser will see a mismatch. Updating the `Access-Control-Allow-Origin` value in `index.php` to match the actual Vite port, or freeing up port 5173, should resolve it.
## Next: Connect and Fetch Data
The backend verifies session tokens and is ready to call the JTL Cloud API. The remaining work is registering your app with JTL to get real credentials, installing the app in the JTL Hub, and pulling product data from JTL-Wawi:
Register your app, install it in the JTL Hub, and fetch products from
JTL-Wawi.
# Connect and Fetch Data
Source: https://developer.jtl-software.com/get-started/quick-start/from-scratch/connect-and-fetch
Register your app with JTL, install it in the JTL Hub, and fetch real product data from JTL-Wawi.
Bring everything together. Register your app with JTL to get real credentials, install it in the JTL Hub, then add an items endpoint to your backend and a product table to your frontend.
## Prerequisites
You need:
* ✅ **A finished frontend** from the [Build the Frontend](/get-started/quick-start/from-scratch/frontend) guide
* ✅ **A finished backend** from either the [Node.js](/get-started/quick-start/from-scratch/backend-node), [C#](/get-started/quick-start/from-scratch/backend-csharp), or [PHP](/get-started/quick-start/from-scratch/backend-php) guide
* ✅ **A JTL ID** (your login to the JTL ecosystem)
* ✅ **Access to an organization (tenant) in the [Partner Portal](https://partner.jtl-cloud.com)** (created automatically on first login if you don’t have one yet)
* ✅ **[JTL-Wawi](https://www.jtl-software.com/de/warenwirtschaftssystem-software/jtl-wawi-download)** installed and running locally, with at least one product, and connected to JTL Cloud.
If you don’t have JTL Cloud set up yet, follow the step-by-step guide: [Create a Developer Account](/get-started/create-developer-account).
## What you're Building
So far, the frontend and backend are only loosely connected. The frontend can render the app, and the backend can verify authentication tokens, but neither side is yet tied to a real merchant installation. This guide closes the loop.
```mermaid theme={null}
sequenceDiagram
participant Dev as You
participant Portal as Partner Portal
participant Hub as JTL Hub
participant App as Your App
participant Wawi as JTL-Wawi
Dev->>Portal: Register app with manifest
Portal-->>Dev: Client ID + Client Secret
Dev->>Hub: Install app in test tenant
Hub->>App: Loads /setup in iframe
App->>App: Verifies session, completes handshake
Dev->>App: Opens /erp menu item
App->>Wawi: GET /api/items (with session token)
Wawi-->>App: Product data
```
By the end, opening the app from the ERP Cloud menu will show a table of real products from JTL-Wawi.
## 1. Create the Manifest
The manifest tells JTL three things: how your app integrates technically, how it appears in the App Store, and where to send merchants when they install or open it.
Create `manifest.json` in the project root:
```json theme={null}
{
"manifest": {
"version": "1.0.0",
"technicalName": "my-jtl-app",
"lifecycle": {
"configurationUrl": "http://localhost:5173/setup"
},
"capabilities": {
"hub": {
"appLauncher": {
"redirectUrl": "http://localhost:5173/hub"
}
},
"erp": {
"menuItems": [
{
"id": "my-app-menu",
"name": "My JTL App",
"url": "http://localhost:5173/erp"
}
],
"api": {
"scopes": []
}
}
}
},
"listing": {
"version": "1.0.0",
"defaultLocale": "en",
"name": {
"en": {
"short": "my-jtl-app",
"full": "My JTL Cloud App"
}
},
"description": {
"en": {
"short": "A Cloud App built from scratch",
"full": "A sample Cloud App built from scratch using Vite, React, and TypeScript."
}
},
"media": {
"icons": {
"light": "https://hub.jtl-cloud.com/assets/image-placeholder.png",
"dark": "https://hub.jtl-cloud.com/assets/image-placeholder.png"
}
},
"support": {
"url": {
"en": "https://support.example.com/help"
}
},
"legal": {
"privacyPolicy": "https://example.com/privacy",
"termsOfUse": "https://example.com/terms",
"gdpr": {
"request": "https://example.com/gdpr/request",
"delete": "https://example.com/gdpr/delete"
}
}
}
}
```
The three URLs under `capabilities` map directly to the three frontend routes:
| Manifest field | Page in your code |
| --------------------------------------------------- | ------------------ |
| `manifest.lifecycle.configurationUrl` | `_shell.setup.tsx` |
| `manifest.capabilities.hub.appLauncher.redirectUrl` | `hub.tsx` |
| `manifest.capabilities.erp.menuItems[].url` | `_shell.erp.tsx` |
The example uses `http://localhost:5173/...` for the manifest URLs and `https://example.com/...` for the listing URLs. When you deploy, replace both with your real production domain. All URLs must be publicly reachable. `localhost` works only because the JTL App Shell runs in your browser, not on JTL's servers.
## 2. Register your App
Go to [Partner Portal](https://partner.jtl-cloud.com/) and log in.
Click **+ Create**. You'll see a manifest editor with a pre-filled example.
Replace the example manifest with the contents of your `manifest.json` file. Click **Register app**.
After registration, you'll see your **Client ID** and **Client Secret**.
The Client Secret is shown only once. Copy the value immediately. If you lose it, you'll need to register a new app.
## 3. Update your Backend Credentials
Replace the placeholder values you set earlier with the real Client ID and Client Secret.
Open `backend/.env` and replace the placeholder values:
```dotenv theme={null}
CLIENT_ID=your-actual-client-id
CLIENT_SECRET=your-actual-client-secret
PORT=5273
```
The `tsx watch` command picks up source file changes automatically, but environment variables are read once at startup. Stop and restart the backend to pick up the new values.
From the `Backend/` directory, update the user-secrets values:
```bash theme={null}
dotnet user-secrets set "Jtl:ClientId" "your-actual-client-id"
dotnet user-secrets set "Jtl:ClientSecret" "your-actual-client-secret"
```
ASP.NET Core reads configuration once at startup. Stop and restart the backend to pick up the new values.
Open `backend/.env` and replace the placeholder values:
```dotenv theme={null}
CLIENT_ID=your-actual-client-id
CLIENT_SECRET=your-actual-client-secret
PORT=5273
```
PHP's built-in development server reads environment variables once at startup. Stop the server with `Ctrl+C` and start it again to pick up the new values:
## 4. Run Both Processes
You need both the frontend and backend running. Open two terminals from the project root.
**Terminal 1 (backend):**
```bash theme={null}
cd backend
npm run dev
```
```bash theme={null}
cd Backend
dotnet run
```
```bash theme={null}
cd backend
php -S localhost:5273 -t public
```
**Terminal 2 (frontend):**
```bash theme={null}
cd frontend
npm run dev
```
Opening `http://localhost:5173` directly in a browser will show a blank page or the placeholder error state. The app is meant to be rendered inside the JTL App Shell, which is what the next step covers.
## 5. Install the App in JTL Hub
Go to [JTL Hub](https://hub.jtl-cloud.com/) and log in.
Navigate to the **Manage apps** menu and click the **Apps in development** tab. You should see your newly registered app.
Once the app is installed, you'll see a success screen with the option to configure the app. Click the **Configure app** button to proceed to the next step.
Click the **Complete Setup** button on your setup page. This triggers the full setup handshake between your app and JTL.
The setup page now displays a valid tenant ID. This confirms that the session token was successfully verified through your backend and that the App Shell recognizes the installation as complete.
## 6. Add an Items Endpoint
The backend can now make tenant-scoped calls to the JTL Cloud API. The next step is adding an endpoint that fetches products from JTL-Wawi via GraphQL.
Every API request that needs to access tenant data needs an `X-Tenant-ID` header. The backend extracts this value from the verified session token payload. See the [Session Token Payload](/guides/essentials/authentication/api-keys-tokens#payload) reference for details.
Add the items route to `backend/src/server.ts`. Place it alongside the existing `connect-tenant` route:
```typescript theme={null}
import { getJwt } from './jtl-auth.js';
app.get('/api/items', async (req: Request, res: Response) => {
const authHeader = req.header('authorization');
if (!authHeader?.startsWith('Bearer ')) {
return res.status(401).json({ error: 'Missing or invalid Authorization header' });
}
const sessionToken = authHeader.slice(7);
try {
const payload = await verifySessionToken(sessionToken);
const accessToken = await getJwt();
const response = await fetch('https://api.jtl-cloud.com/erp/v2/graphql', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${accessToken}`,
'X-Tenant-ID': payload.tenantId,
},
body: JSON.stringify({
operationName: 'GetERPItems',
query: `
query GetERPItems {
QueryItems(first: 10) {
nodes { id sku name notes basePriceUnit }
totalCount
}
}
`,
}),
});
const body = await response.json();
return res.json(body);
} catch (error) {
console.error('Failed to fetch items:', error);
return res.status(500).json({ error: 'Failed to fetch items' });
}
});
```
The route reads the session token from the `Authorization` header (sent by the frontend as a `Bearer` token), verifies it to extract the tenant ID, fetches a fresh access token, and forwards the GraphQL response back to the frontend as-is.
Create `Backend/Controllers/ItemsController.cs`:
```csharp theme={null}
using System.Net.Http.Headers;
using System.Text;
using Backend.Services;
using Microsoft.AspNetCore.Mvc;
namespace Backend.Controllers;
[ApiController]
[Route("api/items")]
public class ItemsController : ControllerBase
{
private readonly HttpClient _http;
private readonly JtlAuthService _auth;
private readonly SessionVerifier _verifier;
public ItemsController(
IHttpClientFactory httpFactory,
JtlAuthService auth,
SessionVerifier verifier)
{
_http = httpFactory.CreateClient();
_auth = auth;
_verifier = verifier;
}
[HttpGet]
public async Task Get()
{
var authHeader = Request.Headers.Authorization.ToString();
if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Bearer "))
{
return Unauthorized(new { error = "Missing or invalid Authorization header" });
}
var sessionToken = authHeader.Substring("Bearer ".Length);
try
{
var payload = await _verifier.VerifyAsync(sessionToken);
var accessToken = await _auth.GetJwtAsync();
var query = """
{
"operationName": "GetERPItems",
"query": "query GetERPItems { QueryItems(first: 10) { nodes { id sku name notes basePriceUnit } totalCount } }"
}
""";
var request = new HttpRequestMessage(
HttpMethod.Post,
$"{_auth.ApiBaseUrl}/erp/v2/graphql");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
request.Headers.Add("X-Tenant-ID", payload.TenantId);
request.Content = new StringContent(query, Encoding.UTF8, "application/json");
var response = await _http.SendAsync(request);
var body = await response.Content.ReadAsStringAsync();
return Content(body, "application/json");
}
catch (Exception ex)
{
return StatusCode(500, new { error = "Failed to fetch items", details = ex.Message });
}
}
}
```
The controller reads the session token from the `Authorization` header (sent by the frontend as a `Bearer` token), verifies it to extract the tenant ID, fetches a fresh access token, and forwards the GraphQL response back to the frontend as-is.
The existing `app.MapControllers()` call in `Program.cs` already discovers this controller, so no extra registration is needed.
Add the items route to `backend/public/index.php`. Place it alongside the existing `connect-tenant` route:
```php theme={null}
$app->get('/api/items', function (Request $request, Response $response) use ($auth, $verifier, $httpClient) {
$authHeader = $request->getHeaderLine('Authorization');
if (!str_starts_with($authHeader, 'Bearer ')) {
$response->getBody()->write(json_encode(['error' => 'Missing or invalid Authorization header']));
return $response->withStatus(401)->withHeader('Content-Type', 'application/json');
}
$sessionToken = substr($authHeader, 7);
try {
$payload = $verifier->verify($sessionToken);
$accessToken = $auth->getJwt();
$apiResponse = $httpClient->request('POST', JtlAuth::API_BASE_URL . '/erp/v2/graphql', [
'http_errors' => false,
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'Authorization' => "Bearer {$accessToken}",
'X-Tenant-ID' => $payload['tenantId'],
],
'json' => [
'operationName' => 'GetERPItems',
'query' => 'query GetERPItems { QueryItems(first: 10) { nodes { id sku name notes basePriceUnit } totalCount } }',
],
]);
$body = $apiResponse->getBody()->getContents();
$response->getBody()->write($body);
return $response->withHeader('Content-Type', 'application/json');
} catch (\Throwable $e) {
error_log("Failed to fetch items: {$e->getMessage()}");
$response->getBody()->write(json_encode(['error' => 'Failed to fetch items']));
return $response->withStatus(500)->withHeader('Content-Type', 'application/json');
}
});
```
The route reads the session token from the `Authorization` header (sent by the frontend as a `Bearer` token), verifies it to extract the tenant ID, fetches a fresh access token, and forwards the GraphQL response back to the frontend as-is.
## 7. Display Items in the ERP Page
Replace `frontend/src/routes/_shell.erp.tsx` with a version that fetches and renders the products:
```tsx theme={null}
import { createFileRoute } from '@tanstack/react-router';
import { Box, Text } from '@jtl-software/platform-ui-react';
import { useCallback, useEffect, useState } from 'react';
import { useAppBridge } from '../appBridge';
interface Item {
id: string;
sku: string;
name: string;
}
interface ItemsResponse {
data: {
QueryItems: {
nodes: Item[];
totalCount: number;
};
};
}
function ErpPage() {
const { appBridge, tenantId } = useAppBridge();
const [items, setItems] = useState([]);
const [totalCount, setTotalCount] = useState(0);
const [loading, setLoading] = useState(false);
const [error, setError] = useState(null);
const fetchItems = useCallback(async () => {
if (!appBridge) return;
try {
setLoading(true);
const sessionToken =
await appBridge.method.call('getSessionToken');
const res = await fetch('/api/items', {
headers: { Authorization: `Bearer ${sessionToken}` },
});
if (!res.ok) {
throw new Error(`Request failed (${res.status})`);
}
const data: ItemsResponse = await res.json();
setItems(data.data.QueryItems.nodes || []);
setTotalCount(data.data.QueryItems.totalCount || 0);
} catch (err) {
console.error(String(err));
setError(
err instanceof Error ? err.message : 'Failed to load products',
);
} finally {
setLoading(false);
}
}, [appBridge]);
useEffect(() => {
fetchItems();
}, [fetchItems]);
if (error) {
return (
Error
{error}
);
}
return (
My JTL Cloud App
Connected to tenant:{' '}
{tenantId}
Products from Cloud-ERP
{loading ? (
Loading products...
) : items.length === 0 ? (
No products found. Make sure your test account has items in
Cloud-ERP.
) : (
<>
Showing {items.length} of {totalCount} products
sku
name
{items.map((item) => (
{item.sku}
{item.name}
))}
)}
);
}
export const Route = createFileRoute('/_shell/erp')({
component: ErpPage,
});
```
On mount, the component requests a session token from the AppBridge, sends it to your backend as the `Authorization` header, and renders the returned products in a table. The session token round-trip means the backend always knows which tenant the request belongs to, even though the frontend only ever holds a short-lived signed token.
A sample response from the GraphQL API looks like this:
```json theme={null}
{
"data": {
"QueryItems": {
"nodes": [
{
"id": "895d2d4d-4ed4-44c7-ac61-ebec01000000",
"sku": "AR2016041-VKO",
"name": "Men's T-shirt"
},
{
"id": "895d2d4d-4ed4-44c7-ac61-ebec06000000",
"sku": "AR2016041-002",
"name": "Men's T-shirt orange S"
}
],
"totalCount": 674
}
}
}
```
## 8. Open the App from the ERP Menu
In the [ERP Cloud](https://erp.jtl-cloud.com), navigate to the **App** menu and find the **My JTL App** menu item that the manifest registered. Clicking it loads `/erp` inside the App Shell.
You should see a header reading **My JTL Cloud App**, the connected tenant ID, and a table listing the first ten products from your JTL-Wawi instance.
This completes the full handshake flow: the App Shell loads your frontend in an iframe, AppBridge provides a short-lived session token, your backend verifies the token and uses its access token to make a tenant-scoped request to the JTL Cloud API, and the response is returned to the browser.
## Common Issues
This error usually means TypeScript and Node are resolving modules differently.
With `"type": "module"` in `package.json` and `"module": "NodeNext"` in `tsconfig.json`, Node expects ES module imports to include file extensions. Even if your source file is `jtl-auth.ts`, the import must use `./jtl-auth.js`.
TypeScript resolves this correctly during development, and Node finds the compiled `.js` file at runtime.
If you prefer not to use `.js` extensions, switch to `"module": "CommonJS"` in `tsconfig.json` and remove `"type": "module"` from `package.json`.
This means the backend started without loading your environment variables.
The most common cause is running Node without the `--env-file=.env` flag. In that case, the `.env` file exists but is never read.
The `dev` and `start` scripts already include this flag. If you're running the server manually, add it back or use `npm run dev`.
Also confirm that the `.env` file is inside the `backend/` directory. The path is resolved relative to where Node is executed.
A 401 from the auth endpoint means the credentials are not valid.
If you are still using placeholder values, this is expected. Real credentials are provided after registering your app in the Partner Portal.
If you have already registered:
* check for typos or extra spaces in `.env`
* restart the dev server after making changes
Environment variables are only read at startup, so updates to `.env` require a restart.
This usually means the backend responded, but not with a successful (2xx) response.
The frontend treats any non-2xx response as an error and shows the placeholder state.
Open the browser console and inspect the `/api/connect-tenant` response:
* a 401 is expected at this stage without real credentials
* a 500 or network error indicates a backend issue (check server logs)
Once valid credentials are configured, this state resolves automatically.
This means the browser blocked the response due to an origin mismatch.
The backend allows requests from `http://localhost:5173`, which is the default Vite dev server port. If Vite runs on a different port (for example, 5174), the request will be rejected.
Update the `origin` in `server.ts` to match the actual port, or restart Vite on 5173.
If you're using the Vite dev proxy for `/api/*`, CORS should not appear. Seeing this error usually means the request is being made directly to the backend instead of going through the proxy.
## What's Next?
You've built a working JTL Cloud App from scratch: a frontend that runs inside the JTL App Shell, a backend that verifies session tokens and proxies requests to the JTL Cloud API, and a real connection to a tenant pulling live product data. Where to go from here:
Validate your app in the sandbox with test data.
Use the JTL-Wawi REST and GraphQL APIs, handle responses, and work with tenant-scoped data.
Try queries and mutations interactively against your ERP instance.
Learn how to integrate deeper with the JTL UI and App Shell.
Deploy your app and publish it for merchants.
# Build the Frontend
Source: https://developer.jtl-software.com/get-started/quick-start/from-scratch/frontend
Scaffold the React frontend for your JTL Cloud App with TanStack Router and the JTL AppBridge SDK.
Build the React frontend for a JTL Cloud App using Vite, TypeScript, [TanStack Router](https://tanstack.com/router/latest), and the JTL AppBridge SDK. By the end, the app runs locally with three working routes and a clear state for connecting to your backend.
**Stack:** Vite, React, TypeScript, TanStack Router (file-based routing), JTL AppBridge, JTL Platform UI.
## Prerequisites
You need:
* ✅ **A JTL ID** (your login to the JTL ecosystem)
* ✅ **Access to an organization (tenant) in the [Partner Portal](https://partner.jtl-cloud.com)** (created automatically on first login)
* ✅ **[Node.js](https://nodejs.org/) v24.16.0 or higher** (current LTS, includes `npm`). Verify with `node --version` and `npm --version`
If you don't have your JTL ID and Partner Portal access yet, follow [Create a Developer Account](/get-started/create-developer-account) first.
## What you're Building
Before writing code, here’s how a JTL Cloud App works:
```mermaid theme={null}
sequenceDiagram
participant Shell as JTL App Shell
participant FE as Your Frontend
participant BE as Your Backend
Shell->>FE: Loads app in iframe
FE->>Shell: appBridge.method.call('getSessionToken')
Shell-->>FE: Session token (JWT)
FE->>BE: GET /api/connect-tenant (with token)
BE-->>FE: Verified tenant info
```
Your frontend runs inside JTL’s App Shell (in an iframe). It communicates with the shell through **AppBridge**, a small SDK that exposes shell capabilities to the iframe. The most important one is `getSessionToken`, a short-lived signed token that proves which merchant (tenant) is currently using your app. Your frontend sends that token to your backend, which verifies it and uses it to make tenant-scoped calls to the JTL API.
Not every page in your app runs inside the shell. The frontend has three routes, and they fall into two groups:
* `/setup` and `/erp` run inside the App Shell iframe. AppBridge is available, and the app knows which tenant it's serving.
* `/hub` opens in a standalone browser tab when a merchant clicks the app card. There’s no iframe, no AppBridge, and no tenant context.
These two contexts require slightly different setup. You’ll handle that when building the frontend.
## 1. Create the Project
```bash theme={null}
mkdir my-jtl-app
cd my-jtl-app
npm create vite@latest frontend -- --template react-ts
```
When prompted:
* **Ok to proceed? (y):** `y`
* **Install with npm and start now?:** `Yes`
Once Vite finishes installing, press `Ctrl + C` to stop the dev server.
## 2. Install Packages
```bash theme={null}
cd frontend
npm install @tanstack/react-router @jtl-software/cloud-apps-core @jtl-software/platform-ui-react tailwindcss @tailwindcss/vite
npm install -D @tanstack/router-plugin @tanstack/react-router-devtools
```
| Package | Purpose |
| ----------------------------------- | ----------------------------------------------------------------------- |
| `@tanstack/react-router` | Type-safe router with file-based routing |
| `@tanstack/router-plugin` | Vite plugin that auto-generates the route tree from your file structure |
| `@tanstack/react-router-devtools` | Devtools panel for inspecting routes (dev only) |
| `@jtl-software/cloud-apps-core` | AppBridge SDK: communication between your app and the JTL App Shell |
| `@jtl-software/platform-ui-react` | JTL's UI component library (Button, Card, Text, etc.) |
| `tailwindcss` + `@tailwindcss/vite` | Utility-first CSS, required by the JTL UI library |
## 3. Configure Vite
Replace `frontend/vite.config.ts`:
```typescript theme={null}
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import tailwindcss from '@tailwindcss/vite';
import { tanstackRouter } from '@tanstack/router-plugin/vite';
import path from 'path';
export default defineConfig({
server: {
port: 5173,
proxy: {
'/api': {
target: 'http://localhost:5273',
changeOrigin: true,
},
},
},
plugins: [
// The router plugin must come before the React plugin
tanstackRouter({ target: 'react', autoCodeSplitting: true }),
react(),
tailwindcss(),
],
resolve: {
alias: {
'/assets': path.join(
path.dirname(require.resolve('@jtl-software/platform-ui-react')),
'assets',
),
},
},
});
```
This does three things:
* **TanStack Router plugin** watches `src/routes/` and regenerates `src/routeTree.gen.ts` whenever you add or rename a route file. The plugin must be listed before `react()`. See the [installation docs](https://tanstack.com/router/latest/docs/installation/with-vite) for details.
* **Tailwind plugin** enables Tailwind utilities, which the JTL UI library depends on.
* **Dev proxy** forwards `/api/*` requests to a backend on `localhost:5273`. Your frontend can call `fetch('/api/...')` and Vite will route the request without CORS issues during development.
## 4. Set up Styles
Replace `frontend/src/index.css`:
```css theme={null}
@import '@jtl-software/platform-ui-react/index.css';
@import 'tailwindcss';
```
## 5. Create the Route Files
TanStack Router uses file-based routing, so your folder structure under `src/routes/` *is* your route configuration. Delete the default `src/App.tsx` (the router replaces it), then create the following structure:
```
frontend/src/routes/
├── __root.tsx # Root layout (devtools, outlet)
├── _shell.tsx # Pathless layout. Only wraps Outlet in that renders inside the App Shell
├── _shell.setup.tsx # /setup (inside App Shell)
├── _shell.erp.tsx # /erp (inside App Shell)
└── hub.tsx # /hub (standalone, no AppBridge)
```
Two conventions are in play here:
* **`__root.tsx`** is the top-level layout, always rendered.
* **`_shell.tsx`** is a [pathless layout route](https://tanstack.com/router/latest/docs/routing/routing-concepts#pathless-layout-routes). The leading underscore means it doesn't add a URL segment, so `_shell.setup.tsx` becomes `/setup`, not `/_shell/setup`. Any route file prefixed with `_shell.` shares the layout's wrapper. `hub.tsx` doesn't, so it bypasses the AppBridge initialization entirely.
### Root Route
Add the following to your `frontend/src/routes/__root.tsx`:
```tsx theme={null}
import { createRootRoute, Outlet } from '@tanstack/react-router';
import { TanStackRouterDevtools } from '@tanstack/react-router-devtools';
export const Route = createRootRoute({
component: () => (
<>
),
});
```
The `` is where child routes render. During development, a devtools panel appears in the bottom corner. It won’t be included in your production build.
### Shell Layout (AppBridge Provider)
This layout wraps every iframe route.
`frontend/src/routes/_shell.tsx`:
```tsx theme={null}
import { createFileRoute, Outlet } from '@tanstack/react-router';
export const Route = createFileRoute('/_shell')({
component: () => ,
});
```
Then create a `frontend/src/appBridge.tsx` file that initializes AppBridge once, exposes the bridge and tenant ID through React Context, and shows a loading state until the connection completes.
```tsx theme={null}
import {
createContext,
useContext,
useEffect,
useState,
type ReactNode,
} from 'react';
import type { AppBridge } from '@jtl-software/cloud-apps-core';
interface AppBridgeContextValue {
appBridge: AppBridge | null;
tenantId: string | null;
isReady: boolean;
error: string | null;
}
const AppBridgeContext = createContext({
appBridge: null,
tenantId: null,
isReady: false,
error: null,
});
export function useAppBridge() {
return useContext(AppBridgeContext);
}
export function AppBridgeProvider({ children }: { children: ReactNode }) {
const [appBridge, setAppBridge] = useState(null);
const [tenantId, setTenantId] = useState(null);
const [isReady, setIsReady] = useState(false);
const [error, setError] = useState(null);
useEffect(() => {
let cancelled = false;
async function init() {
try {
const { createAppBridge } =
await import('@jtl-software/cloud-apps-core');
const bridge = await createAppBridge();
if (cancelled) return;
setAppBridge(bridge);
const sessionToken =
await bridge.method.call('getSessionToken');
if (cancelled) return;
const res = await fetch('/api/connect-tenant', {
headers: { 'X-Session-ID': sessionToken },
});
if (cancelled) return;
if (!res.ok) {
const data = await res.json().catch(() => null);
throw new Error(
data?.error || `Connect failed (${res.status})`,
);
}
const data = await res.json();
if (cancelled) return;
setTenantId(data.tenantId);
setIsReady(true);
} catch (err) {
if (cancelled) return;
console.error('[AppBridge] Init failed:', err);
setError(
err instanceof Error ? err.message : 'Failed to initialize',
);
setIsReady(true);
}
}
init();
return () => {
cancelled = true;
};
}, []);
if (!isReady) {
return (
Connecting to JTL Platform...
);
}
return (
{children}
);
}
```
Two things to note:
* **Dynamic import** of `createAppBridge` keeps the SDK out of any pre-render path. AppBridge requires `window`, so it can only run client-side.
* **React Context** exposes `appBridge`, `tenantId`, and connection state through the `useAppBridge()` hook. Any route that is a child of the `_shell` route can call it with no prop drilling and a single shared connection state.
### Setup Page
Add the following to your `frontend/src/routes/_shell.setup.tsx`:
```tsx theme={null}
import { createFileRoute } from '@tanstack/react-router';
import { Button, Box, Text } from '@jtl-software/platform-ui-react';
import { useAppBridge } from '../appBridge';
function SetupPage() {
const { appBridge, tenantId, error } = useAppBridge();
const handleSetupCompleted = async () => {
if (!appBridge) return;
try {
await appBridge.method.call('setupCompleted');
} catch (err) {
console.error('Setup completion failed:', err);
}
};
if (error) {
return (
Waiting for backend
The frontend is running, but no backend is responding at /api/connect-tenant.
Start your backend and reload this page.
{error}
);
}
return (
Connect to JTL Cloud
Your app has been verified and is ready to connect.
{tenantId && (
Tenant: {tenantId}
)}
);
}
export const Route = createFileRoute('/_shell/setup')({
component: SetupPage,
});
```
Uses the `useAppBridge()` hook to connect to the tenant. The error branch renders whenever `/api/connect-tenant` is unreachable or returns a non-2xx response. The success branch renders once a backend verifies the session token and returns a tenant ID.
### ERP Page
Add the following to your `frontend/src/routes/_shell.erp.tsx`:
```tsx theme={null}
import { createFileRoute } from '@tanstack/react-router';
import { Box, Text } from '@jtl-software/platform-ui-react';
import { useAppBridge } from '../appBridge';
function ErpPage() {
const { tenantId, error } = useAppBridge();
if (error) {
return (
Waiting for backend
Start your backend and reload this page.
);
}
return (
My JTL Cloud App
Your app is running inside the JTL Cloud and connected to your tenant.
{tenantId && (
Tenant ID: {tenantId}
)}
);
}
export const Route = createFileRoute('/_shell/erp')({
component: ErpPage,
});
```
This is the page merchants see when they open your app from the ERP menu.
### Hub Page
This route sits outside the shell layout and doesn't inherit AppBridge initialization. When a merchant clicks the app card in the [JTL Hub](https://hub.jtl-cloud.com/), this page opens in a full browser tab with no iframe and no session token.
`frontend/src/routes/hub.tsx`:
```tsx theme={null}
import { createFileRoute } from '@tanstack/react-router';
import {
Card,
CardHeader,
CardTitle,
CardDescription,
CardContent,
CardFooter,
Text,
Box,
Button,
} from '@jtl-software/platform-ui-react';
import { ArrowUpRight } from 'lucide-react';
function HubPage() {
return (
Launched from JTL Cloud
This page opens in a full browser tab when a merchant clicks your app card
in the JTL Hub. It runs outside the App Shell, so there is no AppBridge
and no tenant context.
Manifest mappingcapabilities.hub.appLauncher.redirectUrl
}
iconPosition="right"
/>
);
}
export const Route = createFileRoute('/hub')({
component: HubPage,
});
```
## 6. Wire up the Router and Add AppBridgeProvider
Update `frontend/src/main.tsx` to initialize the router and wrap your shell layout with AppBridgeProvider.
```tsx theme={null}
import ReactDOM from 'react-dom/client';
import { RouterProvider, createRouter } from '@tanstack/react-router';
import { routeTree } from './routeTree.gen';
import { AppBridgeProvider } from './appBridge';
import './index.css';
const router = createRouter({ routeTree });
declare module '@tanstack/react-router' {
interface Register {
router: typeof router;
}
}
const needsBridge = !window.location.pathname.startsWith('/hub');
const tree = needsBridge ? (
) : (
);
const rootElement = document.getElementById('root')!;
if (!rootElement.innerHTML) {
ReactDOM.createRoot(rootElement).render(tree);
}
```
## 7. Run the Frontend
Start the dev server:
```bash theme={null}
npm run dev
```
The first time you run this, the TanStack Router plugin generates `src/routeTree.gen.ts` automatically.
Visit each route to confirm the app works:
You should see a spinner and then a message: **"Waiting for backend"**. This shows the routing works and the shell layout mounts, AppBridge attempts to initialize, and the fetch to `/api/connect-tenant` fails (no backend yet).
Same waiting message as before. Confirms the second iframe route loads and reuses the shell layout.
You should see the **"Launched from JTL Cloud"** card. No spinner, no error, since this route bypasses the shell layout entirely.
## Common Issues
This error occurs when AppBridge is loaded outside a browser environment. It relies on the `window` object, which is not available during server-side rendering or in Node.
In the shell layout, the SDK should be loaded using a dynamic `await import('@jtl-software/cloud-apps-core')` inside `useEffect`. If it is moved to a top-level `import`, it runs too early and triggers this error.
Also make sure you are running `npm run dev`. This app is a client-only Vite app and is not designed to run in a server environment.
This means the route tree file has not been generated yet. It is created automatically by the TanStack Router Vite plugin when it detects your route files.
Start the dev server with `npm run dev`, then save any file inside `src/routes/`. The plugin watches this folder and will generate `src/routeTree.gen.ts` as soon as it detects a change.
If the file still does not appear, check `vite.config.ts`. The `tanstackRouter()` plugin must be listed before `react()` in the `plugins` array.
This usually means the route is not being treated as a pathless layout.
In TanStack Router, the leading underscore (`_`) marks a route as pathless. If the file is named `shell.setup.tsx` (without the underscore), `_shell` becomes part of the URL.
Rename the file to `_shell.setup.tsx` to restore the expected behavior. Also make sure you are using the flat-file convention (`_shell.setup.tsx`), not a folder structure like `_shell/setup.tsx`, since this guide assumes the flat-file format.
This usually happens when `AppBridgeContext` and `useAppBridge` are defined in the same file as a TanStack Router route (for example, `_shell.tsx`).
During development, the router’s Vite integration can create multiple module instances under hot module replacement (HMR). This causes the provider and consumer to reference different context objects, so `useAppBridge()` returns `null`.
**Fix:** Move the context, hook, and provider into a separate file (for example, `src/appBridge.tsx`) and import `useAppBridge` from there in all components.
## Next: Build the Backend
Pick a language to build the backend that will verify session tokens and proxy requests to the JTL API:
Express and TypeScript.
ASP.NET Core 8.
Slim 4 and PHP.
# Quickstart: From Template
Source: https://developer.jtl-software.com/get-started/quick-start/from-template
Clone the sample app, add your credentials, and have a running JTL Cloud App in under 15 minutes.
**What you'll build:** A full-stack Cloud App (React frontend + Express/.NET/PHP backend) that authenticates with the JTL platform and runs inside the App Shell.
## Prerequisites
Before you start, make sure you have:
You need:
* ✅ **A JTL ID** (your login to the JTL ecosystem)
* ✅ **Access to an organization (tenant) in the [Partner Portal](https://partner.jtl-cloud.com)** (created automatically on first login if you don’t have one yet)
If you don't have these yet, follow the step-by-step guide: [Create a Developer Account](/get-started/create-developer-account).
You'll also need:
* ✅ **[JTL-Wawi](https://www.jtl-software.com/de/warenwirtschaftssystem-software/jtl-wawi-download)** installed and running locally
You'll need the following tools installed on your machine:
* [Node.js](https://nodejs.org/) **v24.16.0 or higher** (current LTS, includes `npm`). Verify with `node --version` and `npm --version`
* For .NET template: [.NET SDK](https://dotnet.microsoft.com/en-us/download/dotnet/8.0). Run `dotnet --version` to check
* For PHP template: [PHP](https://www.php.net/downloads) **8.1 or higher** with `ext-sodium` enabled. Run `php --version` and `php -m | grep sodium` to check
## 1. Create the Project Using Cloud Apps CLI
```bash theme={null}
npm create @jtl-software/cloud-app@latest
```
Follow the prompts to create your app:
* **Ok to proceed? (y):** `y`
* **App name:** `my-jtl-app`
* **Description:** `My JTL Sample App`
* **Backend:** `Node.js` or `.NET` or `PHP`
* **Frontend:** `React (Vite + Tailwind + JTL UI)`
Use the **Arrow Keys** to navigate and **Enter** to select.
The CLI generates a project that matches your backend choice. The frontend is the same for both.
## 2. Install Dependencies
From the project root, install all dependencies:
```bash theme={null}
cd my-jtl-app
npm install
```
This installs dependencies for the project.
## 3. Register your App
The `register` command signs you in with your [JTL ID](/get-started/create-developer-account#step-1-set-up-your-partner-portal) and lets you select a tenant. It then registers the app and writes the generated credentials to your local environment file. From the project root, run:
```bash theme={null}
npm run register
```
The CLI opens a browser tab to sign you in with your JTL ID. After you sign in, return to the terminal. The CLI then walks you through three short prompts:
* **Register the app in which tenant?** Pick the tenant you want the app registered under. If your account has access to more than one, the CLI lists them all.
* **Review.** The CLI prints a summary of the app it is about to create: `App name`, `Technical name`, `Version`, `Description`, `Tenant`, and `Action`. Verify the values are correct.
* **Create app "\" in tenant "\"?** Confirm with `Yes` to proceed.
Once the app is created, the CLI writes your client ID and client secret to the appropriate local file for your backend:
| Backend | File written |
| ------- | ------------------------------------------------------- |
| Node.js | `/packages/backend/.env` |
| .NET | `/packages/backend/MyJtlApp.Api/appsettings.Local.json` |
| PHP | `/packages/backend/.env` |
The CLI also returns a link to the app in JTL Hub.
**Don't commit your environment files.** They contain your client secrets. The CLI writes them to paths that the template's `.gitignore` already excludes, but verify this before pushing to a shared repository.
If the browser does not open automatically, the CLI prints the sign-in URL in the terminal. Copy it into a browser on a machine that can reach it, complete the sign-in, and return to the terminal to continue.
## 4. Start the App
Run the following command from the root directory to start the development server:
```bash theme={null}
npm run dev
```
This starts both the backend and frontend:
| Service | URL | Port |
| ------------------------------------ | ----------------------- | ---- |
| Backend (Express or .NET API or PHP) | `http://localhost:3005` | 3005 |
| Frontend (React App) | `http://localhost:3004` | 3004 |
## 5. Open the App
Open [http://localhost:3004](http://localhost:3004) in your browser. You should see an instruction page. It's intentional, as the sample app is designed to run inside the JTL Cloud.
## 6. Verify the Connection
Your app is now running locally and connected to the JTL platform using your credentials. To verify everything is working:
1. Open [JTL Hub](https://hub.jtl-cloud.com/) in your browser
2. Navigate to the **Manage apps** menu and click the **Apps in development** tab
3. You should see the `my-jtl-app` listed
4. Click the **Install** button to install the app.
Once the app is installed, you'll see a success screen with the option to configure the app. Click the **Configure app** button to proceed to the next step.
Complete the installation process by clicking the **Complete setup** button in the installation wizard.
## 7. Fetch Data from JTL-Wawi
Your app is running and connected to the platform, but it's not pulling real ERP data yet. The template includes a working demo page that queries Wawi through the ERP's GraphQL API. Let's walk through how it works.
### Open the GraphQL Demo Page
The template ships with a demo page at `packages/frontend/src/pages/graphql-demo-page/` that runs several example queries against your JTL-Wawi (items, orders, stock data).
To view it, see the [Test your App](/get-started/test-your-app) guide.
### How it Works
The frontend never talks to the JTL-Wawi API directly. All requests go through your backend, which handles authentication transparently.
```mermaid theme={null}
sequenceDiagram
participant FE as Frontend (demo page)
participant BE as Backend (/graphql proxy)
participant API as JTL-Wawi API
FE->>BE: POST /graphql (with X-Session-Token)
BE->>BE: Verify session token, get tenant ID
BE->>BE: Fetch access token with client credentials
BE->>API: POST /erp/v2/graphql (with Bearer token)
API-->>BE: GraphQL response
BE-->>FE: Forward response
```
The backend's `POST /graphql` endpoint does five things:
1. Reads the session token from the `X-Session-Token` header
2. Verifies the token and extracts the tenant ID
3. Obtains an access token using your app's client credentials
4. Forwards the GraphQL request to the JTL-Wawi API with the correct `Authorization` and `X-Tenant-ID` headers
5. Returns the response as-is
The template's `/graphql` proxy verifies the session token signature, which is enough to get started. Before deploying to production, add an authorization layer that authorize the tenant and user against your own application data. See [Authentication & Login](/guides/cloud-apps/authentication-login) for the full verification pattern and the recommended request flow.
### The Query Code
The demo page lives at `packages/frontend/src/pages/graphql-demo-page/GraphqlDemoPage.tsx`. It keeps a `QUERIES` object with one entry per example query and runs whichever entry you click. `topItems` and `stockOverview` both query `QueryItems`. `recentOrders` queries `QuerySalesOrders`, which returns different fields.
```typescript theme={null}
import { GraphQLClient, gql } from 'graphql-request';
import { apiUrl } from '../../common/constants';
function createClient(sessionToken: string) {
return new GraphQLClient(`${apiUrl}/graphql`, {
headers: { 'X-Session-Token': sessionToken },
});
}
const QUERIES = {
topItems: gql`
query TopItems {
QueryItems(first: 5, order: [{ stockInOrders: DESC }]) {
totalCount
nodes {
sku
name
stockInOrders
salesPriceGross
}
}
}
`,
recentOrders: gql`
query RecentOrders {
QuerySalesOrders(first: 5, order: [{ salesOrderDate: DESC }]) {
totalCount
nodes {
salesOrderNumber
salesOrderDate
totalGrossAmount
currencyIso
companyName
}
}
}
`,
stockOverview: gql`
query StockOverview {
QueryItems(first: 5, order: [{ stockTotal: DESC }]) {
totalCount
nodes {
sku
name
stockTotal
stockAvailable
stockInOrders
}
}
}
`,
};
const sessionToken = await appBridge.method.call('getSessionToken');
const client = createClient(sessionToken);
const data = await client.request(QUERIES.topItems);
```
A sample response looks like this:
```json theme={null}
{
"data": {
"QueryItems": {
"totalCount": 674,
"nodes": [
{
"sku": "AR2016041-VKO",
"name": "Men's T-shirt",
"stockInOrders": 42,
"salesPriceGross": 29.99
},
{
"sku": "AR2016041-002",
"name": "Men's T-shirt orange S",
"stockInOrders": 38,
"salesPriceGross": 29.99
}
]
}
}
}
```
This demo runs a minimal query to verify the connection. The GraphQL API
supports filtering, sorting, pagination, and mutations. Explore the full
schema interactively in the [GraphQL
Playground](/api-reference/graphql-playground), or read the [Using Platform
APIs](/guides/cloud-apps/using-platform-apis) guide for more patterns.
## What Just Happened?
Here's what's running under the hood:
```mermaid theme={null}
flowchart LR
FE["React Frontend:3004 (HTTPS)"] --> BE["Express/.NET Backend:3005 (HTTP)"]
BE --> AUTH["OAuth 2.0 Authentication"]
AUTH --> API["Cloud-ERP API"]
API --> DATA["Merchant Data Products, Orders, etc."]
style FE fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style BE fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style AUTH fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style API fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style DATA fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
```
* The **React frontend** renders your app's UI (running on port 3004)
* The **Express/.NET/PHP backend** handles authentication and API calls (running on port 3005)
* The backend uses your **client ID and secret** to authenticate with JTL via OAuth 2.0
* Once authenticated, it can call the **JTL-Wawi API** to read and write data
## Project Structure
Here's what's inside `my-jtl-app/`:
```
my-jtl-app/
├── packages/
│ ├── backend/ # Express or .NET or PHP server
│ └── frontend/ # React application
├── manifest.json # App manifest
├── package.json # Monorepo config
└── README.md
```
## Common Issues
The template requires Node.js v24.16.0 or higher (current LTS). Node 18 and earlier are known to fail during install or at runtime. Check your version with `node --version`. If you need to upgrade, use [nvm](https://github.com/nvm-sh/nvm) or download the current LTS from [nodejs.org](https://nodejs.org/).
The CLI tries to open your default browser to start the JTL ID sign-in. If your environment blocks that, the CLI prints the sign-in URL to the terminal instead. Copy the URL into a browser on a machine that can reach it. After you complete the sign-in, the CLI continues with the tenant selection and review steps.
If you registered the app under the wrong tenant, the simplest path is to remove the app from the [Partner Portal](https://partner.jtl-cloud.com/) and rerun `npm run register`. The CLI prompts you to pick a tenant each time, so you can pick the correct one on the next pass.
The frontend runs on HTTPS, which requires a certificate. In development, this is a self-signed certificate that your browser does not trust. Click "Advanced" then "Proceed to localhost" (Chrome) or "Accept the Risk" (Firefox) to continue. This is safe for local development.
Another process is using the port. Find and stop it:
```bash theme={null}
# macOS / Linux
lsof -i :3004
kill -9
# Windows
netstat -ano | findstr :3004
taskkill /PID /F
```
This usually means the credentials in your local environment file do not match the app registered in the Partner Portal. The fastest way to fix it is to rerun `npm run register`, which regenerates credentials and rewrites the local file. If the problem persists, regenerate the credentials manually in the [Partner Portal](https://partner.jtl-cloud.com/) under your app's client credentials, then update the file yourself.
Your API request is missing required headers. Verify you are sending:
* `Authorization: Bearer `
* `X-Tenant-ID: ` (from session token payload)
Make sure the session token is still valid and has not expired.
If you get `{ "data": null }` or empty results:
* Verify the `tenantId` is correct (check what is in your session token)
* Confirm you have data in your Wawi for the query you are making
* Check that your GraphQL query syntax is valid (no missing brackets or commas)
## What's Next?
Your app is running. Here's where to go from here:
Use the cloud environment to test your app with real (test) data.
Use the JTL-Wawi REST and GraphQL APIs, handle responses, and work with
tenant-scoped data.
Try queries and mutations interactively against your ERP instance.
Want to understand every piece? Build a Cloud App step by step.
Integrate deeper with the JTL UI using AppBridge and Platform UI components.
# Submit to the App Store
Source: https://developer.jtl-software.com/get-started/submit-to-app-store
Deploy your app, update your manifest, and get your app listed in the JTL App Store.
Once your app is built and tested locally, the next step is getting it listed in the [App Store](https://apps.jtl-cloud.com/) where merchants can discover and install it.
This page walks you through deploying your app, updating your manifest with production URLs, and requesting your listing.
## How the Submission Process Works
The App Store submission follows this process:
Let's go through each step.
## 1. Deploy your App
Your app currently runs on `localhost` and merchants can't access that. You need to deploy it to a publicly accessible URL with HTTPS.
**What you need:**
* A hosting provider (Vercel, Railway, AWS, Hetzner, or any platform that runs Node.js)
* A domain or subdomain (e.g. `app.yourcompany.com`)
* HTTPS enabled (required because JTL loads your app in an iframe, and browsers block mixed content)
**What to deploy:**
* Your frontend (the pages that render inside the App Shell)
* Your backend / API routes (the endpoints that handle auth and business logic)
If you built with fullstack framework like **Next.js**, platforms like [Vercel](https://vercel.com) or [Railway](https://railway.app) can deploy your app with minimal configuration.
If you used the **template (Express + React)**, you'll need a platform that supports running both services, or deploy them separately behind a reverse proxy.
**Set your production environment variables:**
Wherever you deploy, make sure these environment variables are configured:
```dotenv theme={null}
CLIENT_ID=your-client-id
CLIENT_SECRET=your-client-secret
```
## 2. Update Your Manifest
Your manifest has two sections that both need attention before going live: the technical `manifest` section (URLs and capabilities) and the `listing` section (icons, descriptions, legal links). Update each one separately.
### Technical Configuration
The `manifest` section currently has `localhost` URLs from local development. Update every URL to point to your deployed app.
```json theme={null}
{
"manifest": {
"lifecycle": {
"configurationUrl": "https://app.yourcompany.com/configure"
},
"capabilities": {
"hub": {
"appLauncher": {
"redirectUrl": "https://app.yourcompany.com/erp"
}
},
"erp": {
"menuItems": [
{
"id": "my-app-menu",
"name": "My JTL App",
"url": "https://app.yourcompany.com/erp"
}
]
}
}
}
}
```
Every URL in the `manifest` section must:
* Use `https://` (not `http://`)
* Point to your production domain (not `localhost`)
* Be publicly accessible
### Presentation Content
In your `listing` section, replace any development placeholders with production content:
* **Icons**: replace placeholder URLs (e.g., `picsum.photos`) with your real app icons hosted at a public, stable URL. Provide both light and dark variants.
* **Name and description**: finalize copy in every locale you support (`name.{locale}.short`, `name.{locale}.full`, `description.{locale}.short`, `description.{locale}.full`).
* **Support URLs**: point `support.url.{locale}` and `support.documentation.{locale}` at real, working pages.
* **Legal URLs**: `legal.privacyPolicy`, `legal.termsOfUse`, `legal.gdpr.request`, and `legal.gdpr.delete` must all resolve to real, published pages. JTL requires these for compliance.
See [App Shell & UI Integration](/guides/cloud-apps/app-shell-ui-integration#listing-section) for the full listing field reference.
## 3. Register your App (if not already done)
If you already registered your app on the [Partner Portal](https://partner.jtl-cloud.com/) during the quickstart, you have your client credentials and the app exists in JTL's system.
If you're registering for the first time with production URLs:
1. Open the [Partner Portal](https://partner.jtl-cloud.com/)
2. Click **+ Create** button
3. Paste your updated manifest (with production URLs) into the Manifest Editor
4. Click **Register app** button
5. **Copy your credentials immediately**, as they're shown only once
Update your production environment variables with the new credentials if they've changed.
## 4. Submit your Listing Request
With your app deployed, your manifest updated, and the app registered, you can submit a listing request to the JTL partner team by filling the form below:
Prefer to open the form in a new tab? [Submit your listing request directly](https://forms.office.com/pages/responsepage.aspx?id=C73w-5V9hUueKLpvoKvGl1evQ-Bq_5lFv2Ua0947AqNUQlRRRTJWT0dTMVAyWFo5S0g2RVBKVTFPUS4u\&route=shorturl)
To get your app ID, follow these steps:
1. Open the [Partner Portal](https://partner.jtl-cloud.com/) and navigate to the **Manage apps** section.
2. Click on the **ellipsis (...)** menu for your app and select **Edit app**.
3. Copy the **App ID** from the URL.
`https://partner.jtl-cloud.com/{TenantSlug}/{PublisherId}/app-edit/{AppId}`
The App ID is the last segment of the URL.
## 5. JTL Reviews and Publishes
After you contact JTL, the team will:
1. Review your app and verify it's working at the production URL
2. Make your app visible in the App Store
3. Notify you once the listing is live
## Pre-submission Checklist
Before contacting JTL, make sure everything is in order:
| Check | Status |
| -------------------------------------------------------------------- | ------ |
| App is deployed and accessible via HTTPS | ⬜ |
| All manifest URLs point to production (no `localhost`) | ⬜ |
| App loads correctly in JTL Hub from production URL | ⬜ |
| Setup flow completes successfully (session token verification works) | ⬜ |
| App renders correctly in the ERP Cloud | ⬜ |
| Support URL in manifest leads to a real page | ⬜ |
| Privacy policy and terms of use URLs are live | ⬜ |
| App icon URLs are publicly accessible | ⬜ |
## What to Expect After Listing
Once your app is live in the App Store:
* **Merchants can discover it** by browsing or searching the store
* **Installation triggers your setup flow**: the same flow you tested locally
* **You manage the app** through the Partner Portal (credentials, payouts, updates)
* **App updates** are deployed through your hosting provider; if the manifest changes, coordinate with JTL
## What's Next?
Explore what to build next: deeper API integration, panel views,
marketplace channels, and more.
Add panel views, custom tabs, and deeper ERP integration to your app.
# Test Your App
Source: https://developer.jtl-software.com/get-started/test-your-app
How to test your app in the JTL sandbox environment
You've built your app and installed it in JTL Hub. Now let's verify it's actually running inside the ERP Cloud and connected to your tenant.
**Time:** \~5 minutes\
**Prerequisites:** You've completed either the [From Template](/get-started/quick-start/from-template) or [From Scratch](/get-started/quick-start/from-scratch) quickstart, and your app is installed in JTL Hub.
## 1. Make Sure Your App is Running Locally
Your app needs to be running on your machine for the ERP Cloud to load it. If it's not already running, start it based on your setup:
```bash theme={null}
cd my-jtl-app
npm run dev
```
```bash theme={null}
cd my-jtl-app/backend
npm run dev
```
Open a new terminal tab, then run:
```bash theme={null}
cd my-jtl-app/frontend
npm run dev
```
```bash theme={null}
cd my-jtl-app/Backend
dotnet run
```
Open a new terminal tab, then run:
```bash theme={null}
cd my-jtl-app/frontend
npm run dev
```
```bash theme={null}
cd my-jtl-app/backend
php -S localhost:5273 -t public
```
Open a new terminal tab, then run:
```bash theme={null}
cd my-jtl-app/frontend
npm run dev
```
## 2. Open the ERP Cloud
Go to [ERP Cloud](https://erp.jtl-cloud.com/) and log in. You'll see the
**ERP-App** dashboard. This is where your app runs inside the ERP interface.
## 3. Find your App in the Sidebar
In the ERP sidebar, scroll down to the **App** section. You should see your app listed by the name you defined in your manifest
alongside the `menuItems`:
The menu item corresponds to what you configured in your `manifest.json`:
```json From Template theme={null}
"erp": {
"menuItems": [
{
"id": "my-jtl-app-menu",
"name": "my-jtl-app",
"url": "http://localhost:3004/erp"
},
{
"id": "my-jtl-app-graphql-demo",
"name": "GraphQL Demo",
"url": "http://localhost:3004/graphql-demo"
}
],
}
```
```json From Scratch theme={null}
"erp": {
"menuItems": [
{
"id": "my-app-menu",
"name": "My JTL App",
"url": "http://localhost:5173/erp"
}
]
}
```
The `name` field is what appears in the sidebar. The `url` field is the corresponding route in your application.
## 4. Click your App
Click your app's menu item in the sidebar. The ERP loads your `/erp` page inside its main content area and shows the items from your JTL-Wawi.
From Template App:
`/my-jtl-app`
`/graphql-demo`
From Scratch App:
If you followed the **From Template** quickstart, you'll see the item list in the ERP page. If you followed the **From Scratch** quickstart, you'll see the tenant details page showing your connected Tenant ID and list of items.
## 5. Verify the Connection
Your app is working correctly if:
| Check | What to look for |
| ------------------------ | -------------------------------------------------------------------------------------------- |
| ✅ App appears in sidebar | Your menu item name shows under the **App** section |
| ✅ App loads in the ERP | Clicking it renders your app's UI in the main content area |
| ✅ Tenant is connected | Your app displays a tenant ID, queried products from the JTL-Wawi or connection confirmation |
If any of these fail, check the [troubleshooting section](#troubleshooting) below.
## How it All Connects
Here’s what happens under the hood when you click your app:
```mermaid theme={null}
sequenceDiagram
participant ERP as ERP Cloud
participant Shell as App Shell (iframe)
participant App as Your App (localhost)
participant BE as Your Backend
ERP->>Shell: User clicks menu item
Shell->>App: Loads your /erp URL in iframe
App->>Shell: AppBridge initialises
App->>Shell: getSessionToken()
Shell-->>App: Session token
App->>BE: POST /api/connect-tenant
BE-->>App: Tenant details
App->>App: Renders UI with tenant data
```
Your app is extending the [ERP Cloud](https://erp.jtl-cloud.com/). It sits alongside the built-in modules (Articles, Customers, Sales, Stock, etc.) in the sidebar and has the same access to merchant data through the JTL-Wawi API. The only difference is that built-in modules are native, and your app loads from your URL via the App Shell.
## Troubleshooting
* Is your app installed in JTL Hub? Check **Apps in development** in
the Hub.
* Does your manifest include a `menuItems` entry under
`capabilities.erp`?
* Did the manifest registration succeed in the
Partner Portal?
* Is your local dev server running? The ERP loads your app from
`localhost`.
* Check the URL in your manifest's `menuItems` and does the
path match your running app?
* Open browser DevTools (F12) → Console tab. Look for errors.
* If you see a mixed content warning, make sure your URL protocol (HTTP vs HTTPS) matches what the ERP expects.
The AppBridge provider can't connect:
* If your app isn't running inside the App Shell, it won't work in a standalone browser tab
* Check terminal output for backend errors
* Verify `CLIENT_ID` and `CLIENT_SECRET` in your `.env` / `.env.local`
* Restart the dev server after changing environment variables
* **401 / Authentication error:** Your client credentials are wrong or
expired. Regenerate them in the [Partner Portal](https://partner.jtl-cloud.com/).
* **CORS error:** Your backend might not be accepting requests from the ERP's origin. Check your API
route's response headers.
* **Network error:** The ERP can't reach `localhost`. Make sure no firewall or VPN is blocking local
connections.
## What's Next?
Your app is running inside the ERP Cloud. From here:
Ready to ship? Learn how to submit your app for review and reach 50,000+
merchants.
Go deeper with the App Shell: add panel views, custom tabs, and ERP
context integration.
# What is the JTL Platform?
Source: https://developer.jtl-software.com/get-started/what-is-jtl-platform
A quick introduction to the JTL ecosystem and what you can build on it
JTL is an all-in-one platform for building and running multi-channel commerce systems. It provides merchants with a single place to manage products, inventory, orders, and fulfillment across online stores, marketplaces, and internal systems.
JTL Cloud builds on top of the platform by exposing APIs, webhooks, and an app platform. This is where you build integrations, automate workflows, and extend the platform with custom applications.
## How the Platform is Structured
The platform is made up of a few core components. They can be used independently or combined depending on what you're building.
| Component | Description |
| ------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| [JTL-Wawi](/guides/erp-integration/integration-overview) | The ERP at the center of the platform: products, inventory, orders, and customers all live here. |
| [JTL Hub](/guides/cloud-apps/architecture-overview) | The API layer, webhooks, and infrastructure you'll use to build cloud apps and integrations. |
| [App Shell](/guides/cloud-apps/architecture-overview) | The container that hosts your app's UI. It handles layout, navigation, and communication with the rest of the platform. |
| [App Store](https://apps.jtl-cloud.com/) | Where merchants go to discover and install apps. |
| [ERP Cloud](https://erp.jtl-cloud.com/) | The cloud-based interface where your installed app actually runs. |
| [Marketplace Channels](/guides/marketplace-channels/channel-api-overview) | Tools and APIs for connecting to external marketplaces like Amazon and eBay. |
Since all of these components share the same underlying data through Wawi, you don't have to worry about syncing state between them yourself.
## Where Developers Work
As a developer building on JTL, you'll move between three surfaces. Each has a
different job, and you'll sign in to all of them with the same [JTL ID](/get-started/create-developer-account#step-1-set-up-your-partner-portal).
| Surface | What you do here |
| ----------------------------------------------- | --------------------------------------------------------------------------------- |
| [Partner Portal](https://partner.jtl-cloud.com) | Create apps, manage manifests, view client credentials, submit to the App Store. |
| [JTL Hub](https://hub.jtl-cloud.com) | Install apps under a test tenant, run the install handshake, view installed apps. |
| [JTL ERP Cloud](https://erp.jtl-cloud.com) | The browser-based runtime where installed apps actually open and run. |
A typical first session: register an app in the Partner Portal, install it in the
Hub under your test tenant, then open it from JTL ERP Cloud.
## What You Can Build
JTL Cloud gives you the tools to extend the platform in several directions:
* Cloud apps that plug directly into the JTL platform
* Marketplace integrations that sync products, orders, and inventory with external channels
* ERP integrations that automate internal business workflows
* Event-driven systems that react to changes via webhooks
You can mix and match these to fit whatever commerce workflow you're working with.
## What Makes JTL Different
JTL is designed around multi-channel commerce at scale, and that shapes how everything works, from how data flows to how integrations are structured.
* **ERP-first design**: Wawi is the single source of truth. Products, inventory, and orders always originate there, which means your integrations don't have to reconcile conflicting data from multiple sources.
* **Multi-channel from the ground up**: The platform is built to keep data in sync across stores, marketplaces, and internal systems, so you're not bolting on multi-channel support after the fact.
* **Built for real operations**: Workflows include retries, conflict handling, and batch processing, the kind of things you need when data has to move reliably at scale.
* **Extensible without forking**: You can build custom integrations, cloud apps, and automation workflows that plug into the platform without touching the core system.
## What's Next?
Set up a developer account and get sandbox access.
Follow a guide to build your first app.
Learn how to preview and test your application on the JTL Cloud.
Prepare your app for publication and submit it for review.
# What's Next?
Source: https://developer.jtl-software.com/get-started/whats-next
Explore deeper topics and advanced guides after completing the quick start
Now that you've built and submitted a Cloud App, here are the areas worth exploring next.
## Go Deeper with Cloud Apps
Add panel views, tabs, and context-aware UI inside the ERP.
Implement OAuth 2.0, token handling, scopes, and permissions.
Read and write products, orders, customers, and inventory.
Handle events like order creation, product updates, and app lifecycle
changes.
## Reference
Explore queries and mutations interactively with autocomplete and schema docs.
Full API coverage for Cloud ERP, SCX, and app registration.
Official client libraries (JavaScript/TypeScript).
## Community
Ask questions, share what you're building, and get help from the community and JTL staff.
* **[Forum](https://forum.jtl-software.de/)**: Ask questions and browse discussions
* **[GitHub](https://github.com/jtl-software)**: SDKs, examples, and open-source projects
* **[JTL-Connect](https://www.jtl-connect.de/)**: Annual conference and workshops
Have a question or need clarification? Contact the partner team at
[partner@jtl-software.com](mailto:partner@jtl-software.com).
# App Shell & UI Integration
Source: https://developer.jtl-software.com/guides/cloud-apps/app-shell-ui-integration
How to integrate your app with the JTL App Shell using the manifest and AppBridge communication
This guide covers the two systems that control how your Cloud App renders and communicates inside the JTL platform:
* **Manifest**: Configuration document with two sections. The `manifest` section defines lifecycle hooks, capabilities, and API scopes. The `listing` section defines name, description, icons, legal URLs, and support links shown in the JTL Hub and App Store.
* **AppBridge**: Runtime SDK that enables bidirectional communication between your app (in an iframe) and the host environment (JTL Hub or ERP Cloud).
* **Platform UI**: React component library for building interfaces that match JTL's design system.
For authentication flows, see [Authentication & Login](/guides/cloud-apps/authentication-login). For calling the JTL Cloud and JTL-Wawi APIs, see [Using Platform APIs](/guides/cloud-apps/using-platform-apis).
## App Manifest
The manifest is a JSON document that defines your app. It has two sections that work together: `manifest` for technical runtime configuration, and `listing` for the marketing content shown in the App Store and JTL Hub. You need both to deploy an app through the [Partner Portal](https://partner.jtl-cloud.com/).
```mermaid theme={null}
flowchart LR
M["App Manifest"] --> Tech["manifest section
(technical runtime)"]
M --> List["listing section
(marketing & UI)"]
Tech --> Platform["JTL Platform"]
List --> Platform
Platform --> Hub["JTL Hub"]
Platform --> ERP["JTL ERP"]
Platform --> Store["App Store"]
style M fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style Tech fill:#FFFFFF,stroke:#FB581F,stroke-width:1px,color:#0B1B45
style List fill:#FFFFFF,stroke:#89D2FF,stroke-width:1px,color:#0B1B45
style Platform fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
style Hub fill:#FFFFFF,stroke:#0B1B45,stroke-width:1px,color:#0B1B45
style ERP fill:#FFFFFF,stroke:#0B1B45,stroke-width:1px,color:#0B1B45
style Store fill:#FFFFFF,stroke:#0B1B45,stroke-width:1px,color:#0B1B45
```
### Manifest Section
The `manifest` section holds technical runtime configuration: identity, lifecycle hooks, and capabilities.
#### Top-level Fields
Two fields identify the app and its release.
| Property | Type | Required | Description |
| --------------- | ------ | -------- | -------------------------------------------------------------------------------------------------- |
| `technicalName` | string | Yes | Stable internal identifier for the app. Max 100 characters. Used as a fallback display name. |
| `version` | string | Yes | App release version. Strict semver, digits only (e.g., `1.0.0`). Pre-release tags are not allowed. |
#### Requirements
Declare the minimum platform API version your app needs. JTL prevents installation on environments that don't meet the requirement.
| Property | Type | Required | Description |
| --------------------------------- | ------ | -------- | ------------------------------------ |
| `requirements.minCloudApiVersion` | string | No | Minimum compatible Cloud API version |
#### Lifecycle
The lifecycle object defines the URL JTL loads when a merchant installs your app.
| Property | Type | Required | Description |
| ---------------------------- | ------ | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `lifecycle.configurationUrl` | string | No | URL rendered in an iframe during initial setup or onboarding. Use this to present UI, complete the AppBridge handshake, and persist the tenant connection. |
The URL must be a standard `http://` or `https://` URL and is validated against the pattern `^https?:\/\/(?:[^{}\s]|\{\s*metadata\.[a-zA-Z0-9_-]+\s*})+$` when you register your manifest.
**Identifying the App**
If you publish multiple apps, each one needs its own `configurationUrl`. Two apps sharing the same URL will cause the wrong setup UI to be rendered when a merchant installs either of them.
Give each app a distinct URL, either by using separate routes:
```json theme={null}
"lifecycle": {
"configurationUrl": "https://example.com/setup/inventory-sync"
}
```
Or by encoding the app's identity in the query string:
```json theme={null}
"lifecycle": {
"configurationUrl": "https://example.com/setup?app=inventory-sync"
}
```
Both approaches are valid. Use separate routes if you control routing and want cleaner URLs. Use query parameters if you prefer a single handler that switches behavior dynamically.
A working configuration flow is provided when you use the CLI `npm create
@jtl-software/cloud-app@latest` to create a new app.
#### Capabilities
Capabilities define where and how your app integrates with JTL. Each key under `capabilities` maps to a specific surface. See [Architecture Overview](/guides/cloud-apps/architecture-overview) for a full description of each integration type.
**Hub**
Controls how the app appears in the JTL Hub dashboard. When a merchant clicks the app's card, the platform redirects to this URL.
| Property | Type | Required | Description |
| ------------------------------------------ | ------ | ---------------------------- | ------------------------------------------------------------------- |
| `capabilities.hub.appLauncher.redirectUrl` | string | Required if `hub` is present | URL the system redirects to when the app card is clicked in the Hub |
Without a `redirectUrl`, the app card has no destination.
**ERP: Menu Items**
Add entries to the ERP Cloud sidebar under the **App** section. Each menu item links to a page in your app loaded inside the ERP iframe.
| Property | Type | Required | Description |
| -------- | ------ | -------- | -------------------------------------------- |
| `id` | string | Yes | Stable internal identifier for the menu item |
| `name` | string | Yes | Display name shown in the navigation |
| `url` | string | Yes | URL loaded when the item is clicked |
**ERP: API Scopes**
Declare the JTL-Wawi API resources your app intends to use. Declared scopes are validated against the allowed list at registration.
Runtime enforcement of these scopes by the API layer has not shipped yet, so declaring a scope here does not currently restrict what your app can call. This is a temporary state. Once enforcement is live, the API will reject calls that exceed the declared set, and the merchant will see the declared scopes at install time. See [Scopes & Permissions](/guides/essentials/authentication/scopes-permissions) for the full list and roadmap context.
| Property | Type | Required | Description |
| ----------------------------- | --------------- | -------- | ----------------------------------------- |
| `capabilities.erp.api.scopes` | array of string | No | API permission scopes required by the app |
The platform accepts only 41 specific scope values. Any value outside this list is rejected at registration.
A subset for reference:
```json theme={null}
"scopes": [
"items.read", "items.write",
"orders.read", "orders.write",
"customers.read", "customers.write",
"inventory.read", "inventory.write"
]
```
**Panel**
Add sidebar panels that appear alongside ERP views. Panels are context-aware and show up only on matching pages. When more than one installed app targets the same view and each app renders as its own tab within the panel. When there are more tabs than fit the panel width, the overflow collapses into a menu at the end of the tab bar.
| Property | Type | Required | Description |
| ---------------- | --------------- | -------- | --------------------------------------------------------------------------------------------------- |
| `id` | string | No | Internal identifier for the panel |
| `context` | string | Yes | View path where the panel appears, in the form `$tenantSlug.` (e.g., `$tenantSlug.customers`) |
| `url` | string | Yes | URL loaded inside the panel iframe |
| `requiredScopes` | array of string | No | Per-panel scope override. Uses the same 41-value enum as `capabilities.erp.api.scopes` |
### Listing Section
The `listing` section holds the marketing content shown to merchants in the App Store and JTL Hub: localized names and descriptions, icons, support URLs, and legal links.
#### Localized Name and Description
Names and descriptions are keyed by locale. The `defaultLocale` is the fallback when a merchant's preferred locale is not available.
| Property | Type | Description |
| ---------------------------- | ------ | ----------------------------------------------------------------- |
| `defaultLocale` | string | Fallback locale (e.g., `de-DE`) |
| `name.{locale}.short` | string | Short name shown in lists and cards. **Max 30 characters**. |
| `name.{locale}.full` | string | Full name shown on the app detail page. **Max 80 characters**. |
| `description.{locale}.short` | string | Teaser shown in cards. **Max 200 characters**. |
| `description.{locale}.full` | string | Full description shown on the app detail page. **No max length**. |
#### Media
Icons render in light and dark themes. Both URLs must be publicly reachable at registration and during installation.
| Property | Type | Description |
| ------------------- | ------ | ----------------------------------------------- |
| `media.icons.light` | string | Icon URL for light backgrounds (HTTPS, PNG/SVG) |
| `media.icons.dark` | string | Icon URL for dark backgrounds (HTTPS, PNG/SVG) |
#### Support and Documentation
Links shown on the app detail page. Both fields are localized.
| Property | Type | Description |
| -------------------------------- | ------ | -------------------------- |
| `support.url.{locale}` | string | Support link (HTTPS) |
| `support.documentation.{locale}` | string | Documentation link (HTTPS) |
#### Legal
Required legal URLs for compliance. GDPR endpoints accept data access and deletion requests.
| Property | Type | Description |
| --------------------- | ------ | ----------------------------------- |
| `legal.privacyPolicy` | string | URL to the privacy policy |
| `legal.termsOfUse` | string | URL to the terms of service |
| `legal.gdpr.request` | string | URL for GDPR data access requests |
| `legal.gdpr.delete` | string | URL for GDPR data deletion requests |
### Complete Manifest Example
The example below shows both sections together: a manifest declaring Hub redirect, one ERP menu item, three API scopes, and one panel scoped to the orders view, alongside a listing covering the German locale.
```json theme={null}
{
"manifest": {
"technicalName": "my-example-app",
"version": "1.0.0",
"requirements": {
"minCloudApiVersion": "1.0.0"
},
"lifecycle": {
"configurationUrl": "https://example.com/configure"
},
"capabilities": {
"hub": {
"appLauncher": {
"redirectUrl": "https://example.com/hub/launch"
}
},
"erp": {
"menuItems": [
{
"id": "menu-item-1",
"name": "Mein Menüpunkt",
"url": "https://example.com/erp/menu"
}
],
"api": {
"scopes": ["orders.read", "orders.write", "items.read"]
},
"pane": [
{
"id": "panel-1",
"context": "$tenantSlug.customers",
"url": "https://example.com/erp/pane/customers",
}
]
}
}
},
"listing": {
"version": "1.0.0",
"defaultLocale": "de-DE",
"name": {
"de-DE": {
"short": "Hello World example",
"full": "Hello World example"
}
},
"description": {
"de-DE": {
"short": "Official Hello World example.",
"full": "This is the official Hello World example."
}
},
"media": {
"icons": {
"light": "https://picsum.photos/200/200",
"dark": "https://picsum.photos/200/200"
}
},
"support": {
"url": {
"de-DE": "https://support.example.com/tickets"
},
"documentation": {
"de-DE": "https://docs.example.com/user-guide"
}
},
"legal": {
"privacyPolicy": "https://example.com/legal/privacy",
"termsOfUse": "https://example.com/legal/terms",
"gdpr": {
"request": "https://example.com/gdpr/data-request",
"delete": "https://example.com/gdpr/account-deletion"
}
}
}
}
```
***
## AppBridge Communication
The AppBridge is provided by the [`@jtl-software/cloud-apps-core`](https://www.npmjs.com/package/@jtl-software/cloud-apps-core) package. It establishes a secure communication channel between your app's frontend (running in an iframe) and the host JTL environment (JTL Hub or ERP Cloud).
The bridge allows your app to request data (like session tokens) and call host methods. Publish/subscribe event handling is in development ([see below](/guides/cloud-apps/app-shell-ui-integration#events)).
### Installation
```bash theme={null}
npm install @jtl-software/cloud-apps-core
```
### Initializing the AppBridge
Initialize the AppBridge **before** rendering your React app, then pass the instance as a prop or store it in context:
```tsx theme={null}
import { createAppBridge } from '@jtl-software/cloud-apps-core';
import { createRoot } from 'react-dom/client';
createAppBridge().then((appBridge) => {
createRoot(document.getElementById('root')!).render(
,
);
});
```
**What this does:** Calls `createAppBridge()` to establish the iframe-to-host connection, waits for the bridge to be ready, then passes it to your app as a prop. This guarantees the communication channel is open before any component tries to use it.
Do not initialize the AppBridge inside a component (e.g., in `useEffect`).
This can cause race conditions where components render before the bridge is
ready. Always initialize it at the application entry point.
For Next.js apps that need SSR compatibility, use a dynamic import inside a
client-side provider instead. See the [From Scratch
Quickstart](/get-started/quick-start/from-scratch#appbridge-provider) for the
full pattern.
You can use AppBridge in any JavaScript frontend framework, including React,
Vue, and Angular.
### Communication Flow
The AppBridge creates a two-way channel: your app's `appBridge` instance communicates with a corresponding `hostAppBridge` instance inside the JTL Cloud service.
```mermaid theme={null}
sequenceDiagram
participant App as App Frontend (iframe)
participant Bridge as appBridge
participant Host as hostAppBridge
participant Service as JTL Cloud Service
App->>Bridge: Initialize (createAppBridge())
activate Bridge
Bridge->>Host: Establish connection
activate Host
Host-->>Bridge: Connection ready
deactivate Host
Bridge-->>App: Bridge instance ready
deactivate Bridge
Note over App, Service: Runtime interactions
App->>Bridge: method.call("getSessionToken")
activate Bridge
Bridge->>Host: Invoke getSessionToken()
activate Host
Host->>Service: Execute host logic
activate Service
Service-->>Host: Return result
deactivate Service
Host-->>Bridge: Forward result
deactivate Host
Bridge-->>App: Return session token
deactivate Bridge
```
All communication is **asynchronous and non-blocking**. Your app continues executing while messages are delivered between the iframe and the host. There are no HTTP requests or polling involved.
### API Reference
The AppBridge provides two main interfaces: **methods** (expose/call) and **events** (publish/subscribe).
AppBridge methods provide a request/response channel between your app and the host. There are two directions:
* **Call host methods** (available today): your app invokes functions the host exposes, like `getSessionToken`. See [Environment-specific Methods](#environment-specific-methods) for the full list.
* **Expose methods to the host** (in development): your app registers functions that the host can invoke by name, used for things like custom calculations or data lookups.
### Calling Host Methods
Invoke a function provided by JTL. The call returns a promise that resolves with the host's result.
```javascript theme={null}
const sessionToken = await appBridge.method.call("getSessionToken");
```
**What this does:** Sends a method call across the bridge. The host executes the function and returns the result as a resolved promise.
### Exposing Methods to the Host
**In development:** `method.expose` and `method.isExposed` are in active development and not yet available. This section will be updated when the API ships.
Once available, exposing methods will let the host invoke logic that lives in your app. For example, a `calculateShippingCost` function the ERP calls before showing a quote, or a `validateOrder` hook called before checkout. The shape will follow a `name + handler` registration pattern with a disposer for cleanup, mirroring the event subscription model.
### Method API Summary
The table marks which APIs are available today and which are planned.
| Method | Status | Description |
| ---------------------------- | -------------- | ---------------------------------------------- |
| `method.call(name, ...args)` | Available | Call a host method. Returns `Promise`. |
| `method.expose(name, fn)` | In development | Register a function the host can call by name. |
| `method.isExposed(name)` | In development | Check whether a method is already registered. |
AppBridge events cover two directions. One is available today for panels; the other is in development.
* **`event.subscribe`** (available for panel entity context): listen for events the host publishes. Panels use this to react when the merchant navigates to a different entity, for example `CustomerChanged` on the customer view. See [Reading Panel Context](#reading-panel-context) for the pattern and the available events.
* **`event.publish`** (in development): send events from your app to the host so it can react to actions your app completes, for example `order:verification:complete`.
**In development:** Publishing events from your app to the host (`event.publish`), and general app-to-app pub/sub beyond the host entity-context events, are in active development. This section will be updated when they ship.
Host entity-context events follow a consistent convention: PascalCase, past-tense names (`CustomerChanged`), with object payloads (`{ customerId }`) rather than bare values.
### Environment-specific Methods
JTL exposes different built-in methods depending on which environment your app is running in.
These methods are available when your app loads via the `lifecycle.configurationUrl` during installation:
| Method | Parameters | Returns | Description |
| ----------------- | ---------- | ----------------- | ----------------------------------------------------------------- |
| `getSessionToken` | None | `Promise` | Returns the current session token (contains user and tenant info) |
| `setupCompleted` | None | `Promise` | Signals that setup is done and activates the app in the Hub |
These methods are available when your app runs inside the ERP (via menu items or panels):
| Method | Parameters | Returns | Description |
| ---------------------- | ---------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `getSessionToken` | None | `Promise` | Returns the current session token |
| `getCurrentTime` | None | `Promise` | Returns the current time as a Date object |
| `getCurrentCustomerId` | None | `Promise` | Returns the id of the customer the merchant is viewing. Available to panels on the **customer** view. Resolves to an empty string when no customer is in context. |
`getSessionToken` is available in both environments. It's the primary way your frontend identifies the current user and tenant. For details on verifying session tokens on your backend, see [Authentication & Login](/guides/cloud-apps/authentication-login).
#### Reading Panel Context
Panels can read the current entity in context. On the customer view, call `getCurrentCustomerId` to read the current customer, and subscribe to the `CustomerChanged` event to be notified when it changes.
```javascript theme={null}
// Read the current customer on load
const customerId = await appBridge.method.call("getCurrentCustomerId");
// React to the merchant navigating to a different customer
const unsubscribe = appBridge.event.subscribe(
"CustomerChanged",
({ customerId }) => {
if (!customerId) return;
// Load data for this customer.
},
);
// Call unsubscribe() when your component unmounts
```
The `CustomerChanged` payload is an object of the form `{ customerId: string }`. This event is emitted whenever the merchant selects a customer from the customer list. It is not emitted on unrelated views. Guard against an empty `customerId` before loading customer-specific data.
#### Naming Conventions
AppBridge APIs follow these naming conventions:
* Host methods use camelCase verbs, for example `getCurrentCustomerId`.
* Events use PascalCase and describe completed actions, for example `CustomerChanged`.
* Event payloads are always objects, for example `{ customerId }`, rather than primitive values. This allows additional fields to be added in future without breaking existing subscribers.
***
## Platform UI Components
JTL provides a [React Component Library](https://www.npmjs.com/package/@jtl-software/platform-ui-react) that matches the platform's design system. Using these components ensures your app looks and feels consistent with the rest of the JTL interface.
### Installation
```bash theme={null}
npm install @jtl-software/platform-ui-react
```
Add the CSS import to your global stylesheet:
```css theme={null}
@import '@jtl-software/platform-ui-react/index.css';
```
### Available Components
The library includes form controls, layout containers, and typography components. Here's the full list:
**Layout components**
* `Box` , `Grid` , `Stack` , `Layout` , `LayoutSection` , `Card`
**Form components**
* `Button` , `Checkbox` , `Input` , `InputOTP` , `Radio` , `Select` , `Textarea` , `Switch` , `Toggle` , `ToggleGroup` , `FormGroup` , `Form`
**Data display**
* `Text` , `Badge` , `Avatar` , `Table` , `DataTable` , `Progress`
**Navigation**
* `Link` , `Breadcrumb` , `Tab` , `Dropdown`
**Feedback**
* `Alert` , `Dialog` , `AlertDialog` , `Tooltip` , `Skeleton`
**Utility**
* `Icon` , `Separator` , `ScrollArea` , `Collapsible` , `Popover` , `Sheet`
### Usage
Import components directly from the package:
```tsx theme={null}
import { Button, Card, Text } from '@jtl-software/platform-ui-react';
export default function MyComponent() {
return (
Welcome to my JTL App
);
}
```
**What this does:** Renders a card with JTL-styled typography and a button.
## What's Next
Implement OAuth 2.0 and session token verification in your app.
Call the JTL Cloud REST and GraphQL APIs from your backend.
Respond to events and AppBridge messages.
Patterns for AppBridge initialization, error handling, and production
readiness.
# Architecture Overview
Source: https://developer.jtl-software.com/guides/cloud-apps/architecture-overview
Understand how JTL Cloud Apps are structured, how they communicate with the platform, and the four integration types available.
## What is a JTL Cloud App?
A JTL app is a software application that connects to JTL products or services through the API infrastructure. Apps can:
* Extend the functionality of JTL products
* Integrate in JTL products
* Provide specialized processes or tools for specific business needs
* Automate workflows between JTL and other systems
Every Cloud App consists of two components:
* **Frontend**: your app's UI, rendered inside an iframe within the JTL [ERP Cloud](https://erp.jtl-cloud.com/). Built with any web framework (React, Vue, or plain HTML).
* **Backend**: your server-side code that authenticates with JTL's Identity Provider, calls the JTL Cloud and JTL-Wawi API, and serves your frontend.
```mermaid theme={null}
flowchart TB
subgraph App ["Your App"]
FE["App Frontend
(iframe)"]
BE["App Backend"]
end
subgraph JTL ["JTL Platform"]
Cloud["JTL Hub"]
ERP["JTL Cloud / JTL-Wawi"]
AB["AppBridge"]
IDP["Identity Provider"]
API["JTL Cloud API"]
end
FE <-->|"AppBridge
Messages"| AB
AB <--> ERP
BE -->|"OAuth2
Client Credentials"| IDP
IDP -->|"JWT Access Token"| BE
BE -->|"Authenticated
API Calls"| API
Cloud -->|"Install / Manage"| App
style App fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style JTL fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
```
The frontend communicates with the JTL Cloud host application through **AppBridge**, a bidirectional messaging layer built on `postMessage`.
Your backend authenticates independently using OAuth 2.0 client credentials and calls the JTL Cloud API with a JWT access token.
## Integration Types
Cloud Apps support three integration types. Each type determines where your app appears, how it communicates, and what kind of experience it provides.
| Type | UI | Communication | Use case |
| -------------- | ---------------------------- | -------------------- | ---------------------------------------------------- |
| **Hub-Link** | Card in JTL Hub | Redirect to your URL | Entry points, external tools, dashboards |
| **ERP-iFrame** | Embedded in ERP main content | AppBridge messages | Rich interactive UI within the ERP |
| **Panel** | Sidebar in ERP | AppBridge messages | Context-aware panels (e.g., customer detail sidebar) |
All three types require a `manifest.json` and app registration through the [Partner Portal](https://partner.jtl-cloud.com/).
### Hub-Link
A Hub-Link app adds a card to the JTL Hub dashboard. When a merchant clicks it, the platform redirects them to your `appLauncher.redirectUrl`. This is the simplest integration type: no iframe, no AppBridge, just a redirect.
Use Hub-Link for external dashboards, standalone tools, or apps that don't need to render inside the JTL UI.
```json theme={null}
{
"capabilities": {
"hub": {
"appLauncher": {
"redirectUrl": "https://your-app.example.com/dashboard"
}
}
}
}
```
### ERP-iFrame
An ERP-iFrame app renders inside the main content area of ERP Cloud. Your frontend loads in an iframe and communicates with the host through the AppBridge. You define where your app appears using `menuItems` in the manifest, which adds entries to the ERP sidebar under **App** menu item.
This is the most common integration type for apps that require a rich, interactive UI within the merchant’s ERP workspace.
```json theme={null}
{
"capabilities": {
"erp": {
"menuItems": [
{
"id": "my-jtl-app",
"name": "my-jtl-app",
"url": "https://your-app.example.com/erp"
},
{
"id": "my-jtl-graphql-demo",
"name": "GraphQL Demo",
"url": "https://your-app.example.com/graphql-demo"
}
]
}
}
}
```
**Example:** An app that fetches product details from the ERP, sends them to
an external AI service to generate descriptions, and lets the merchant push
the result back to the product field with a button click.
### Panel
A Panel app renders as a resizable sidebar on the right side of the ERP
content area. Like ERP-iFrame apps, Panels have full access to the AppBridge. The
difference is purely UI placement: Panels appear alongside existing ERP views
rather than replacing them.
The panel remembers its state across the session. Its open or closed position and the selected app persist as the merchant navigates between views and across sign-ins, so a merchant who opens your app on one view finds it open on the next. The merchant can drag the panel edge to resize its width, and the last width is remembered.
When more than one installed app targets the same view, each app appears as its
own tab within the panel. The merchant switches between apps by selecting a tab.
When there are more tabs than fit the panel width, the overflow collapses into a
menu at the end of the tab bar.
Panels are context-aware. You specify which ERP view your panel appears in using the `context` field.
```json theme={null}
{
"capabilities": {
"erp": {
"pane": [
{
"id": "customer-panel",
"url": "https://your-app.example.com/pane/customers",
"context": "$tenantSlug.customers"
}
]
}
}
}
```
The `context` field uses a special syntax to refer to specific views in the ERP Cloud. The `$tenantSlug` refers to the current tenant, and the following text is the name of the view. For example, `$tenantSlug.customers` refers to the **Customers** view in the current tenant's ERP.
**Example:** A sidebar panel that reacts to the merchant navigating between customers, displaying real-time analytics or notes for the currently selected customer.
## App Installation Flow
Merchants discover and install apps from the [App Store](https://apps.jtl-cloud.com/). The installation process grants your app the permissions it needs to access the merchant's data.
```mermaid theme={null}
flowchart TD
A["Browse App Store"] --> B["Select App"]
B --> C["View Details and Click Install"]
C --> D["Permissions Granted Automatically"]
D --> E["App Active"]
E --> F["Merchant Uses App"]
style A fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
style E fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style F fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
```
The merchant browses the [App Store](https://apps.jtl-cloud.com/) and selects an app.
On the app's detail page, the merchant reviews the description, screenshots, and required permissions, then clicks **Install**.
The platform grants your app the scopes declared in your manifest. This happens automatically as part of the installation. The merchant does not need to approve individual scopes in a separate consent screen.
The app is now active in the merchant's environment. Depending on the integration type, it appears as a Hub card, ERP menu item, or sidebar panel.
## Authentication Flows
Every Cloud App gets an OAuth client with a `ClientId` and `ClientSecret` when registered in the [Partner Portal](https://partner.jtl-cloud.com/). When a merchant installs your app, it receives access to that merchant's tenant without the credentials changing. One set of credentials works across all tenants that install your app.
### Machine-to-Machine (M2M)
Use this flow when your backend needs to call JTL Cloud APIs without any user interaction. Your backend authenticates directly with the Identity Provider using client credentials.
```mermaid theme={null}
sequenceDiagram
autonumber
participant BE as App Backend
participant IDP as JTL Identity Provider
participant API as JTL Cloud API
BE->>IDP: Request access token (client credentials)
activate IDP
IDP-->>BE: Return access token (JWT)
deactivate IDP
BE->>API: Call API with access token + tenant ID
activate API
API-->>BE: Return response
deactivate API
```
1. Your backend sends its `ClientId` and `ClientSecret` to the Identity Provider.
2. The Identity Provider validates the credentials and returns a JWT access token.
3. Your backend uses the token (along with the `X-Tenant-ID` header) to call the JTL Cloud API.
4. The API processes the request and returns the data.
### Frontend-Initiated
Use this flow when your app has a frontend running in an iframe. The frontend gets a session token from the AppBridge, passes it to your backend, and the backend handles both session validation and API authentication.
```mermaid theme={null}
sequenceDiagram
autonumber
participant FE as App Frontend
participant AB as JTL AppBridge
participant BE as App Backend
participant IDP as JTL Identity Provider
participant ACC as JTL Account Service
participant API as JTL Cloud API
FE->>AB: Request session token
AB-->>FE: Return session token
FE->>BE: Request data (with session token)
par Backend authentication
BE->>IDP: Request access token (client credentials)
IDP-->>BE: Return access token
and Session validation
BE->>ACC: Validate session token (JWKS)
ACC-->>BE: Session valid (tenant info)
end
BE->>API: Call API (access token + tenant ID)
API-->>BE: Return data
BE-->>FE: Forward response
```
The frontend requests a session token from the AppBridge. This token contains the current user's identity and tenant information.
The frontend sends its request to your backend, including the session token.
Your backend does two things in parallel: requests an access token from the Identity Provider (client credentials), and validates the session token against JTL's Account Service using JWKS.
With a valid access token and confirmed tenant, your backend calls the JTL Cloud API and returns the response to the frontend.
## What's Next
Learn how the AppBridge, iframe messaging, and Platform UI components work.
Implement OAuth 2.0 and session token flows in your app.
Call the JTL Cloud and JTL-Wawi APIs from your backend with proper headers and scoping.
# Authentication & Login
Source: https://developer.jtl-software.com/guides/cloud-apps/authentication-login
Implement OAuth 2.0 client credentials and session token verification in your JTL Cloud App.
This guide walks through implementing authentication in your Cloud App. By the end, your backend will be able to request access tokens from JTL, verify session tokens from the AppBridge, and make authenticated API calls on behalf of a merchant's tenant.
If you need a conceptual overview of how JTL authentication works across Cloud, OnPremise, and SCX, see the [OAuth 2.0 Flow](/guides/essentials/authentication/oauth2-flow) and [API Keys & Tokens](/guides/essentials/authentication/api-keys-tokens) pages.
## Authentication Tokens and Their Roles
Cloud Apps use two tokens that work together: an **access token** and a **session token**.
| Token | Answers the question | Where it comes from |
| ----------------- | -------------------------------------------------------- | ------------------------------------------------------------------------ |
| **Access token** | Is *this app* authorized to call JTL APIs? | Your backend, by exchanging client credentials at the token endpoint |
| **Session token** | *Who* is making this request? (which tenant, which user) | Your frontend, via AppBridge: `appBridge.method.call('getSessionToken')` |
The access token authorizes your app to call JTL's tenant-specific APIs. The session token identifies which merchant the request is for. Most JTL Cloud API requests need both: the access token goes in the `Authorization` header, and the tenant ID (read from the verified session token) goes in the `X-Tenant-ID` header.
### How They Fit Together
1. Your frontend asks AppBridge for a session token.
2. Your frontend sends the session token to your backend.
3. Your backend verifies the session token and reads the `tenantId` from its payload.
4. Your backend separately fetches an access token using its client credentials.
5. Your backend calls the JTL Cloud API with the access token in `Authorization: Bearer` and the tenant ID in `X-Tenant-ID`.
```mermaid theme={null}
sequenceDiagram
participant FE as Your Frontend
participant BE as Your Backend
participant Bridge as AppBridge
participant Auth as JTL Auth
participant API as JTL Cloud API
FE->>Bridge: getSessionToken()
Bridge-->>FE: Session token (identity)
FE->>BE: Request (with session token)
BE->>BE: Verify session token, extract tenantId
BE->>Auth: Client credentials grant
Auth-->>BE: Access token (authorization)
BE->>API: Request + Bearer token + X-Tenant-ID
API-->>BE: Data
BE-->>FE: Response
```
## Client Credentials: Getting an Access Token
Your backend authenticates with JTL's Identity Provider using the `CLIENT_ID` and `CLIENT_SECRET` you received when registering your app in the [Partner Portal](https://partner.jtl-cloud.com/).
### Implementation
```typescript TypeScript theme={null}
// lib/jtl-auth.ts
const AUTH_ENDPOINT = "https://auth.jtl-cloud.com/oauth2/token";
const API_BASE_URL = "https://api.jtl-cloud.com";
export async function getAccessToken(): Promise {
const clientId = process.env.CLIENT_ID;
const clientSecret = process.env.CLIENT_SECRET;
if (!clientId || !clientSecret) {
throw new Error(
"CLIENT_ID and CLIENT_SECRET must be defined in environment variables"
);
}
const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString(
"base64"
);
const response = await fetch(AUTH_ENDPOINT, {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
Authorization: `Basic ${credentials}`,
},
body: new URLSearchParams({
grant_type: "client_credentials",
}),
});
if (!response.ok) {
const error = await response.json().catch(() => null);
throw new Error(
`Token request failed (${response.status}): ${error?.error || "unknown"}`
);
}
const data = await response.json();
return data.access_token;
}
export { API_BASE_URL };
```
```csharp C# theme={null}
// JtlAuth.cs
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
public static class JtlAuth
{
private const string AuthEndpoint = "https://auth.jtl-cloud.com/oauth2/token";
public const string ApiBaseUrl = "https://api.jtl-cloud.com";
private static readonly HttpClient HttpClient = new();
public static async Task GetAccessTokenAsync()
{
var clientId = Environment.GetEnvironmentVariable("CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("CLIENT_SECRET");
if (string.IsNullOrEmpty(clientId) || string.IsNullOrEmpty(clientSecret))
throw new InvalidOperationException(
"CLIENT_ID and CLIENT_SECRET must be defined in environment variables"
);
var credentials = Convert.ToBase64String(
Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}")
);
var request = new HttpRequestMessage(HttpMethod.Post, AuthEndpoint);
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", credentials);
request.Content = new FormUrlEncodedContent(new[]
{
new KeyValuePair("grant_type", "client_credentials")
});
var response = await HttpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
string? errorCode = null;
try
{
var errorBody = await response.Content.ReadAsStringAsync();
using var errorDoc = JsonDocument.Parse(errorBody);
errorCode = errorDoc.RootElement.GetProperty("error").GetString();
}
catch { /* ignore parse failures */ }
throw new HttpRequestException(
$"Token request failed ({(int)response.StatusCode}): {errorCode ?? "unknown"}"
);
}
var json = await response.Content.ReadAsStringAsync();
using var doc = JsonDocument.Parse(json);
return doc.RootElement.GetProperty("access_token").GetString()
?? throw new InvalidOperationException("Response did not contain an access_token");
}
}
```
```php PHP theme={null}
post(self::AUTH_ENDPOINT, [
'headers' => [
'Content-Type' => 'application/x-www-form-urlencoded',
'Authorization' => "Basic {$credentials}",
],
'form_params' => [
'grant_type' => 'client_credentials',
],
]);
} catch (RequestException $e) {
$status = $e->getResponse()?->getStatusCode() ?? 0;
$errorCode = 'unknown';
if ($e->hasResponse()) {
$body = (string) $e->getResponse()->getBody();
$decoded = json_decode($body, true);
$errorCode = $decoded['error'] ?? 'unknown';
}
throw new RuntimeException("Token request failed ({$status}): {$errorCode}");
}
$data = json_decode((string) $response->getBody(), true, flags: JSON_THROW_ON_ERROR);
return $data['access_token'];
}
private static function httpClient(): Client
{
return self::$httpClient ??= new Client();
}
}
```
```bash cURL theme={null}
curl -X POST https://auth.jtl-cloud.com/oauth2/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Authorization: Basic $(echo -n 'CLIENT_ID:CLIENT_SECRET' | base64)" \
-d "grant_type=client_credentials"
```
**What this does:** Encodes your client credentials as Base64, sends them to JTL's auth endpoint with the `client_credentials` grant type, and returns a JWT access token. This token authenticates your backend for API calls.
### Token Response
A successful request returns:
```json theme={null}
{
"access_token": "eyJhbGciOiJSUzI1NiIs...",
"expires_in": 86399,
"scope": "",
"token_type": "bearer"
}
```
| Field | Description |
| -------------- | ------------------------------------------------------------ |
| `access_token` | JWT used in the `Authorization: Bearer` header for API calls |
| `expires_in` | Token lifetime in seconds (\~24 hours) |
| `token_type` | Always `bearer` |
### Caching and Refreshing Tokens
Access tokens are valid for approximately 24 hours. Requesting a new token on every API call adds latency and unnecessary load on the auth server. Cache the token and refresh it before it expires.
```typescript TypeScript theme={null}
// lib/token-cache.ts
let cachedToken: string | null = null;
let tokenExpiresAt = 0;
let inflightRequest: Promise | null = null;
export async function getCachedAccessToken(): Promise {
const now = Date.now();
const bufferMs = 60_000;
if (cachedToken && now < tokenExpiresAt - bufferMs) {
return cachedToken;
}
if (inflightRequest) {
return inflightRequest;
}
inflightRequest = (async () => {
try {
const token = await getAccessToken();
// Decode the JWT to read the expiry (without verifying, since we just received it)
const payload = JSON.parse(
Buffer.from(token.split(".")[1], "base64url").toString()
);
cachedToken = token;
tokenExpiresAt = payload.exp * 1000;
return cachedToken!;
} finally {
inflightRequest = null;
}
})();
return inflightRequest;
}
export function clearTokenCache(): void {
cachedToken = null;
tokenExpiresAt = 0;
}
```
```csharp C# theme={null}
// TokenCache.cs
using System.Text.Json;
public static class TokenCache
{
private static string? _cachedToken = null;
private static long _tokenExpiresAt = 0;
private static readonly SemaphoreSlim _lock = new(1, 1);
public static async Task GetCachedAccessTokenAsync()
{
var now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
const long bufferMs = 60_000;
if (_cachedToken != null && now < _tokenExpiresAt - bufferMs)
return _cachedToken;
await _lock.WaitAsync();
try
{
now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
if (_cachedToken != null && now < _tokenExpiresAt - bufferMs)
return _cachedToken;
var token = await JtlAuth.GetAccessTokenAsync();
// Decode the JWT to read the expiry (without verifying, since we just received it)
var payloadBase64 = token.Split('.')[1];
var paddedPayload = payloadBase64.PadRight(
payloadBase64.Length + (4 - payloadBase64.Length % 4) % 4, '='
);
var payloadJson = System.Text.Encoding.UTF8.GetString(
Convert.FromBase64String(paddedPayload)
);
using var doc = JsonDocument.Parse(payloadJson);
var exp = doc.RootElement.GetProperty("exp").GetInt64();
_cachedToken = token;
_tokenExpiresAt = exp * 1000;
return _cachedToken;
}
finally
{
_lock.Release();
}
}
public static void ClearCache()
{
_cachedToken = null;
_tokenExpiresAt = 0;
}
}
```
```php PHP theme={null}
**What this does:** Stores the access token in memory and reuses it until 60 seconds before expiry. When the buffer is reached, it fetches a fresh token. This prevents both unnecessary auth requests and failures from expired tokens mid-request.
This in-memory cache works for single-instance servers. If you're running multiple instances (e.g., behind a load balancer), use a shared cache like Redis instead.
## Session Tokens: Verifying the Frontend User
When your app runs inside the App Shell, the frontend gets a session token from the AppBridge. This token identifies who the user is and which tenant (merchant) they belong to. Your backend must verify this token before trusting it.
### How it Works
1. Your frontend calls `appBridge.method.call('getSessionToken')` to get a session token from the App Shell
2. The frontend sends this token to your backend (through the header)
3. Your backend fetches JTL's public keys (JWKS) and uses them to verify the token's signature
4. The verified payload contains the `tenantId`, `userId`, and `tenantSlug`
### Session Token Payload
A decoded session token contains:
```json theme={null}
{
"exp": 1700000000,
"userId": "user-abc-123",
"tenantId": "tenant-xyz-789",
"tenantSlug": "my-store"
}
```
| Field | Description |
| ------------ | ------------------------------------------------------------------------------------- |
| `exp` | Expiration timestamp (Unix seconds) |
| `userId` | The JTL user who is currently logged in |
| `tenantId` | The merchant's tenant identifier. Use this in the `X-Tenant-ID` header for API calls. |
| `tenantSlug` | Human-readable tenant name |
### Implementation
```typescript TypeScript theme={null}
// lib/verify-session.ts
import { importJWK, jwtVerify } from "jose";
import { getAccessToken, API_BASE_URL } from "./jtl-auth";
export interface SessionTokenPayload {
exp: number;
userId: string;
tenantId: string;
tenantSlug: string;
}
export async function verifySessionToken(
sessionToken: string
): Promise {
const accessToken = await getAccessToken();
// Fetch JTL's public keys
const response = await fetch(
`${API_BASE_URL}/account/.well-known/jwks.json`,
{
headers: {
Authorization: `Bearer ${accessToken}`,
},
}
);
if (!response.ok) {
throw new Error(`Failed to fetch JWKS (${response.status})`);
}
const jwks = await response.json();
// Select the signing key by its JWK properties (use=sig, alg=EdDSA)
const signingKey = jwks.keys.find(
(k: { use?: string; alg?: string }) =>
k.use === "sig" && k.alg === "EdDSA"
);
if (!signingKey) {
throw new Error("No EdDSA signing key found in JWKS");
}
const publicKey = await importJWK(signingKey, "EdDSA");
const { payload } = await jwtVerify(sessionToken, publicKey);
return payload as unknown as SessionTokenPayload;
}
```
```csharp C# theme={null}
// VerifySession.cs
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using NSec.Cryptography;
public record SessionTokenPayload(
long Exp,
string UserId,
string TenantId,
string? TenantSlug
);
public static class VerifySession
{
private static readonly HttpClient HttpClient = new();
public static async Task VerifySessionTokenAsync(string sessionToken)
{
var accessToken = await JtlAuth.GetAccessTokenAsync();
var request = new HttpRequestMessage(
HttpMethod.Get,
$"{JtlAuth.ApiBaseUrl}/account/.well-known/jwks.json"
);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var response = await HttpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
throw new HttpRequestException($"Failed to fetch JWKS ({(int)response.StatusCode})");
var jwksJson = await response.Content.ReadAsStringAsync();
var jwks = JsonSerializer.Deserialize(jwksJson);
// Select the signing key by its JWK properties (use=sig, alg=EdDSA)
JsonElement? signingKey = null;
foreach (var k in jwks.GetProperty("keys").EnumerateArray())
{
var use = k.TryGetProperty("use", out var u) ? u.GetString() : null;
var alg = k.TryGetProperty("alg", out var a) ? a.GetString() : null;
if (use == "sig" && alg == "EdDSA")
{
signingKey = k;
break;
}
}
if (signingKey is null)
throw new InvalidOperationException("No EdDSA signing key found in JWKS");
// JTL session tokens are signed with Ed25519 (OKP)
var publicKeyBytes = Base64UrlDecode(signingKey.Value.GetProperty("x").GetString()!);
return VerifyAndDecode(sessionToken, publicKeyBytes);
}
private static SessionTokenPayload VerifyAndDecode(string token, byte[] publicKeyBytes)
{
var parts = token.Split('.');
if (parts.Length != 3)
throw new ArgumentException("Invalid JWT format. Expected 3 dot-separated parts.");
var signedData = Encoding.ASCII.GetBytes($"{parts[0]}.{parts[1]}");
var signature = Base64UrlDecode(parts[2]);
var algorithm = SignatureAlgorithm.Ed25519;
var publicKey = PublicKey.Import(algorithm, publicKeyBytes, KeyBlobFormat.RawPublicKey);
if (!algorithm.Verify(publicKey, signedData, signature))
throw new UnauthorizedAccessException("Invalid token signature.");
var payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(parts[1]));
var payload = JsonSerializer.Deserialize(payloadJson);
var exp = payload.GetProperty("exp").GetInt64();
if (DateTimeOffset.FromUnixTimeSeconds(exp) < DateTimeOffset.UtcNow)
throw new UnauthorizedAccessException("Token has expired.");
return new SessionTokenPayload(
Exp: exp,
UserId: payload.GetProperty("userId").GetString()!,
TenantId: payload.GetProperty("tenantId").GetString()!,
TenantSlug: payload.TryGetProperty("tenantSlug", out var slug) ? slug.GetString() : null
);
}
private static byte[] Base64UrlDecode(string input)
{
var padded = input.Replace('-', '+').Replace('_', '/');
padded += (padded.Length % 4) switch
{
2 => "==",
3 => "=",
_ => ""
};
return Convert.FromBase64String(padded);
}
}
```
```php PHP theme={null}
get(
JtlAuth::API_BASE_URL . '/account/.well-known/jwks.json',
['headers' => ['Authorization' => "Bearer {$accessToken}"]]
);
if ($response->getStatusCode() !== 200) {
throw new RuntimeException("Failed to fetch JWKS ({$response->getStatusCode()})");
}
$jwks = json_decode((string) $response->getBody(), true, flags: JSON_THROW_ON_ERROR);
// Split the JWT into its three parts
$parts = explode('.', $sessionToken);
if (count($parts) !== 3) {
throw new UnexpectedValueException('Invalid JWT format. Expected 3 dot-separated parts');
}
[$headerB64, $payloadB64, $signatureB64] = $parts;
// Select the signing key by its JWK properties (use=sig, alg=EdDSA)
$signingKey = null;
foreach ($jwks['keys'] as $k) {
if (($k['use'] ?? null) === 'sig' && ($k['alg'] ?? null) === 'EdDSA') {
$signingKey = $k;
break;
}
}
if ($signingKey === null) {
throw new RuntimeException('No EdDSA signing key found in JWKS');
}
// JTL session tokens are signed with Ed25519 (OKP). The raw public key
// sits in the `x` parameter of the JWK as base64url-encoded bytes.
$publicKey = self::base64UrlDecode($signingKey['x']);
$signedData = "{$headerB64}.{$payloadB64}";
$signature = self::base64UrlDecode($signatureB64);
$isValid = sodium_crypto_sign_verify_detached($signature, $signedData, $publicKey);
if (!$isValid) {
throw new UnexpectedValueException('Invalid token signature');
}
$payload = json_decode(self::base64UrlDecode($payloadB64), true, flags: JSON_THROW_ON_ERROR);
if (($payload['exp'] ?? 0) < time()) {
throw new UnexpectedValueException('Token has expired');
}
return new SessionTokenPayload(
exp: $payload['exp'],
userId: $payload['userId'],
tenantId: $payload['tenantId'],
tenantSlug: $payload['tenantSlug'] ?? null,
);
}
private static function httpClient(): Client
{
return self::$httpClient ??= new Client();
}
private static function base64UrlDecode(string $input): string
{
$padded = strtr($input, '-_', '+/');
$padded .= str_repeat('=', (4 - strlen($padded) % 4) % 4);
return base64_decode($padded);
}
}
```
**What this does:** Fetches JTL's public keys from the JWKS endpoint (authenticated with your access token) and verifies the token's signature. The returned payload tells you which user and tenant the request belongs to.
In production, cache the JWKS response. Public keys change infrequently, so fetching them on every request adds unnecessary latency.
***
## Wiring it Together: The `connect-tenant` Route
The connect-tenant pattern ties both flows together. Your frontend gets a session token, sends it as a header (`X-Session-ID`) to your backend, and your backend verifies it and returns the tenant details.
```typescript TypeScript theme={null}
import express, { Request, Response } from 'express';
import { verifySessionToken } from '../lib/verify-session';
const app = express();
app.get('/api/connect-tenant', async (req: Request, res: Response) => {
const sessionToken = req.headers['x-session-id'] as string;
if (!sessionToken) {
return res.status(400).json({ error: 'Session token is required' });
}
try {
const payload = await verifySessionToken(sessionToken);
return res.json({
success: true,
tenantId: payload.tenantId,
userId: payload.userId,
tenantSlug: payload.tenantSlug,
});
} catch (error) {
return res.status(401).json({ error: 'Failed to verify session token' });
}
});
```
```csharp C# theme={null}
// ConnectTenantEndpoint.cs
public static class ConnectTenantEndpoint
{
private static readonly HttpClient HttpClient = new();
public static async Task HandleAsync(HttpRequest request)
{
try
{
var sessionToken = request.Headers["X-Session-ID"].FirstOrDefault();
if (string.IsNullOrEmpty(sessionToken))
{
return Results.Json(new { error = "Session token is required" }, statusCode: 400);
}
var payload = await VerifySession.VerifySessionTokenAsync(sessionToken);
// In production, store the tenant connection in your database here
return Results.Json(new
{
success = true,
tenantId = payload.TenantId,
userId = payload.UserId,
tenantSlug = payload.TenantSlug,
});
}
catch (Exception ex)
{
Console.Error.WriteLine($"Connection failed: {ex}");
return Results.Json(new { error = "Failed to verify session token" }, statusCode: 401);
}
}
}
```
```php PHP theme={null}
getHeaderLine('X-Session-ID');
if ($sessionToken === '') {
return self::json($response, ['error' => 'Session token is required'], 400);
}
try {
$payload = VerifySession::verifySessionToken($sessionToken);
return self::json($response, [
'success' => true,
'tenantId' => $payload->tenantId,
'userId' => $payload->userId,
'tenantSlug' => $payload->tenantSlug,
]);
} catch (Throwable) {
return self::json($response, ['error' => 'Failed to verify session token'], 401);
}
}
private static function json(ResponseInterface $response, array $data, int $status = 200): ResponseInterface
{
$response->getBody()->write(json_encode($data, JSON_THROW_ON_ERROR));
return $response->withHeader('Content-Type', 'application/json')->withStatus($status);
}
}
```
**What this does:** Receives the session token from your frontend, verifies it using JWKS, and returns the tenant details. In a production app, this is where you would store the tenant connection in your database so you can associate future API calls with the correct merchant.
### Calling from the Frontend
Your frontend sends the session token to this route after the AppBridge initializes:
```typescript theme={null}
const sessionToken = await appBridge.method.call("getSessionToken");
const response = await fetch("/api/connect-tenant", {
method: "POST",
headers: {
"X-Session-ID": sessionToken,
},
});
const { tenantId } = await response.json();
```
**What this does:** Gets the session token from the App Shell via AppBridge, sends it to your backend for verification, and receives the verified tenant ID. Your frontend can then pass this tenant ID in subsequent API requests.
For the full frontend integration pattern using React Context, see the [AppBridge Provider](/get-started/quick-start/from-scratch#appbridge-provider) in the From Scratch quickstart.
## Tenant Mapping
When a merchant installs your app, you need to store a record linking their JTL tenant ID to your app's internal state. Without this mapping, your backend has no way to associate future requests.
In-memory storage works in development but is wiped on every restart and does not survive multiple server instances. Use a persistent store from the start.
### What to Store
At minimum, persist the following on install:
| Field | Where it comes from | Why you need it |
| ------------------- | ------------------------------ | ------------------------------------------------------ |
| `tenantId` | Verified session token payload | Primary key, identifies the merchant |
| `tenantSlug` | Verified session token payload | Human-readable identifier, useful for logs and support |
| `installedAt` | Your server timestamp | Audit trail, debugging |
| `installedByUserId` | Verified session token payload | Who installed the app, useful for support |
If your app has its own user or account model, link the `tenantId` to your internal record.
### When to Write
Write the record in your `/api/connect-tenant` handler, after you verify the session token and before you return success to the frontend. Use an upsert rather than an insert: the same merchant may reinstall your app, and a duplicate-key error on reinstall is a poor experience.
A minimal PostgreSQL schema:
```sql theme={null}
CREATE TABLE jtl_tenants (
tenant_id UUID PRIMARY KEY,
tenant_slug TEXT NOT NULL,
installed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
installed_by UUID NOT NULL,
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
```
Then upsert on install:
```typescript TypeScript theme={null}
import { Request, Response } from 'express';
import { Pool } from 'pg';
import { verifySessionToken } from '../lib/verify-session';
const pool = new Pool();
app.get('/api/install', async (req: Request, res: Response) => {
const sessionToken = req.headers['x-session-id'] as string;
if (!sessionToken) {
return res.status(400).json({ error: 'Session token is required' });
}
try {
const payload = await verifySessionToken(sessionToken);
await pool.query(
`INSERT INTO jtl_tenants (tenant_id, tenant_slug, installed_by)
VALUES ($1, $2, $3)
ON CONFLICT (tenant_id) DO UPDATE
SET tenant_slug = EXCLUDED.tenant_slug,
installed_by = EXCLUDED.installed_by,
updated_at = NOW()`,
[payload.tenantId, payload.tenantSlug, payload.userId]
);
return res.json({ tenantId: payload.tenantId });
} catch (error) {
return res.status(401).json({ error: 'Failed to verify session token' });
}
});
```
```csharp C# theme={null}
using Microsoft.AspNetCore.Mvc;
using Npgsql;
public static class InstallEndpoint
{
private static readonly HttpClient HttpClient = new();
private static readonly NpgsqlDataSource DataSource =
NpgsqlDataSource.Create(Environment.GetEnvironmentVariable("DATABASE_URL")!);
public static async Task HandleAsync(HttpRequest request)
{
var sessionToken = request.Headers["X-Session-ID"].FirstOrDefault()
?? throw new InvalidOperationException("X-Session-ID header is required");
var payload = await VerifySession.VerifySessionTokenAsync(sessionToken);
await using var cmd = DataSource.CreateCommand(
"""
INSERT INTO jtl_tenants (tenant_id, tenant_slug, installed_by)
VALUES ($1, $2, $3)
ON CONFLICT (tenant_id) DO UPDATE
SET tenant_slug = EXCLUDED.tenant_slug,
installed_by = EXCLUDED.installed_by,
updated_at = NOW()
"""
);
cmd.Parameters.AddWithValue(payload.TenantId);
cmd.Parameters.AddWithValue(payload.TenantSlug);
cmd.Parameters.AddWithValue(payload.UserId);
await cmd.ExecuteNonQueryAsync();
return Results.Json(new { tenantId = payload.TenantId });
}
}
```
```php PHP theme={null}
getHeaderLine('X-Session-ID');
if ($sessionToken === '') {
return self::json($response, ['error' => 'Session token is required'], 400);
}
$payload = VerifySession::verifySessionToken($sessionToken);
$stmt = $this->pdo->prepare(
'INSERT INTO jtl_tenants (tenant_id, tenant_slug, installed_by)
VALUES (:tenant_id, :tenant_slug, :installed_by)
ON CONFLICT (tenant_id) DO UPDATE
SET tenant_slug = EXCLUDED.tenant_slug,
installed_by = EXCLUDED.installed_by,
updated_at = NOW()'
);
$stmt->execute([
':tenant_id' => $payload->tenantId,
':tenant_slug' => $payload->tenantSlug,
':installed_by' => $payload->userId,
]);
return self::json($response, ['tenantId' => $payload->tenantId]);
}
private static function json(ResponseInterface $response, array $data, int $status = 200): ResponseInterface
{
$response->getBody()->write(json_encode($data, JSON_THROW_ON_ERROR));
return $response->withHeader('Content-Type', 'application/json')->withStatus($status);
}
}
```
**What this does:** Verifies the session token to get a trusted tenant ID, then writes (or updates) the mapping in your database. The `ON CONFLICT` clause handles reinstalls cleanly.
### When to Read
On every incoming request from your frontend, extract the tenant ID from the verified session token and look up your internal record:
```typescript TypeScript theme={null}
// Inside your route handler
const payload = await verifySessionToken(sessionToken);
const result = await pool.query(
'SELECT * FROM jtl_tenants WHERE tenant_id = $1',
[payload.tenantId],
);
if (result.rowCount === 0) {
return res.status(404).json({ error: 'Tenant not found' });
}
const tenant = result.rows[0];
```
```csharp C# theme={null}
// Inside your route handler
var payload = await VerifySession.VerifySessionTokenAsync(sessionToken);
await using var cmd = DataSource.CreateCommand(
"SELECT * FROM jtl_tenants WHERE tenant_id = $1"
);
cmd.Parameters.AddWithValue(payload.TenantId);
await using var reader = await cmd.ExecuteReaderAsync();
if (!reader.HasRows)
return Results.Json(new { error = "Tenant not found" }, statusCode: 404);
await reader.ReadAsync();
var tenant = new
{
TenantId = reader["tenant_id"],
TenantSlug = reader["tenant_slug"],
InstalledBy = reader["installed_by"],
UpdatedAt = reader["updated_at"],
};
```
```php PHP theme={null}
// Inside your route handler ($request, $response, $pdo are in scope)
$payload = VerifySession::verifySessionToken($sessionToken);
$stmt = $pdo->prepare('SELECT * FROM jtl_tenants WHERE tenant_id = :tenant_id');
$stmt->execute([':tenant_id' => $payload->tenantId]);
$tenant = $stmt->fetch(PDO::FETCH_ASSOC);
if ($tenant === false) {
$response->getBody()->write(json_encode(['error' => 'Tenant not found']));
return $response->withHeader('Content-Type', 'application/json')->withStatus(404);
}
```
A merchant who uninstalls and reinstalls should invalidate any cached state your app holds for that tenant.
### What Not to Do
A few anti-patterns cause most tenant-mapping bugs in production. Avoid each of these from the start.
| Don't | Why |
| -------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| Store tenant mappings only in memory | Wiped on every restart, does not survive multiple instances |
| Trust a `tenantId` sent directly from the frontend | A browser can send any value. Always extract the tenant ID from a server-verified session token |
| Store the session token itself | Session tokens expire. Store the `tenantId` they prove, not the token |
| Assume tenant IDs are sequential or predictable | They are UUIDs. Treat them as opaque identifiers |
## Token Lifecycle
Understanding when tokens expire and how to handle expiry prevents intermittent auth failures in production.
### Access Tokens
Access tokens from the client credentials flow expire after approximately **24 hours** (86399 seconds). Your backend should cache and reuse the token, refreshing it before expiry. See the [token caching example](#caching-tokens) above.
If an API call returns `401 Unauthorized`, clear your cached token and request a new one before retrying:
```typescript TypeScript theme={null}
// lib/api-client.ts
import { getCachedAccessToken, clearTokenCache } from './token-cache';
async function callApiWithRetry(url: string, tenantId: string) {
let token = await getCachedAccessToken();
let response = await fetch(url, {
headers: {
Authorization: `Bearer ${token}`,
'X-Tenant-ID': tenantId,
},
});
if (response.status === 401) {
// Token may have expired, clear cache and retry once
clearTokenCache();
token = await getCachedAccessToken();
response = await fetch(url, {
headers: {
Authorization: `Bearer ${token}`,
'X-Tenant-ID': tenantId,
},
});
}
return response;
}
```
```csharp C# theme={null}
// ApiClient.cs
using System.Net.Http.Headers;
public static class ApiClient
{
private static readonly HttpClient HttpClient = new();
public static async Task CallApiWithRetryAsync(string url, string tenantId)
{
var token = await TokenCache.GetCachedAccessTokenAsync();
var response = await SendRequestAsync(url, tenantId, token);
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
// Token may have expired, clear cache and retry once
TokenCache.ClearCache();
token = await TokenCache.GetCachedAccessTokenAsync();
response = await SendRequestAsync(url, tenantId, token);
}
return response;
}
private static async Task SendRequestAsync(string url, string tenantId, string token)
{
var request = new HttpRequestMessage(HttpMethod.Get, url);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
request.Headers.Add("X-Tenant-ID", tenantId);
return await HttpClient.SendAsync(request);
}
}
```
```php PHP theme={null}
getStatusCode() === 401) {
// Token may have expired, clear cache and retry once
TokenCache::clearCache();
$token = TokenCache::getCachedAccessToken();
$response = self::sendRequest($url, $tenantId, $token);
}
return $response;
}
private static function sendRequest(string $url, string $tenantId, string $token): Response
{
try {
return self::httpClient()->get($url, [
'headers' => [
'Authorization' => "Bearer {$token}",
'X-Tenant-ID' => $tenantId,
],
'http_errors' => false,
]);
} catch (RequestException $e) {
return $e->getResponse() ?? throw $e;
}
}
private static function httpClient(): Client
{
return self::$httpClient ??= new Client();
}
}
```
**What this does:** Attempts the API call with the cached token. If the server returns 401, it clears the cache, gets a fresh token, and retries once. This handles the edge case where a token expires between the cache check and the API call.
### Session Tokens
Session tokens from the AppBridge are short-lived. If your frontend holds a session token too long, verification will fail on the backend. Request a fresh session token before each backend call, or at minimum before operations that require verified identity:
```typescript theme={null}
// Get a fresh token before each sensitive operation
const freshToken = await appBridge.method.call('getSessionToken');
```
## Common Authentication Errors
These are the most frequent authentication issues and how to resolve them.
Your `CLIENT_ID` or `CLIENT_SECRET` is incorrect. Verify both values in your `.env` file. Check for extra whitespace, missing characters, or swapped values. If you've lost your secret, regenerate credentials by creating a new app in the [Partner Portal](https://partner.jtl-cloud.com).
Your access token has expired. If you're caching tokens, make sure you refresh before the `expires_in` window closes. The [token caching example](#caching-tokens) refreshes 60 seconds before expiry to prevent this.
The session token from AppBridge could not be verified.
Common causes: the JWKS endpoint returned an error (check your access token), or the session token has expired (request a fresh one from AppBridge).
The JWKS endpoint requires a valid access token in the `Authorization` header. Make sure you're passing `Bearer `, not the session token or client credentials. If the access token itself is expired, refresh it first.
***
## What's Next
Call the JTL Cloud and JTL-Wawi REST and GraphQL APIs with your authenticated tokens.
Reference for the manifest, AppBridge API, and Platform UI components.
Production patterns for token caching, error handling, and security.
# Best Practices
Source: https://developer.jtl-software.com/guides/cloud-apps/best-practices
Recommended patterns and practices for building Cloud Apps, including migration from the legacy plugin bridge
This guide outlines the essential patterns for building production-ready Cloud Apps. Each section focuses on a specific part of your app’s architecture, with practical guidance and code examples where relevant.
## AppBridge Initialization
How you initialize the AppBridge determines whether your app starts reliably or fails intermittently with race conditions.
### Initialize Before Rendering
Always create the AppBridge instance before your React app renders. If you initialize it inside a component (e.g., in `useEffect`), child components may try to access the bridge before it's ready.
```tsx theme={null}
// Correct: initialize before render
import { createAppBridge } from '@jtl-software/cloud-apps-core';
createAppBridge().then((appBridge) => {
createRoot(document.getElementById('root')!).render(
,
);
});
```
```tsx theme={null}
// Incorrect: initializing inside a component
function App() {
const [bridge, setBridge] = useState(null);
useEffect(() => {
// This causes a race condition: children render before the bridge is ready
createAppBridge().then(setBridge);
}, []);
return ;
}
```
### Use Dynamic Imports for SSR Frameworks
If you're using Next.js or another framework with server-side rendering, the AppBridge SDK fails on the server because it requires a browser environment. Use a client-side provider with dynamic imports.
```tsx theme={null}
'use client';
useEffect(() => {
async function init() {
const { createAppBridge } =
await import('@jtl-software/cloud-apps-core');
const bridge = await createAppBridge();
// Store in state or context
}
init();
}, []);
```
**What this does:** Delays the import until the component runs in the browser, preventing `window is not defined` errors during server rendering. See the [From Scratch quickstart](/get-started/quick-start/from-scratch#appbridge-provider) for the full provider pattern.
### Handle Initialization Failures
The AppBridge can fail to initialize if your app isn't running inside the App Shell (e.g., during local development in a regular browser tab). Always catch errors and display a helpful message.
```tsx theme={null}
try {
const bridge = await createAppBridge();
setAppBridge(bridge);
} catch (err) {
setError(
'Could not connect to JTL. Make sure the app is running inside the App Shell.',
);
}
```
***
## Authentication
Token management is the most common source of production issues. These patterns prevent the majority of auth-related failures.
### Cache Access Tokens
Access tokens are valid for approximately 24 hours. Requesting a new token on every API call wastes time and puts unnecessary load on the auth server. Cache the token in memory and refresh it before expiry.
```typescript theme={null}
let cachedToken: string | null = null;
let tokenExpiresAt = 0;
const BUFFER_MS = 60_000; // refresh 60 seconds early
export async function getCachedAccessToken(): Promise {
if (cachedToken && Date.now() < tokenExpiresAt - BUFFER_MS) {
return cachedToken;
}
const token = await getAccessToken();
const payload = JSON.parse(
Buffer.from(token.split('.')[1], 'base64').toString(),
);
cachedToken = token;
tokenExpiresAt = payload.exp * 1000;
return cachedToken;
}
```
**What this does:** Reuses the cached token until 60 seconds before expiry, then fetches a fresh one. The buffer prevents failures from tokens expiring mid-request.
### Retry on 401
Even with caching, tokens can expire unexpectedly (server clock drift, cache invalidation). Retry once with a fresh token before surfacing the error.
```typescript theme={null}
async function authenticatedFetch(url: string, tenantId: string) {
let token = await getCachedAccessToken();
let response = await fetch(url, {
headers: {
Authorization: `Bearer ${token}`,
'X-Tenant-Id': tenantId,
},
});
if (response.status === 401) {
cachedToken = null;
token = await getCachedAccessToken();
response = await fetch(url, {
headers: {
Authorization: `Bearer ${token}`,
'X-Tenant-ID': tenantId,
},
});
}
return response;
}
```
### Never Expose Credentials to the Frontend
Your `CLIENT_SECRET` must stay on the server. Never include it in frontend code, environment variables prefixed with `NEXT_PUBLIC_`, or client-side bundles. The frontend authenticates through the AppBridge session token, not client credentials.
### Refresh Session Tokens before Sensitive Operations
Session tokens from the AppBridge are short-lived. Request a fresh one before operations that require verified identity, rather than reusing a token obtained minutes ago.
```typescript theme={null}
// Before each sensitive operation
const freshToken = await appBridge.method.call('getSessionToken');
await fetch('/api/connect-tenant', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ sessionToken: freshToken }),
});
```
***
## API Usage
Efficient API usage keeps your app fast and prevents rate limiting.
### Request Only the Fields You Need
GraphQL lets you specify exactly which fields to return. Avoid requesting fields your UI doesn't display. Smaller payloads mean faster responses and less bandwidth.
```graphql theme={null}
# Too broad: fetching everything
query {
QueryItems(first: 50) {
nodes {
id
sku
name
gtin
upc
defaultAsin
salesPriceNet
averagePurchasePriceNet
stockTotal
stockInOrders
manufacturerId
manufacturerName
productGroupId
productGroupName
taxClassId
taxClassName
notes
basePriceUnit
}
}
}
# Better: only what the UI needs
query {
QueryItems(first: 50) {
nodes {
id
sku
name
salesPriceNet
stockTotal
}
}
}
```
### Paginate Large Datasets
Never fetch all records at once. Use cursor-based pagination with a reasonable page size (10-50 items). Fetch the next page only when the user scrolls or clicks "Load more."
```typescript theme={null}
async function fetchAllItems(tenantId: string): Promise {
const items: Item[] = [];
let cursor: string | null = null;
let hasMore = true;
while (hasMore) {
const data = await query(tenantId, 'GetERPItems', ITEMS_QUERY, {
first: 50,
after: cursor,
});
items.push(...data.QueryItems.nodes);
hasMore = data.QueryItems.pageInfo.hasNextPage;
cursor = data.QueryItems.pageInfo.endCursor;
}
return items;
}
```
**What this does:** Fetches items in pages of 50 until all records are retrieved. For background sync jobs this is fine, but for UI-driven fetching, load pages on demand instead of fetching everything upfront.
### Handle GraphQL Errors in the Response Body
GraphQL returns errors inside the JSON body, not as HTTP status codes. A `200 OK` response can still contain errors. Always check both `data` and `errors`.
```typescript theme={null}
const { data, errors } = await response.json();
if (errors?.length) {
console.error('GraphQL errors:', errors);
throw new Error(errors[0].message);
}
```
***
## Error Handling
Consistent error handling prevents your app from crashing and gives merchants useful feedback when things go wrong.
### Wrap API Calls in try/catch
Every API call can fail. Network issues, expired tokens, rate limits, and server errors all produce exceptions. Catch them and provide meaningful error states.
```typescript theme={null}
async function loadItems(tenantId: string) {
try {
setLoading(true);
setError(null);
const data = await fetchItems(tenantId);
setItems(data.nodes);
} catch (err) {
console.error('Failed to load items:', err);
setError('Could not load products. Please try again.');
} finally {
setLoading(false);
}
}
```
### Distinguish Error Types
Different errors require different responses. A network timeout should be retried. A 403 should prompt the merchant to check permissions. A validation error should highlight the problematic field.
```typescript theme={null}
if (response.status === 401) {
// Token expired: refresh and retry
} else if (response.status === 403) {
// Missing scopes: show a message about permissions
} else if (response.status === 429) {
// Rate limited: wait and retry with backoff
} else if (response.status >= 500) {
// Server error: retry with backoff, then show an error
}
```
### Show Loading and Error States
Never leave the merchant looking at a blank screen. Show a loading indicator while data is being fetched, and a clear error message if something fails.
```tsx theme={null}
if (loading) return
Loading products...
;
if (error) return
{error}
;
if (items.length === 0) return
No products found.
;
return ;
```
***
## Security
These practices protect both your app and the merchants who use it.
### Verify Session Tokens on the Backend
Never trust a session token without verifying it. The frontend can be manipulated. Your backend should verify every session token against JTL's JWKS before using the tenant ID from it.
### Validate Tenant ID on Every Request
When your frontend sends a tenant ID to your backend, verify it matches the tenant ID in the verified session token. This prevents one merchant from accessing another merchant's data.
```typescript theme={null}
const session = await verifySessionToken(sessionToken);
if (session.tenantId !== requestedTenantId) {
return NextResponse.json({ error: 'Tenant mismatch' }, { status: 403 });
}
```
### Use HTTPS in Production
All production URLs in your manifest (`configurationUrl`, menu item URLs, panel URLs) must use HTTPS. HTTP is acceptable for `localhost` during development only.
### Store Credentials Securely
Keep your `CLIENT_SECRET` in environment variables. Never commit `.env` files to version control. Use a secrets manager (AWS Secrets Manager, Vault, Doppler) for production deployments.
***
## Performance
Fast apps get more installs and fewer support tickets.
### Cache JWKS Responses
JTL's public keys change infrequently. Fetching them on every session token verification adds latency. Cache the JWKS response and refresh it only when verification fails with a key mismatch.
```typescript theme={null}
let jwksCache: JsonWebKeySet | null = null;
let jwksCacheExpiry = 0;
const JWKS_TTL = 3600_000; // 1 hour
async function getJwks(): Promise {
if (jwksCache && Date.now() < jwksCacheExpiry) {
return jwksCache;
}
const response = await fetch(
`${API_BASE_URL}/account/.well-known/jwks.json`,
{
headers: {
Authorization: `Bearer ${await getCachedAccessToken()}`,
},
},
);
jwksCache = await response.json();
jwksCacheExpiry = Date.now() + JWKS_TTL;
return jwksCache;
}
```
**What this does:** Caches the JWKS for one hour and reuses it across all session token verifications. If a token fails verification, you can clear the cache and retry with fresh keys before returning an error.
### Minimize Frontend Bundle Size
Use dynamic imports for the AppBridge SDK and any heavy dependencies. This reduces your initial page load, which matters because your app loads inside an iframe that already has the full ERP UI rendered around it.
```typescript theme={null}
// Dynamic import: loaded only when needed
const { createAppBridge } = await import('@jtl-software/cloud-apps-core');
```
***
## Deployment Checklist
Before submitting your app to the App Store, verify each item on this list.
Replace all `localhost` URLs in your manifest with production HTTPS
URLs. This includes `configurationUrl`, `redirectUrl`, menu item URLs,
and panel URLs.
Confirm your `CLIENT_ID` and `CLIENT_SECRET` are set in your production
environment. Test the token exchange from your deployed server.
Walk through the complete flow before deploying: install from JTL
Cloud, complete setup, verify data loads, test all features, then
uninstall and confirm cleanup.
Confirm your app handles token expiry, network failures, and empty data
states without crashing or showing blank screens.
Make sure your manifest's `icon.light` and `icon.dark` point to publicly
accessible HTTPS URLs, not local paths.
Uninstall your app and reinstall it. Verify that the setup flow works
correctly a second time and any previously saved data is handled
gracefully.
***
## What's Next
Deploy your app and publish it for merchants.
Review the full architecture of JTL Cloud Apps.
In-depth error format reference and retry strategies.
# Handling Webhooks & Events
Source: https://developer.jtl-software.com/guides/cloud-apps/handling-webhooks
Implement AppBridge event handlers and lifecycle webhook endpoints in your JTL Cloud App.
Cloud Apps interact with the JTL platform through two channels:
| Channel | Transport | Direction | Use case |
| ------------------------------------ | -------------------- | -------------------------- | ----------------------------------------------- |
| **AppBridge events** (*coming soon*) | iframe `postMessage` | Bidirectional (app ↔ host) | Real-time UI interactions while the app is open |
| **Setup handshake** | iframe + AppBridge | Host → your app's iframe | Onboarding when a merchant installs your app |
AppBridge events are session-scoped: they only fire while a merchant has your app open in the [ERP Cloud](https://erp.jtl-cloud.com). The setup handshake runs once, the first time a merchant configures your app.
For a conceptual overview of all three JTL event systems (including SCX polling events for marketplace channels), see the [Webhooks & Events](/guides/essentials/common-patterns/webhooks) page.
## AppBridge Events
**In development:** AppBridge publish/subscribe events are in development and not yet available. This section will be updated when the API ships.
AppBridge events will let your app and the host environment exchange messages in real time while the merchant has your app open. Communication is asynchronous and non-blocking, with no HTTP requests or polling involved.
The system is designed around two capabilities:
* **Publishing events** notifies the host that your app completed an action (for example, a generated product description is ready to insert).
* **Subscribing to events** lets your app react when the host's context changes (for example, the merchant navigates to a different customer record).
Topics will follow a `resource:action` naming convention so intent is clear from the name. Event payloads are expected to be small (IDs and changed values, not full objects) since the host or your app can always fetch details from the API if needed.
For the conceptual overview of how AppBridge events fit alongside lifecycle hooks and SCX polling, see [Webhooks & Events](/guides/essentials/common-patterns/webhooks).
## Setup Handshake
The setup handshake runs when a merchant installs your app. Your manifest points at the iframe URL where setup happens:
```json theme={null}
{
"lifecycle": {
"configurationUrl": "https://your-app.example.com/setup"
}
}
```
| Field | Role |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `configurationUrl` | The URL JTL loads in an iframe when the merchant clicks **Install** in the JTL Hub. Your app shows its onboarding UI here and completes the AppBridge handshake. |
Inside the iframe, the typical flow is:
1. The AppBridge initializes and provides a session token.
2. Your frontend sends the token to your backend for verification.
3. Your backend verifies the token and stores the tenant connection.
4. Your frontend calls `appBridge.method.call('setupCompleted')` to signal that setup is done.
For the full implementation, including the React provider, the verification code, and the `connect-tenant` route in three languages, see [App Shell & UI Integration](/guides/cloud-apps/app-shell-ui-integration) and the [From Scratch quickstart](/get-started/quick-start/from-scratch/frontend).
## How They Fit Together
```mermaid theme={null}
flowchart LR
Install["Merchant installs app"] --> Setup["configurationUrl
(AppBridge handshake)"]
Setup --> Active["App is active"]
Active --> Events["AppBridge events
(coming soon)"]
Events --> Active
style Install fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
style Setup fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style Active fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style Events fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45,stroke-dasharray: 5 5
```
The setup handshake runs once, when the merchant first installs your app. AppBridge events will cover real-time interactions during active sessions once the publish/subscribe API ships.
***
## What's Next
Full AppBridge API reference and the setup handshake implementation.
Conceptual overview of all three JTL event systems including SCX polling.
Verify session tokens during setup and on subsequent backend requests.
Production patterns for error handling, security, and performance.
# Using Platform APIs
Source: https://developer.jtl-software.com/guides/cloud-apps/using-platform-apis
Call the JTL Cloud and JTL-Wawi APIs from your backend using REST for authentication and GraphQL for ERP data.
The JTL platform exposes two API surfaces, each serving a different purpose:
| API | Purpose | Format |
| --------------- | ---------------------------------------------------------------------------- | ------------------------------ |
| **REST API** | Authentication, token management, and account operations | Standard REST (JSON over HTTP) |
| **GraphQL API** | Querying and mutating ERP data (items, categories, customers, orders, stock) | GraphQL (single endpoint) |
In practice, your backend uses the REST API to obtain access tokens, then uses those tokens to query and mutate ERP data through GraphQL.
For the conceptual foundations (pagination, error handling, versioning), see the [Essentials](/guides/essentials/common-patterns/error-handling) section.
## Required Headers
Every API request to the JTL Cloud Platform requires a specific set of headers. Missing or incorrect headers result in `401` or `400` errors.
| Header | Value | Required | Description |
| --------------- | ----------------------- | ------------------------ | ------------------------------------------------------------------------------------- |
| `Authorization` | `Bearer ` | Yes | JWT access token from the client credentials flow |
| `X-Tenant-ID` | `` | Yes | Identifies which merchant's data to access. Get this from the verified session token. |
| `Content-Type` | `application/json` | Yes (for POST/mutations) | Request body format |
The `X-Tenant-ID` is what scopes your request to a specific merchant. The tenant ID determines whose data you're reading or writing.
C# samples target .NET 8 with implicit usings enabled and use raw string literals (C# 11+). PHP samples target PHP 8.1+ and require the `guzzlehttp/guzzle` Composer dependency. TypeScript samples assume a modern Node.js or browser environment with `fetch` available globally. These examples use raw HTTP requests. If your project already uses HTTP or GraphQL client libraries, the same headers and payload structure apply.
## REST API
The REST API handles authentication and account-level operations. You already use it to obtain access tokens (see [Authentication & Login](/guides/cloud-apps/authentication-login)). It also provides endpoints for account management, JWKS key retrieval, and other platform services.
### Base URL
REST endpoints use URL-path versioning:
```
https://api.jtl-cloud.com/erp/v2/{endpoint}
```
Always target `/erp/v2/` for new integrations. See [Versioning](/guides/essentials/common-patterns/versioning) for the full version history.
### Example: Token Request
This is the most common REST call your app makes. See [Authentication & Login](/guides/cloud-apps/authentication-login#client-credentials-getting-an-access-token) for the full implementation with caching.
```bash theme={null}
curl -X POST https://auth.jtl-cloud.com/oauth2/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Authorization: Basic $(echo -n 'CLIENT_ID:CLIENT_SECRET' | base64)" \
-d "grant_type=client_credentials"
```
### Example: JWKS Retrieval
Fetch the public keys used to verify session tokens:
```bash theme={null}
curl -X GET https://api.jtl-cloud.com/account/.well-known/jwks.json \
-H "Authorization: Bearer "
```
**What this does:** Returns the JSON Web Key Set (JWKS) containing the public keys your backend uses to verify session tokens from the AppBridge. Cache this response and refresh it when key verification fails.
***
## GraphQL API
All ERP data operations (reading items, creating categories, updating customers, querying orders) go through the GraphQL API. It provides a single endpoint for both queries (reads) and mutations (writes).
### Endpoint
```
POST https://api.jtl-cloud.com/erp/v2/graphql
```
All GraphQL requests are `POST` requests to this single URL, regardless of whether you're reading or writing data.
### Making a Request
Every GraphQL request has the same structure: an `operationName`, a `query` string, and optional `variables`. The shape is identical across languages, only the syntax for sending the HTTP request differs.
```typescript TypeScript theme={null}
const response = await fetch("https://api.jtl-cloud.com/erp/v2/graphql", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${accessToken}`,
"X-Tenant-ID": tenantId,
},
body: JSON.stringify({
operationName: "MyOperation",
query: `query MyOperation { ... }`,
variables: { /* ... */ },
}),
});
const { data, errors } = await response.json();
```
```csharp C# theme={null}
// GraphQLRequest.cs
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
var payload = new
{
operationName = "MyOperation",
query = "query MyOperation { ... }",
variables = new { /* ... */ },
};
var request = new HttpRequestMessage(
HttpMethod.Post,
"https://api.jtl-cloud.com/erp/v2/graphql"
);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
request.Headers.Add("X-Tenant-ID", tenantId);
request.Content = new StringContent(
JsonSerializer.Serialize(payload),
Encoding.UTF8,
"application/json"
);
var response = await HttpClient.SendAsync(request);
var json = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize(json);
```
```php PHP theme={null}
httpClient (Guzzle)
$response = $this->httpClient->post('https://api.jtl-cloud.com/erp/v2/graphql', [
'headers' => [
'Content-Type' => 'application/json',
'Authorization' => "Bearer {$accessToken}",
'X-Tenant-ID' => $tenantId,
],
'json' => [
'operationName' => 'MyOperation',
'query' => 'query MyOperation { ... }',
'variables' => (object) [/* ... */],
],
]);
$result = json_decode((string) $response->getBody(), true, flags: JSON_THROW_ON_ERROR);
```
```bash cURL theme={null}
curl -X POST https://api.jtl-cloud.com/erp/v2/graphql \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $ACCESS_TOKEN" \
-H "X-Tenant-ID: $TENANT_ID" \
-d '{
"operationName": "MyOperation",
"query": "query MyOperation { ... }",
"variables": {}
}'
```
**What this does:** Sends a GraphQL operation to the ERP API with your access token and tenant ID. The response contains a `data` object with the results, or an `errors` array if something went wrong.
Throughout this guide, GraphQL query and mutation strings are shown in plain GraphQL syntax. The string itself is the same across languages; only how you embed it (a template literal in TypeScript, a verbatim string in C#, a heredoc in PHP) differs. The variables object follows the JSON serialization conventions of your language.
## Querying Data
Queries read data from the ERP without modifying it. Use them to fetch items, customers, orders, categories, and other resources.
The examples in this section use the `query()` / `QueryAsync()` / `JtlGraphQL::query()` helper built in [Building a Reusable API Client](#building-a-reusable-api-client).
The GraphQL operation itself is language-agnostic. Only the variables object differs depending on your language's JSON syntax and conventions.
### Basic Query
Fetch a list of products with their SKU and name:
```graphql theme={null}
query GetERPItems($first: Int, $order: [ItemListItemSortInput!]) {
QueryItems(first: $first, order: $order) {
nodes {
id
sku
name
}
totalCount
}
}
```
Call it with variables for page size and sort order:
```typescript theme={null}
const items = await query(tenantId, "GetERPItems", ITEMS_QUERY, {
first: 10,
order: [{ name: "ASC" }],
});
```
**What this does:** Fetches the first 10 items sorted alphabetically by name. The response includes a `nodes` array with each item's `id`, `sku`, and `name`, plus a `totalCount` of all matching items.
```json theme={null}
{
"data": {
"QueryItems": {
"nodes": [
{
"id": "895d2d4d-4ed4-44c7-ac61-ebec01000000",
"sku": "AR2016041-VKO",
"name": "Men's T-shirt"
},
{
"id": "895d2d4d-4ed4-44c7-ac61-ebec06000000",
"sku": "AR2016041-002",
"name": "Men's T-shirt orange S"
}
],
"totalCount": 674
}
}
}
```
### Requesting Specific Fields
One of GraphQL's key advantages is that you only fetch the fields you need. This reduces payload size and improves performance.
A minimal query with just IDs and names:
```graphql theme={null}
query GetItemsMinimal {
QueryItems(first: 50) {
nodes {
id
name
}
totalCount
}
}
```
A detailed query with pricing and stock data:
```graphql theme={null}
query GetItemsDetailed {
QueryItems(first: 50) {
nodes {
id
sku
name
gtin
salesPriceNet
averagePurchasePriceNet
stockTotal
stockInOrders
manufacturerName
productGroupName
taxClassName
}
totalCount
}
}
```
The same `query()` helper handles both, only the operation string changes.
### Sorting
Control the order of results using the `order` variable. Pass an array of sort objects with the field name as the key and `ASC` or `DESC` as the value.
```typescript theme={null}
// Alphabetical by name
const variables = { first: 20, order: [{ name: "ASC" }] };
// Reverse alphabetical by SKU
const variables = { first: 20, order: [{ sku: "DESC" }] };
```
In C#, build the variables with `new { first = 20, order = new[] { new { name = "ASC" } } }`. In PHP, use `['first' => 20, 'order' => [['name' => 'ASC']]]`.
### Filtering
Use the `where` variable to filter results based on field conditions. Filters use a structured input type specific to each query.
```typescript theme={null}
const variables = {
first: 20,
where: {
name: { contains: "T-shirt" },
},
};
```
Filter operators vary by field type, such as `contains` and `eq` for strings, `gte` and `lte` for numbers, `in` for enum-like fields. See the [GraphQL Playground](/api-reference/graphql-playground) for the full schema of available operators on each query.
### Pagination
The GraphQL API uses cursor-based pagination. Use `first` to set the page size and `after` to fetch subsequent pages.
Add `pageInfo` to your query to get pagination metadata:
```graphql theme={null}
query GetERPItems($first: Int, $after: String) {
QueryItems(first: $first, after: $after) {
nodes {
id
sku
name
}
pageInfo {
hasNextPage
endCursor
}
totalCount
}
}
```
Then loop by passing the previous response's `endCursor` as `after` until `hasNextPage` is `false`:
```typescript theme={null}
let cursor: string | null = null;
while (true) {
const page = await query(tenantId, "GetERPItems", ITEMS_QUERY, {
first: 20,
after: cursor,
});
// Process page.QueryItems.nodes here
if (!page.QueryItems.pageInfo.hasNextPage) break;
cursor = page.QueryItems.pageInfo.endCursor;
}
```
| Field | Description |
| ------------- | --------------------------------------------------------- |
| `hasNextPage` | `true` if more results exist beyond this page |
| `endCursor` | Opaque cursor string to pass as `after` for the next page |
| `totalCount` | Total number of matching items across all pages |
For the full pagination pattern including REST-style page-based pagination, see [Pagination](/guides/essentials/common-patterns/pagination).
## Mutating Data
Mutations create, update, or delete ERP data. They follow the same request structure as queries but use the `mutation` keyword. Use the same `query()` helper as it handles both.
### Creating a Resource
Create a new category in the ERP:
```graphql theme={null}
mutation CreateCategory($request: CreateCategoryCommandRequestInput) {
CreateCategory(request: $request) {
categoryId
}
}
```
Call it with the category details:
```typescript theme={null}
const result = await query(tenantId, "CreateCategory", CREATE_CATEGORY_MUTATION, {
request: {
name: "Summer Collection",
sortNumber: 1,
parentId: null,
},
});
const categoryId = result.CreateCategory.categoryId;
```
**What this does:** Creates a new top-level category named "Summer Collection". The response returns the `categoryId` of the newly created resource. Set `parentId` to an existing category ID to create a subcategory.
### Updating a Resource
Update an existing category:
```graphql theme={null}
mutation UpdateCategory($request: UpdateCategoryCommandRequestInput) {
UpdateCategory(request: $request)
}
```
Call it with the resource ID and the fields you want to change:
```typescript theme={null}
await query(tenantId, "UpdateCategory", UPDATE_CATEGORY_MUTATION, {
request: {
id: "cat-abc-123",
name: "Winter Collection",
sortNumber: 2,
},
});
```
**What this does:** Updates the category's name and sort order. The `id` field is required to identify which resource to update. Only the fields you include in the request are modified; omitted fields remain unchanged. The mutation returns `true` on success.
## Handling Responses
Every GraphQL response has the same top-level structure:
```json theme={null}
{
"data": { ... },
"errors": [ ... ]
}
```
### Success
A successful response contains the `data` object with your requested fields. The `errors` field is either absent or an empty array.
### Errors
GraphQL errors are returned in the `errors` array, even when the HTTP status is `200`. Always check for errors in the response body, not just the status code.
```typescript TypeScript theme={null}
const { data, errors } = await response.json();
if (errors?.length) {
// Handle errors (log, retry, or surface to the user)
throw new Error(`GraphQL error: ${errors.map(e => e.message).join(", ")}`);
}
if (data) {
// Process successful response
}
```
```csharp C# theme={null}
var json = await response.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize(json);
if (result.TryGetProperty("errors", out var errorsElement) &&
errorsElement.ValueKind == JsonValueKind.Array &&
errorsElement.GetArrayLength() > 0)
{
var messages = errorsElement.EnumerateArray()
.Select(e => e.GetProperty("message").GetString())
.ToArray();
throw new InvalidOperationException(
$"GraphQL error: {string.Join(", ", messages)}"
);
}
if (result.TryGetProperty("data", out var data))
{
// Process successful response
}
```
```php PHP theme={null}
$result = json_decode((string) $response->getBody(), true, flags: JSON_THROW_ON_ERROR);
if (!empty($result['errors'])) {
$messages = array_map(fn($e) => $e['message'], $result['errors']);
throw new \RuntimeException('GraphQL error: ' . implode(', ', $messages));
}
if (isset($result['data'])) {
// Process successful response
}
```
**What this does:** Checks for errors in the GraphQL response before processing data. Unlike REST APIs where errors are indicated by HTTP status codes, GraphQL can return partial data alongside errors. Always inspect both fields.
For a complete reference on error formats and retry strategies, see [Error Handling](/guides/essentials/common-patterns/error-handling).
## Building a Reusable API Client
As your app grows, you'll want a helper that handles headers, authentication, and error checking in one place.
```typescript TypeScript theme={null}
// lib/jtl-graphql.ts
import { getCachedAccessToken } from './token-cache';
const GRAPHQL_ENDPOINT = 'https://api.jtl-cloud.com/erp/v2/graphql';
interface GraphQLResponse {
data: T | null;
errors?: Array<{ message: string }>;
}
export async function query(
tenantId: string,
operationName: string,
queryString: string,
variables?: Record,
): Promise {
const accessToken = await getCachedAccessToken();
const response = await fetch(GRAPHQL_ENDPOINT, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${accessToken}`,
'X-Tenant-ID': tenantId,
},
body: JSON.stringify({ operationName, query: queryString, variables }),
});
if (!response.ok) {
throw new Error(`API request failed (${response.status})`);
}
const result: GraphQLResponse = await response.json();
if (result.errors?.length) {
throw new Error(
`GraphQL error: ${result.errors.map(e => e.message).join(', ')}`,
);
}
if (!result.data) {
throw new Error('No data returned from GraphQL API');
}
return result.data;
}
```
```csharp C# theme={null}
// JtlGraphQL.cs
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
public static class JtlGraphQL
{
private const string Endpoint = "https://api.jtl-cloud.com/erp/v2/graphql";
private static readonly HttpClient HttpClient = new();
public static async Task QueryAsync(
string tenantId,
string operationName,
string queryString,
object? variables = null
)
{
var accessToken = await TokenCache.GetCachedAccessTokenAsync();
var payload = new
{
operationName,
query = queryString,
variables = variables ?? new { },
};
var request = new HttpRequestMessage(HttpMethod.Post, Endpoint);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
request.Headers.Add("X-Tenant-ID", tenantId);
request.Content = new StringContent(
JsonSerializer.Serialize(payload),
Encoding.UTF8,
"application/json"
);
var response = await HttpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
throw new HttpRequestException($"API request failed ({(int)response.StatusCode})");
var json = await response.Content.ReadAsStringAsync();
using var doc = JsonDocument.Parse(json);
var root = doc.RootElement;
if (root.TryGetProperty("errors", out var errors) &&
errors.ValueKind == JsonValueKind.Array &&
errors.GetArrayLength() > 0)
{
var messages = errors.EnumerateArray()
.Select(e => e.GetProperty("message").GetString())
.ToArray();
throw new InvalidOperationException(
$"GraphQL error: {string.Join(", ", messages)}"
);
}
if (!root.TryGetProperty("data", out var data) || data.ValueKind == JsonValueKind.Null)
throw new InvalidOperationException("No data returned from GraphQL API");
return JsonSerializer.Deserialize(data.GetRawText())
?? throw new InvalidOperationException("Failed to deserialize GraphQL data");
}
}
```
```php PHP theme={null}
post(self::ENDPOINT, [
'headers' => [
'Content-Type' => 'application/json',
'Authorization' => "Bearer {$accessToken}",
'X-Tenant-ID' => $tenantId,
],
'json' => [
'operationName' => $operationName,
'query' => $queryString,
'variables' => $variables ?? (object) [],
],
'http_errors' => false,
]);
if ($response->getStatusCode() >= 400) {
throw new RuntimeException("API request failed ({$response->getStatusCode()})");
}
$result = json_decode((string) $response->getBody(), true, flags: JSON_THROW_ON_ERROR);
if (!empty($result['errors'])) {
$messages = array_map(fn($e) => $e['message'], $result['errors']);
throw new RuntimeException('GraphQL error: ' . implode(', ', $messages));
}
if (!isset($result['data'])) {
throw new RuntimeException('No data returned from GraphQL API');
}
return $result['data'];
}
private static function httpClient(): Client
{
return self::$httpClient ??= new Client();
}
}
```
**What this does:** Wraps the common GraphQL request pattern into a reusable function. It handles access token caching, sets all required headers, checks for both HTTP-level and GraphQL-level errors, and returns parsed data. Use it throughout your app instead of repeating the request boilerplate.
### Using the Client
```typescript TypeScript theme={null}
// Querying items
interface ItemsResponse {
QueryItems: {
nodes: Array<{ id: string; sku: string; name: string }>;
totalCount: number;
};
}
const items = await query(
tenantId,
'GetERPItems',
`query GetERPItems($first: Int) {
QueryItems(first: $first) {
nodes { id sku name }
totalCount
}
}`,
{ first: 10 },
);
// items.QueryItems.nodes is fully typed
// Creating a category
interface CreateCategoryResponse {
CreateCategory: { categoryId: string };
}
const result = await query(
tenantId,
'CreateCategory',
`mutation CreateCategory($request: CreateCategoryCommandRequestInput) {
CreateCategory(request: $request) { categoryId }
}`,
{ request: { name: 'Summer Collection', sortNumber: 1 } },
);
const categoryId = result.CreateCategory.categoryId;
```
```csharp C# theme={null}
// Querying items
public record Item(string Id, string Sku, string Name);
public record ItemsPage(Item[] Nodes, int TotalCount);
public record ItemsResponse(ItemsPage QueryItems);
var items = await JtlGraphQL.QueryAsync(
tenantId,
"GetERPItems",
"""
query GetERPItems($first: Int) {
QueryItems(first: $first) {
nodes { id sku name }
totalCount
}
}
""",
new { first = 10 }
);
// items.QueryItems.Nodes is fully typed
// Creating a category
public record CreateCategoryResult(string CategoryId);
public record CreateCategoryResponse(CreateCategoryResult CreateCategory);
var result = await JtlGraphQL.QueryAsync(
tenantId,
"CreateCategory",
"""
mutation CreateCategory($request: CreateCategoryCommandRequestInput) {
CreateCategory(request: $request) { categoryId }
}
""",
new { request = new { name = "Summer Collection", sortNumber = 1 } }
);
var categoryId = result.CreateCategory.CategoryId;
```
```php PHP theme={null}
10]
);
$nodes = $items['QueryItems']['nodes'];
// Creating a category
$result = JtlGraphQL::query(
$tenantId,
'CreateCategory',
<<<'GRAPHQL'
mutation CreateCategory($request: CreateCategoryCommandRequestInput) {
CreateCategory(request: $request) { categoryId }
}
GRAPHQL,
['request' => ['name' => 'Summer Collection', 'sortNumber' => 1]]
);
$categoryId = $result['CreateCategory']['categoryId'];
```
***
## What's Next
Try queries and mutations interactively with autocomplete and schema
docs.
Respond to lifecycle events and AppBridge messages in your app.
Understand error formats, retry strategies, and validation errors.
Stay within request limits and handle throttling gracefully.
Production patterns for API usage, caching, and performance.
# Available APIs
Source: https://developer.jtl-software.com/guides/erp-integration/available-apis
The three APIs available for integrating with JTL, and how to choose between them.
The JTL Platform exposes three APIs for integrating with merchant data. They cover overlapping ground in different ways; the right choice depends on what you're building and where your integration runs.
## The Three APIs
Each API targets a different use case. Most integrations use one of the first two; SCX is specific to marketplace integrations.
| API | What it's for | Protocol |
| -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
| [REST API](/api-reference/v2.0/accountingdata/query-accounting-data) | Transactional operations on merchant data (orders, items, customers, stock) | REST over HTTP |
| [GraphQL API](/api-reference/graphql-playground) | Flexible queries over the same ERP domain, fetching exactly the fields you need | GraphQL |
| [SCX API](/api-reference/scx/channel) | OnPremise marketplace channel integrations (e.g., Amazon, eBay). See [Marketplace Channels](/guides/marketplace-channels/channel-api-overview) for channel-specific integration detail. | REST over HTTP |
## Common Conventions
Both ERP APIs target version `2.0` of the API and include authentication headers described in [Integration Overview](/guides/erp-integration/integration-overview#required-http-headers). They differ in pagination shape:
* **REST** uses page-based pagination with `pageNumber` and `pageSize` query parameters, returning a wrapped envelope with `items[]` and page metadata
* **GraphQL** uses cursor-based pagination with `first` and `after` variables, returning `nodes[]` and a `pageInfo` object
See [Pagination](/guides/essentials/common-patterns/pagination) for more details.
## What's Next?
Try queries and mutations interactively against your ERP instance.
Browse all REST API endpoints with request/response schemas.
Base URLs, authentication, and required headers.
The full page-based pagination contract.
# Integration Overview
Source: https://developer.jtl-software.com/guides/erp-integration/integration-overview
Overview of ERP integration options with the JTL Platform, including authentication and available endpoints
The JTL ERP API lets you read and modify JTL-Wawi data: orders, products, customers, stock, and more.
Every merchant runs the same Wawi API on their own Wawi instance. What differs is how your integration reaches it.
| Option | Base URL | Where your integration runs |
| ------------- | ------------------------------------------ | --------------------------------------------------------- |
| **OnPremise** | `http://127.0.0.1:64110/api/eazybusiness/` | On the merchant's machine or their local network |
| **Cloud** | `https://api.jtl-cloud.com/erp/` | Anywhere. The request is forwarded to the merchant's Wawi |
The Cloud option is available when a merchant has connected their [Wawi to JTL Cloud](/get-started/create-developer-account#step-2-connect-to-jtl-wawi). The public endpoint forwards requests to their Wawi, letting your integration run off the merchant's premises without access to their network.
Both variants expose the same API surface through REST and GraphQL. They differ in:
* where your integration can be deployed
* how authentication works
* a small set of variant-specific [capabilities](/guides/cloud-apps/app-shell-ui-integration#capabilities)
## Authentication
The authentication flow depends on the variant. Cloud uses OAuth 2.0 client credentials; OnPremise uses a two-step registration flow.
Register your app in the [JTL Partner Portal](https://partner.jtl-cloud.com) to receive a `clientId` and `clientSecret`.
Send a POST request to `https://auth.jtl-cloud.com/oauth2/token` with Basic auth (base64 `clientId:clientSecret`) and body `grant_type=client_credentials`. The response returns a JWT access token valid for 24 hours.
Include the JWT as `Authorization: Bearer ` on every request, along with the merchant's `X-Tenant-ID`.
Open JTL-Wawi (new interface) and go to **Admin > App registration**, and follow the steps to register your app. This authorizes your first API call; without it, registration requests are rejected.
Send a POST request to `/authentication` with your app metadata (`AppId`, `DisplayName`, `Description`, `Version`, `ProviderName`, `ProviderWebsite`, `MandatoryApiScopes`, `OptionalApiScopes`) and an `x-challengecode` header. The API returns a `RegistrationRequestId`.
The merchant approves the registration request in the Wawi admin panel.
GET `/authentication/{registrationId}` with the same `x-challengecode` header. The response contains your `ApiKey` and `GrantedScopes`.
The API key is displayed only once and cannot be retrieved again. Store it securely immediately on receipt.
See the [OAuth 2.0 flow](/guides/essentials/authentication/oauth2-flow) for more details.
## Required HTTP Headers
Every API request must include the headers below:
| Header | Description |
| --------------- | --------------------------------------------------------- |
| `Authorization` | `Bearer ` obtained from the OAuth 2.0 token endpoint |
| `X-Tenant-ID` | The merchant's tenant ID |
| Header | Description |
| ----------------- | ----------------------------------------------------------- |
| `Authorization` | `Wawi ` |
| `x-appid` | Your application identifier, e.g. `MyApp/1.0.0` |
| `x-appversion` | Your application version, e.g. `1.0.0` |
| `api-version` | Target API version, e.g. `2.0` |
| `x-challengecode` | Custom value used during registration, max 30 characters. |
| `x-runas` | Wawi user ID to perform the call on their behalf. Optional. |
See the [versioning](/guides/essentials/common-patterns/versioning) guide for more details on API versioning.
## What's Next?
A guided tour of the REST API domains and what each one does.
Auth flows across Cloud Apps, OnPremise, and SCX.
Browse all REST API endpoints with request/response schemas.
# API Keys & Tokens
Source: https://developer.jtl-software.com/guides/essentials/authentication/api-keys-tokens
Manage API keys, session tokens, and JWTs for the JTL Platform
The JTL platform uses different credentials and tokens depending on the integration type and API. This page explains what each one is, when to use it, and how to manage it.
To obtain these tokens, see the [OAuth 2.0 Flow](/guides/essentials/authentication/oauth2-flow) page.
## Credentials and Tokens at a Glance
| Credential / Token | What it is | Where you get it | Lifetime |
| ----------------------- | ----------------------------------------------------------- | ------------------------------------------- | -------------------------- |
| **Client ID** | Your app's public identifier | Partner Portal (after registration) | Permanent (can regenerate) |
| **Client Secret** | Your app's private key for authentication | Partner Portal (shown once at registration) | Permanent (can regenerate) |
| **Access Token (JWT)** | Short-lived token for authenticating API requests | Token endpoint (client credentials grant) | \~24 hours |
| **Session Token** | Short-lived token identifying the current merchant and user | App Shell (via AppBridge) | Short-lived |
| **API Key (OnPremise)** | Permanent key for local ERP API access | JTL-Wawi desktop registration flow | Permanent |
| **SCX Auth Token** | Short-lived token for SCX Channel API requests | SCX auth endpoint | \~1 hour |
## Client Credentials
Client credentials identify your app on the JTL platform. Every registered app receives a pair: a **Client ID** (public) and a **Client Secret** (private). Together, they're used to request access tokens from JTL's identity provider.
### Client ID
Your app's public identifier. It's safe to include in logs and non-sensitive contexts. The Partner Portal displays it on your app's detail page, and you can view it at any time.
### Client Secret
Your app's private key, used alongside the Client ID to generate access token for your app. The Partner Portal displays it **only once**, immediately after registration.
**The Client Secret is shown only once.** Copy and store it securely at the
moment of registration. If you lose it, you'll need to regenerate it.
### Regenerating a Lost Secret
The [Partner Portal](https://partner.jtl-software.com/) does not currently support in-place secret rotation. To regenerate, register a new app with the same manifest:
1. Log in to the Partner Portal
2. Click the **+ Create** button. You'll see a manifest editor with prefilled example
3. Replace the example manifest with the contents of your `manifest.json` file
4. Click the **Register App** and copy the new Client Secret
5. Update the secret in your app's environment variables and redeploy.
### Storage Best Practices
| Do | Don't |
| -------------------------------------------------------------------------------- | ----------------------------------------------- |
| Store in environment variables (`.env`, `.env.local`) | Hardcode in source code |
| Use a secrets manager in production (AWS Secrets Manager, HashiCorp Vault, etc.) | Commit `.env` files to version control |
| Restrict access to credentials to team members who need them | Share credentials in chat, email, or tickets |
| Rotate the secret if you suspect it's been compromised | Reuse the same credentials across multiple apps |
## Access Token (JWT)
The access token is what your backend uses to authenticate API requests to JTL. You obtain it by sending your client credentials to JTL's token endpoint via the [client credentials grant](/guides/essentials/authentication/oauth2-flow).
### Token Response
When you request an access token, JTL returns:
```json theme={null}
{
"access_token": "eyJhbGciOiJSUzI1NiIsImt.......",
"expires_in": 86399,
"scope": "",
"token_type": "bearer"
}
```
| Field | Type | Description |
| -------------- | ------ | ----------------------------------------------------------- |
| `access_token` | string | The JWT to include in API request headers |
| `expires_in` | number | Seconds until the token expires (86399 ≈ 24 hours) |
| `scope` | string | The granted scopes |
| `token_type` | string | Always `bearer`: include as `Authorization: Bearer ` |
### Using the Access Token
Include it in the `Authorization` header of every API request:
```
Authorization: Bearer eyJhbGciOiJSUzI1NiIsImt.......
```
### Token Lifecycle
Access tokens expire in approximately **24 hours** (`expires_in: 86399`). Handle this as follows:
* **Cache the token**: Don't request a new one for every API call
* **Track expiry**: Store the `expires_in` value and request a new token before it expires (for example, when less than 5 minutes remain)
* **Handle 401 responses**: A `401 Unauthorized` response typically means the token has expired. Request a new one and retry the request once.
```mermaid theme={null}
flowchart TD
A["Request access token (client credentials)"] --> B["Cache token + track expiry"]
B --> C["Make API requests with Bearer token"]
C --> D{Response?}
D -->|"200 OK"| C
D -->|"401 Unauthorized"| A
B --> E{"Token near expiry? (< 5 min remaining)"}
E -->|Yes| A
E -->|No| C
style A fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style B fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style C fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style D fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
style E fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
```
## Session Token
Session tokens are issued by the **App Shell** and identify which merchant (tenant) and user is currently interacting with your app. They are only relevant for **Cloud Apps** that run inside the App Shell.
Unlike access tokens (requested by your app), session tokens come from the host environment. The App Shell passes them to your app through AppBridge, a lightweight SDK that handles session tokens, method calls, and events.
For implementation details on retrieving and verifying session tokens, see [Cloud Apps: Authentication & Login](/guides/cloud-apps/authentication-login).
### Decoded Structure
A session token is a JWT with three parts: header, payload, and signature.
```json theme={null}
{
"header": {
"alg": "EdDSA",
"typ": "JWT"
},
"payload": {
"exp": 1746616503,
"userId": "",
"tenantId": "",
"tenantSlug": ""
},
"signature": "fwjol6pXYkS7sXQ..."
}
```
### Header
| Field | Value | Description |
| ----- | ------- | ----------------------------------------------------------------- |
| `alg` | `EdDSA` | Edwards-curve Digital Signature Algorithm (the signing algorithm) |
| `typ` | `JWT` | Standard JWT type identifier |
### Payload
| Field | Type | Description |
| ------------ | ------------- | --------------------------------------------------------------------------------------------------- |
| `exp` | number | Expiration timestamp (Unix time). The token is invalid after this time |
| `userId` | string (UUID) | Unique identifier of the authenticated user |
| `tenantId` | string (UUID) | Identifier of the merchant's tenant. Send this as the `X-Tenant-ID` header on every ERP API request |
| `tenantSlug` | string | Human-readable tenant identifier |
### Signature
The signature ensures the token has not been tampered with. Your backend verifies it using JTL's public keys, fetched from the JWKS endpoint.
### Verification
Session tokens must be verified **server-side** using JTL's public keys:
* Your backend requests an access token (client credentials grant)
* Using that access token, it fetches JTL's public keys from the JWKS endpoint (`https://api.jtl-cloud.com/account/.well-known/jwks.json`)
* It uses the public key to verify the session token's signature
* If the signature is valid, the payload (tenantId, userId, etc.) can be trusted
Never trust a session token without verifying it server-side. A token
received from the client (frontend) could be tampered with. Always verify
the signature against the JWKS public key before acting on the payload.
## API Key (OnPremise)
API keys are permanent credentials used only in the OnPremise deployment model. They are generated through a two-step registration process in the JTL-Wawi desktop application.
### Key Characteristics
| Property | Value |
| ----------------- | ------------------------------------------------------ |
| **Format** | UUID (e.g. `00000000-0000-0000-0000-000000000000`) |
| **Lifetime** | Permanent (does not expire unless revoked) |
| **Shown** | Once, at the time of creation |
| **Header format** | `Authorization: Wawi ` |
| **Scope** | Local to the Wawi installation where it was registered |
Like the Client Secret, the API key is displayed **only once** during
registration. Store it securely immediately. If lost, you will need to go
through the registration process again.
For the full OnPremise registration flow, see [OAuth 2.0 Flow (OnPremise
tab)](/guides/essentials/authentication/oauth2-flow).
## Token Comparison
| | Access Token | Session Token | API Key | SCX Auth Token |
| ----------------------- | --------------------------- | -------------------------------- | -------------------- | --------------------------- |
| **Used by** | Cloud apps (backend) | Cloud apps (frontend to backend) | OnPremise apps | Marketplace channels |
| **Format** | JWT (Bearer) | JWT (EdDSA) | UUID | JWT (Bearer) |
| **Lifetime** | \~24 hours | Short-lived | Permanent | \~1 hour |
| **How to get** | Client credentials grant | AppBridge (`getSessionToken`) | Wawi registration | SCX auth endpoint |
| **Refresh mechanism** | Re-request with credentials | Re-request via AppBridge | N/A (permanent) | Re-request with credentials |
| **Verify server-side?** | No (trusted issuer) | Yes (JWKS) | N/A (you created it) | No (trusted issuer) |
## Inspecting Tokens for Debugging
During development, you may need to read a token's contents to confirm what's inside. For the verification flow that backends should use in production, see [Cloud Apps: Authentication & Login](/guides/cloud-apps/authentication-login).
For quick inspection during development, paste your token into
[jwt.io](https://jwt.io/). It decodes the header and payload instantly. **Do
not paste production tokens or any sensitive credentials into third-party
tools.**
## What's Next?
How to obtain access tokens, API keys, and SCX auth tokens.
Implementation guide for session tokens, AppBridge, and the setup
handshake in Cloud Apps.
How to handle auth errors, expired tokens, and 401 responses.
# OAuth 2.0 Flow
Source: https://developer.jtl-software.com/guides/essentials/authentication/oauth2-flow
How authentication works on the JTL platform: Cloud OAuth 2.0, OnPremise API keys, and SCX refresh tokens.
The JTL platform uses different authentication mechanisms across its APIs. This page explains how each one works, when to use it, and how tokens are managed.
## Authentication at a Glance
| API | Auth mechanism | Token type | Lifetime |
| --------------------- | ----------------------------- | ------------------------ | ---------------------------------- |
| **JTL Cloud API** | OAuth 2.0 Client Credentials | Short-lived JWT | \~24 hours (refresh before expiry) |
| **OnPremise ERP API** | Proprietary registration flow | Static API key | Permanent |
| **SCX Channel API** | Refresh token exchange | Short-lived access token | \~1 hour (refresh before expiry) |
## Two Types of Tokens (Cloud)
If you're building on the Cloud platform, you'll use two tokens:
| Token | How you get it | What it's for | Who creates it |
| ---------------------- | ------------------------------------------------ | ------------------------------------------------------------------------- | ----------------------------- |
| **Access token (JWT)** | Client credentials grant > JTL Identity Provider | Authenticating your backend's API calls to JTL | Your app's backend |
| **Session token** | `appBridge.method.call('getSessionToken')` | Identifying which merchant (tenant) and user is interacting with your app | JTL App Shell (via AppBridge) |
**Access token**: identifies your app (machine-to-machine).
**Session token**: identifies the tenant and user (from the App Shell).
In a typical Cloud App, both tokens are in play: the session token tells you *who*, and the access token lets you *act* on their behalf.
Check out the [Cloud Apps: Authentication & Login](/guides/cloud-apps/authentication-login) guide to learn more about Cloud Apps authentication (JWKS, AppBridge integration).
## Cloud Authentication (OAuth 2.0)
The Cloud API uses the **OAuth 2.0 Client Credentials Flow**. Your app's backend authenticates with a client ID and secret, receives a short-lived JWT, and uses that JWT as a Bearer token for all API requests.
### Prerequisites
Your app must be registered in the [Partner Portal](https://partner.jtl-cloud.com/). Registration creates an OAuth client with a `Client ID` and `Client Secret`.
Your `Client Secret` is displayed **only once** immediately after registration. Store it securely.
### How the Flow Works
```mermaid theme={null}
sequenceDiagram
autonumber
participant appBackend as App Backend
participant identityProvider as JTL Identity Provider
participant wawiApi as JTL Cloud API
appBackend->>identityProvider: Request Access Token (client credentials)
activate identityProvider
identityProvider-->>appBackend: Return Access Token (JWT)
deactivate identityProvider
appBackend->>wawiApi: Request resource (Bearer token + Tenant ID)
activate wawiApi
wawiApi-->>appBackend: Return resource data
deactivate wawiApi
```
1. Your backend sends its client credentials to the JTL Identity Provider
2. The Identity Provider returns a short-lived JWT access token
3. Your backend includes that token (along with the tenant ID) in every API request
### Token Endpoint
```
POST https://auth.jtl-cloud.com/oauth2/token
```
**Request:**
| Component | Value |
| ----------------- | --------------------------------------- |
| **Method** | `POST` |
| **Content-Type** | `application/x-www-form-urlencoded` |
| **Authorization** | `Basic ` |
| **Body** | `grant_type=client_credentials` |
**Example request:**
```bash theme={null}
curl -X POST https://auth.jtl-cloud.com/oauth2/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Authorization: Basic $(echo -n "$CLIENT_ID:$CLIENT_SECRET" | base64)" \
-d "grant_type=client_credentials"
```
**Response:**
```json theme={null}
{
"access_token": "eyJhbGciOiJSUzI1NiIs...",
"token_type": "Bearer",
"expires_in": 86399
}
```
| Field | Description |
| -------------- | ------------------------------------------------------------------- |
| `access_token` | The JWT to use in API requests |
| `token_type` | Always `Bearer` |
| `expires_in` | Token lifetime in seconds. Request a new token before this expires. |
For a full implementation including caching, JWKS verification, and tenant mapping, see [Cloud Apps: Authentication & Login](/guides/cloud-apps/authentication-login).
### Making Authenticated API Requests
Once you have an access token, include it in every API request along with the tenant ID.
**Base URL:**
```
https://api.jtl-cloud.com/erp/v2/
```
**Required headers:**
| Header | Value | Description |
| --------------- | -------------- | --------------------------------------------------------------------------- |
| `Authorization` | `Bearer ` | The access token from the client credentials flow |
| `X-Tenant-ID` | `` | The JTL Cloud tenant ID (identifies which merchant's data you're accessing) |
**Example request:**
```bash theme={null}
curl -X GET https://api.jtl-cloud.com/erp/v2/info \
-H "Authorization: Bearer $ACCESS_TOKEN" \
-H "X-Tenant-ID: $TENANT_ID"
```
Check out the [Cloud Apps: Authentication & Login](/guides/cloud-apps/authentication-login) guide to see how to get the tenant ID.
### Token Lifecycle
Access tokens are **short-lived** and expire after a set period. Your app needs to handle this:
* Cache the token and reuse it until it's close to expiry
* Refresh proactively (e.g. when \< 5 minutes remain)
* Handle `401 Unauthorized` by refreshing once and retrying
### Security Schemes
Cloud endpoints are secured using one of two schemes:
| Scheme | When it applies |
| ------------------------------------- | --------------------------------------------------------------------------------------- |
| `Wawi AND oauth2-cloud-id-accessCode` | User-bound access: the request is tied to a specific user's session |
| `Wawi AND oauth2-application` | Machine-to-machine access: your backend calls the API directly using client credentials |
## OnPremise Authentication
The OnPremise API uses a proprietary two-step registration flow that produces a permanent API key (no OAuth).
This applies when your app integrates directly with a merchant's local JTL-Wawi installation.
**Base URL:**
```
http://127.0.0.1:/api/eazybusiness/
```
### How the Flow Works
```mermaid theme={null}
sequenceDiagram
autonumber
participant app as Your App
participant wawi as JTL-Wawi (Desktop)
participant api as JTL-Wawi API (Local)
app->>wawi: 1. Initiate registration (Admin panel)
wawi-->>api: Registration endpoint ready
app->>api: POST /authentication (app info + challenge code)
activate api
api-->>app: Return registration ID
deactivate api
app->>wawi: User confirms registration in JTL-Wawi
wawi-->>api: Registration confirmed
app->>api: GET /authentication/{registrationId}
activate api
api-->>app: Return permanent API key
deactivate api
app->>api: API requests with Authorization: Wawi
api-->>app: API responses
```
### Registration Steps
In the JTL-Wawi desktop application, navigate to `Admin > App Registration` and complete the required steps. The steps must be completed before your app can send its first API request. The registration endpoint is not available until it's done.
Send a `POST` request with your app's information to the authentication endpoint.
**Endpoint:**
```
POST http://127.0.0.1:/api/eazybusiness/authentication
```
**Required headers:**
| Header | Description |
| ----------------- | ------------------------------------------------------------------------------------------------------ |
| `api-version` | Desired API version, e.g. `2.0` |
| `x-challengecode` | A custom value of your choice (max 30 characters). Must be identical across all registration requests. |
**Required body fields:**
| Field | Description |
| ------------------- | ----------------------------------------------------------------------------------------- |
| `AppName` | Name of your application |
| `AppVersion` | Version of your application |
| `RequiredApiScopes` | API scopes your app needs |
| `AppIcon` | Base64-encoded app icon |
| `RegistrationType` | `0` = OneInstance, `1` = MultiInstance, `2` = PerUserInstance, `3` = PerUserLoginInstance |
**Example request:**
```bash cURL theme={null}
curl -X POST "http://127.0.0.1:/api/eazybusiness/authentication" \
-H "Content-Type: application/json" \
-H "api-version: 2.0" \
-H "x-challengecode: my-custom-challenge" \
-d '{
"AppName": "My App",
"AppVersion": "1.0.0",
"RequiredApiScopes": ["", ""],
"AppIcon": "iVBORw0KGgoAAAANSUhEUgAA...",
"RegistrationType": 0
}'
```
`RequiredApiScopes` follows the `resource.read` and `resource.write` pattern (e.g. `orders.read`, `orders.write`, `products.read`, `products.write`, etc.).
The API responds with a **registration ID** (token).
After receiving the registration ID, the user will be prompted to confirm the registration in JTL-Wawi. Once confirmed, your app sends a `GET` request with the registration ID:
**Endpoint:**
```
GET http://127.0.0.1:/api/eazybusiness/authentication/{registrationId}
```
**Required headers:**
| Header | Description |
| ----------------- | ---------------------------------------- |
| `api-version` | Desired API version |
| `x-challengecode` | The same value used in the previous step |
**Example request:**
```bash cURL theme={null}
curl -X GET "http://127.0.0.1:/api/eazybusiness/authentication/{registrationId}" \
-H "api-version: 2.0" \
-H "x-challengecode: my-custom-challenge"
```
On success, the API returns a **permanent API key**.
The API key is returned **only once** and cannot be retrieved again. Store it securely.
Include the API key in the `Authorization` header of every request.
**Required headers:**
| Header | Value | Description |
| ---------------------- | --------------------- | ----------------------------------------------------------------------------- |
| `Authorization` | `Wawi ` | The permanent API key from registration |
| `x-appid` | e.g. `MyApp/1.0.0` | Name of your application |
| `x-appversion` | e.g. `1.0.0` | Version of your application |
| `api-version` | e.g. `2.0` | Desired API version |
| `x-challengecode` | Custom value | The same value used during registration |
| `x-runas` *(optional)* | User ID (int or UUID) | Execute request on behalf of a Wawi user. Requires `Application.RunAs` scope. |
**Example request:**
```bash cURL theme={null}
curl -i -X GET \
'http://127.0.0.1:/api/eazybusiness/info' \
-H 'Authorization: Wawi ' \
-H 'api-version: 2.0' \
-H 'x-appid: MyApp/1.0.0' \
-H 'x-appversion: 1.0.0' \
-H 'x-challengecode: my-custom-challenge'
```
## JTL Cloud vs. OnPremise Comparison
| Feature | Cloud | OnPremise |
| ------------------------- | ------------------------------------------------ | -------------------------------------------- |
| **Auth mechanism** | OAuth 2.0 (Client Credentials) | Proprietary API key flow |
| **Token type** | Short-lived JWT Bearer token | Permanent static API key |
| **Registration** | [Partner Portal](https://partner.jtl-cloud.com/) | JTL-Wawi desktop `Admin >> App Registration` |
| **Credentials** | `ClientId` + `ClientSecret` | Registration ID >> API key |
| **Tenant identification** | `X-Tenant-ID` header required | Not required (local connection) |
| **Base URL** | `https://api.jtl-cloud.com/erp/v2/` | `http://127.0.0.1:/api/eazybusiness/` |
| **Authorization format** | `Bearer ` | `Wawi ` |
| **Token refresh** | Re-request with client credentials before expiry | Not needed (key is permanent) |
***
## SCX Channel API Authentication
The SCX Channel API uses the same **client credentials** mechanism as the Cloud-ERP API. You request an access token, use it for API calls, and request a new one before it expires.
This section applies only to [Marketplace Channel](/guides/marketplace-channels/channel-api-overview) integrations.
**Base URL:**
```
https://scx.api.jtl-software.com/v1/
```
### How the Flow Works
```mermaid theme={null}
sequenceDiagram
autonumber
participant app as Your App
participant scx as SCX Channel API
app->>scx: POST /v1/auth (refreshToken)
activate scx
scx-->>app: Return authToken + expiresIn
deactivate scx
loop Until token expires
app->>scx: API request (Bearer authToken)
scx-->>app: API response
end
Note over app,scx: Token near expiry — request a new one
app->>scx: POST /v1/auth (refreshToken)
activate scx
scx-->>app: Return new authToken
deactivate scx
```
### Requesting an Access Token
**Example request:**
```bash cURL theme={null}
curl -X POST 'https://scx.api.jtl-software.com/v1/auth' \
--form 'refreshToken=YOUR-REFRESH-TOKEN'
```
**Response:**
```json theme={null}
{
"scope": "CHANNEL",
"authToken": "eyJ0eXAi....",
"tokenExpireAt": "2024-05-14T10:07:42+02:00",
"expiresIn": 3600
}
```
| Field | Description |
| --------------- | -------------------------------------------- |
| `scope` | The scope of the token (e.g. `CHANNEL`) |
| `authToken` | The access token for authenticating requests |
| `tokenExpireAt` | Expiration timestamp in ISO 8601 format |
| `expiresIn` | Time in seconds until the token expires |
### Using the Access Token
Include the `authToken` as a Bearer token in all subsequent requests:
```bash cURL theme={null}
curl -X POST 'https://scx.api.jtl-software.com/v1/seller/channel/MYCHANNEL' \
-H 'Authorization: Bearer eyJ0eXAi....'
```
### Token Lifecycle
SCX access tokens have a **TTL** (Time To Live) of 1 hour. Your app should:
* Cache the token and reuse it until it's close to expiry
* Monitor the `expiresIn` value and refresh proactively (e.g. when less than 5 minutes)
* Refresh tokens before they expire to avoid failures during requests.
## Best Practices
These practices apply regardless of which auth mechanism you're using:
**Credential storage**
* Never hardcode credentials in source code. Use environment variables or a secrets manager.
* Never commit `.env` files to version control.
* Rotate credentials if you suspect they've been compromised.
**Token management**
* Cache tokens and reuse them. Don't request a new token for every API call.
* Refresh proactively before expiry, not after receiving a 401 error.
* On a 401 response, refresh the token and retry the request once.
**Security**
* Always use HTTPS for Cloud and SCX API calls.
* Validate session tokens server-side. Never trust tokens received from the client without verification.
* Request the minimum required scopes. Don't request broader access than your app needs.
## What's Next?
Deeper dive into JWT structure, session tokens, and token management
patterns.
Implementation guide for authentication in Cloud Apps: AppBridge,
session tokens, and the setup handshake.
How to handle auth errors, expired tokens, and common failure modes.
# Scopes & Permissions
Source: https://developer.jtl-software.com/guides/essentials/authentication/scopes-permissions
Control what your app can access on the JTL Platform
**Scope enforcement on the Cloud Platform has not shipped yet.** This is a temporary state. Current behavior: the platform validates declared scopes at registration and rejects unknown values. Future behavior (in progress): scopes are shown to the merchant at install time and the API layer rejects calls that exceed the declared set. Until enforcement ships, declared scopes do not restrict what your app can call. Declare what your app actually needs so behavior stays consistent once enforcement ships.
Every JTL integration must declare which platform resources it needs access to. The JTL Platform uses **scopes**: permission strings that describe the read, write, or print access an app is requesting against specific API resources.
How you declare scopes depends on the environment:
| Environment | Where scopes are declared | Format |
| ------------- | ------------------------------------------ | --------------------- |
| **Cloud** | Manifest, in `capabilities.erp.api.scopes` | `resource.permission` |
| **OnPremise** | App registration POST request | `resource.permission` |
In both cases, the principle of least privilege applies, meaning you should request only the scopes your app actually needs.
## Anatomy of a Scope
Every scope follows the pattern `resource.permission`.
| Component | Description | Examples |
| ------------ | ----------------------------- | ------------------------------------------------------------------------ |
| `resource` | The API domain your app needs | `items`, `orders`, `customers`, `inventory` |
| `permission` | The access level | `read` (GET), `write` (POST/PATCH/DELETE), `print` (PDF/print endpoints) |
Permissions do not include each other. `write` does not imply `read`, and `print` does not imply either. If your app needs to read items, modify them, and generate printed documents, declare all three: `items.read`, `items.write`, `items.print`.
## Available Scopes
The table below is generated from the latest cloud OpenAPI spec. Any value outside this list is rejected at registration in both Cloud (manifest validation) and OnPremise (registration POST).
### Sales
| Scope | Description |
| ----------------------- | ---------------------------------------------------------- |
| `cusomters.read` | Read customers (note: typo in upstream scope name) |
| `customers.read` | Read customer records |
| `customers.write` | Create or modify customer records |
| `items.read` | Read product items, variants, and catalog data |
| `items.write` | Create or modify product items, variants, and catalog data |
| `offers.print` | Print offers and quotations |
| `offers.read` | Read offers and quotations |
| `orders.read` | Read orders |
| `returns.read` | Read return records |
| `returns.write` | Create or modify return records |
| `saleschannels.read` | Read sales channels |
| `salesorders.print` | Print sales orders |
| `salesorders.read` | Read sales orders |
| `salesorders.write` | Create or modify sales orders |
| `salesquotations.read` | Read sales quotations |
| `salesquotations.write` | Create or modify sales quotations |
### Inventory and Fulfilment
| Scope | Description |
| --------------------- | ------------------------------------------- |
| `deliveries.read` | Read delivery and shipment data |
| `deliveries.write` | Create or modify delivery and shipment data |
| `deliverynotes.print` | Print delivery notes |
| `deliverynotes.read` | Read delivery notes |
| `deliverynotes.write` | Create or modify delivery notes |
| `inventories.read` | Read inventory and stock data |
| `inventories.write` | Create or modify inventory and stock data |
| `inventory.read` | Read stock levels |
| `inventory.write` | Create or modify stock levels |
| `labels.read` | Read labels |
| `labels.write` | Create or modify labels |
| `picklists.read` | Read picklists |
| `picklists.write` | Create or modify picklists |
| `warehouse.read` | Read warehouse data |
### Finance
| Scope | Description |
| ------------------------------- | ------------------------------------------ |
| `accountings.read` | Read accounting data |
| `currencies.read` | Read currencies |
| `invoices.print` | Print invoices |
| `invoices.read` | Read invoices |
| `invoices.write` | Create or modify invoices |
| `paymentmethods.read` | Read payment methods |
| `salesinvoicecorrections.print` | Print sales-invoice corrections |
| `salesinvoicecorrections.read` | Read sales-invoice corrections |
| `salesinvoicecorrections.write` | Create or modify sales-invoice corrections |
| `salesinvoices.read` | Read sales invoices |
| `salesinvoices.write` | Create or modify sales invoices |
| `taxes.read` | Read taxes |
| `taxes.write` | Create or modify taxes |
### Procurement
| Scope | Description |
| ---------------- | -------------- |
| `suppliers.read` | Read suppliers |
### System
| Scope | Description |
| --------------------------- | ---------------------------------------------- |
| `all.read` | Read all data |
| `application.runas` | Execute requests on behalf of another user |
| `customfields.read` | Read custom fields |
| `customfields.write` | Create or modify custom fields |
| `extensibility.integration` | Register and manage extensibility integrations |
| `jera.read` | Read access to JERA-internal endpoints |
| `system.config.read` | Read system configuration |
| `system.config.write` | Modify system configuration |
| `system.read` | Read system data |
| `system.worker.read` | Read worker synchronisations |
| `system.worker.write` | Modify worker synchronisations |
| `wawiapp.all` | Access Wawi-App-related operations |
### Other
| Scope | Description |
| ----------------- | -------------------------------- |
| `payments.write` | Create or modify payments |
| `pps.read` | Read production data |
| `pps.write` | Create or modify production data |
| `resources.read` | Read resources |
| `resources.write` | Create or modify resources |
## Cloud Scopes
For Cloud, you declare API scopes in your `manifest.json` under `capabilities.erp.api.scopes`. These scopes determine which JTL-Wawi API endpoints your app can call.
### Declaring Scopes in the Manifest
```json theme={null}
{
"capabilities": {
"erp": {
"api": {
"scopes": [
"items.read",
"items.write"
]
}
}
}
}
```
Scopes follow the pattern `resource.permission`:
| Component | Description | Examples |
| ------------ | ----------------------------- | ---------------------------------------------------- |
| `resource` | The API domain your app needs | `items`, `customers`, `salesorder`, `stock` |
| `permission` | The access level | `read` (GET requests), `write` (POST, PATCH, DELETE) |
Requesting `write` access does not automatically include `read`. If your app needs to both read and modify items, declare both `items.read` and `items.write`.
### Capability-level Permissions
Beyond API scopes, Cloud Apps can enforce granular permissions on individual capabilities like **panels**. This lets you scope specific UI surfaces to a smaller subset of resources than the app as a whole.
#### Panel Permissions
Use `requiredScopes` on a panel definition to control resource access:
```json theme={null}
{
"capabilities": {
"erp": {
"panel": [
{
"title": "Inventory Insights",
"url": "https://example.com/panel/inventory",
"requiredScopes": ["items.read", "inventory.read"]
}
]
}
}
}
```
`requiredScopes` accepts the same scopes listed above.
## OnPremise Scopes
For OnPremise integrations, scopes are declared during app registration via the REST API. You include them in the `mandatoryApiScopes` and `optionalApiScopes` arrays of the registration request.
### Registering with Scopes
The example below registers an app that requires four scopes and optionally uses one more.
```bash theme={null}
curl -i -X POST \
"http://127.0.0.1:/api/eazybusiness/authentication" \
-H "Content-Type: application/json" \
-H "api-version: 2.0" \
-H "x-appid: MyApp/1.0.0" \
-H "x-appversion: 1.0.0" \
-H "x-challengecode: MyChallengeCode" \
-d '{
"appId": "MyApp",
"displayName": "My App",
"description": "Inventory management tool",
"version": "1.0.0",
"providerName": "My Company",
"providerWebsite": "https://example.com",
"mandatoryApiScopes": [
"stock.read",
"stock.write",
"items.write",
"salesorder.read"
],
"optionalApiScopes": [
"returns.read"
]
}'
```
### Fetching Registration Status and Granted Scopes
After registering, the API returns a `registrationId`. Poll the registration status endpoint with this ID to retrieve your API key and confirm which scopes were granted:
```bash theme={null}
curl -i -X GET \
"http://127.0.0.1:64110/api/eazybusiness/authentication/{registrationId}" \
-H "api-version: 2.0" \
-H "x-challengecode: MyChallengeCode"
```
The response contains your API key and the scopes attached to it:
```json theme={null}
{
"requestStatusInfo": {
"appId": "MyApp",
"registrationRequestId": "abc-123",
"status": 0
},
"token": {
"apiKey": "00000000-0000-0000-0000-000000000000"
},
"grantedScopes": [
"inventory.read",
"inventory.write",
"items.write",
"orders.read",
"returns.read"
]
}
```
The API key is shown **only once** in this response. Store it securely, as it cannot be retrieved again. All future API requests use this key in the `Authorization: Wawi ` header.
The `grantedScopes` array tells you exactly which permissions your app received. If any of your `optionalApiScopes` were not granted, they will be absent from this array. Your app should check `grantedScopes` and adapt its functionality accordingly.
### Mandatory vs. Optional Scopes
| Field | Description |
| -------------------- | ------------------------------------------------ |
| `mandatoryApiScopes` | Scopes your app **requires** to function. |
| `optionalApiScopes` | Scopes your app **can use** but doesn't require. |
Use mandatory scopes for core functionality and optional scopes for enhanced features that can degrade without breaking core functionality.
## Updating Scopes After Registration
Cloud Apps support updating scopes by modifying your `manifest.json`. Update the `capabilities.erp.api.scopes` array, then re-submit the updated manifest through the [Partner Portal](https://partner.jtl-cloud.com/).
OnPremise apps cannot modify scopes on an existing registration. If your app needs additional scopes, you must re-register the app with the updated scope list. This generates a new API key and the old key is invalidated.
Plan your scopes carefully before initial registration. Use `optionalApiScopes` for features you may need later to avoid forcing a re-registration.
## Best Practices
**Request minimal scopes.** Only declare scopes your app actually uses.
**Separate read, write, and print.** If your app only displays data, request `read` only. Add `write` when your app modifies resources. Add `print` only when you need to print.
**Avoid `system.all`.** Use granular scopes wherever possible.
**Use optional scopes for progressive features (OnPremise).** If your app has optional features that need extra permissions, put those in `optionalApiScopes` so the core app still works without them.
**Document your scopes for merchants.** In your App Store listing and support docs, explain why your app needs each scope. Transparency builds trust.
**Check scopes at runtime.** Before making API calls that require specific permissions, verify your app has the necessary scope. Handle `403 Forbidden` responses by showing clear messages.
## What's Next
Understand how tokens and scopes work together in the authentication flow.
Reference for all credential types across Cloud, OnPremise, and SCX.
Handle permission errors and scope-related 403 responses.
Full manifest.json schema including all capability fields.
# SSO Integration
Source: https://developer.jtl-software.com/guides/essentials/authentication/sso-integration
Single Sign-On integration for JTL Cloud Apps (currently in development).
**This feature is in development.** SSO integration is not yet available for
JTL Cloud Apps. This page will be updated when it becomes available.
## What SSO Integration Will Enable Single Sign-On (SSO) will allow JTL Cloud
Apps to authenticate users via external identity providers (e.g. Microsoft Entra
ID, Google Workspace, Okta). Rather than managing separate credentials for your
app, merchants will be able to sign in using their organization's existing
identity system. This is particularly relevant for apps targeting larger
merchants and enterprise customers who require centralized identity management
across their tool stack. ## What's Available Today Until SSO is available, Cloud
Apps use:
* [OAuth 2.0 Client Credentials flow](/guides/essentials/authentication/oauth2-flow) for backend API access
* [Session tokens via AppBridge](/guides/cloud-apps/authentication-login) for identifying the current user and tenant within the App Shell
These cover most use cases today. SSO will add an additional layer for apps that need to integrate with a merchant's external identity provider.
## Register your Interest
If you need SSO for your app, contact the JTL partner team to express interest and get notified when the feature becomes available:
**[partner@jtl-software.com](mailto:partner@jtl-software.com)**
Include your app name and a brief description of your use case. This helps JTL prioritise the feature based on your needs.
## What's Next?
The current authentication model for all JTL Cloud Apps.
How to implement authentication in your Cloud App today using AppBridge
and session tokens.
# Error Handling
Source: https://developer.jtl-software.com/guides/essentials/common-patterns/error-handling
Error handling in JTL APIs
Every JTL API uses standard HTTP status codes to indicate success or failure. This page covers the error formats returned by the JTL-Wawi API (REST and GraphQL) and SCX Channel API, the status codes you'll encounter, and strategies for handling failures.
## HTTP Status Codes
Use the HTTP status code as the first signal for how to handle a response. These codes apply to both REST and GraphQL requests at the HTTP transport level.
### Success Codes
| Code | Meaning | When you'll see it |
| ---------------- | ----------------- | ----------------------------------------------------------- |
| `200 OK` | Request succeeded | Successful GET, PUT, PATCH, or GraphQL requests |
| `201 Created` | Resource created | Successful POST requests that create a new resource |
| `204 No Content` | Success, no body | Successful DELETE requests or updates with no response body |
For GraphQL requests, a `200 OK` status does **not** guarantee success. GraphQL can return errors inside the response body while the HTTP status remains 200. Always check the `errors` array in the response. See the [GraphQL errors](#graphql-api) section below.
### Client Error Codes (4xx)
These indicate a problem with **your request**. Fix the request before retrying.
| Code | Meaning | Common cause |
| -------------------------- | ------------------------------------ | ---------------------------------------------------------------------------------- |
| `400 Bad Request` | Invalid request format or parameters | Malformed JSON, missing required fields, invalid data types |
| `401 Unauthorized` | Authentication failed | Missing `X-Tenant-ID` header, missing or expired access token, invalid credentials |
| `403 Forbidden` | Insufficient permissions | Valid token but lacking the required scope for this endpoint |
| `404 Not Found` | Resource does not exist | Wrong URL, deleted resource, or incorrect ID |
| `409 Conflict` | Resource conflict | Attempting to create a resource that already exists, or a concurrent modification |
| `412 Precondition Failed` | Required precondition missing | Missing `X-Tenant-ID` header or other required headers |
| `422 Unprocessable Entity` | Validation failed | Request is well-formed but the data does not pass business rules |
| `429 Too Many Requests` | Rate limit exceeded | Too many requests in a given time window. |
### Server Error Codes (5xx)
These indicate a problem on **JTL's side**. You cannot fix the underlying cause, but your app should handle them with retries and backoff.
| Code | Meaning | What to do |
| --------------------------- | ---------------------------- | -------------------------------------------------------------------------------- |
| `500 Internal Server Error` | Unexpected server failure | Retry with exponential backoff. If persistent, contact support. |
| `502 Bad Gateway` | Upstream service unavailable | Retry after a short delay. Usually transient. |
| `503 Service Unavailable` | Service temporarily down | Retry with exponential backoff. |
| `504 Gateway Timeout` | Request timed out upstream | Retry once. If persistent, simplify your request (fewer items, smaller payload). |
## Error Response Formats
The error response format differs between the JTL-Wawi REST API, the JTL-Wawi GraphQL API, and the SCX Channel API.
### JTL-Wawi REST API
REST endpoints return errors as JSON with an error code, message, and optional validation details:
```json theme={null}
{
"errorCode": "VALIDATION_ERROR",
"validationErrors": {
"sku": "SKU is required and cannot be empty",
"price": "Price must be a positive number"
},
"errors": {},
"errorMessage": "One or more validation errors occurred.",
"stacktrace": "..."
}
```
| Field | Description |
| ------------------ | ----------------------------------------------------------------------------------------------- |
| `errorCode` | A machine-readable error identifier (e.g., `VALIDATION_ERROR`, `NOT_FOUND`) |
| `validationErrors` | An object mapping field names to validation error messages. Empty `{}` if no validation errors. |
| `errors` | Additional error details. Empty `{}` in most cases. |
| `errorMessage` | A human-readable description of the error |
| `stacktrace` | Server-side stack trace. Do not rely on this in production. May be absent. |
### GraphQL API
GraphQL requests return HTTP `200 OK` for both successful and failed operations. Errors are reported inside the response body in an `errors` array.
A successful response looks like this:
```json theme={null}
{
"data": {
"QueryItems": {
"nodes": [ ... ],
"totalCount": 674
}
}
}
```
An error response looks like this:
```json theme={null}
{
"data": null,
"errors": [
{
"message": "Field 'invalidField' not found on type 'ItemListItem'",
"locations": [{ "line": 4, "column": 7 }],
"path": ["QueryItems"],
"extensions": {
"code": "VALIDATION_ERROR"
}
}
]
}
```
A partial success (some data, some errors) looks like this:
```json theme={null}
{
"data": {
"QueryItems": {
"nodes": [ ... ],
"totalCount": 674
},
"CreateCategory": null
},
"errors": [
{
"message": "Category name is required",
"path": ["CreateCategory"]
}
]
}
```
| Field | Description |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data` | The result of the operation. May be `null` if the entire operation failed, or contain partial results if some fields succeeded. |
| `errors` | An array of error objects. Each error has a `message`, optional `locations` (line/column in the query), optional `path` (which field caused the error), and optional `extensions` with a machine-readable `code`. |
| `errors[].message` | A human-readable description of the error |
| `errors[].path` | Array of field names tracing the error to a specific part of the query |
| `errors[].extensions.code` | A machine-readable error code (e.g., `VALIDATION_ERROR`, `UNAUTHORIZED`) |
The most important difference from REST: **never assume a `200 OK` means success** when using GraphQL. Always check for the `errors` array in the response body before processing `data`.
### SCX Channel API
The SCX Channel API returns errors as an `errorList` array, which can contain **multiple errors** in a single response:
```json theme={null}
{
"errorList": [
{
"code": "VAL100",
"message": "orderList[0].sellerId: SellerId must not be empty and may contain a maximum of 50 alphanumeric characters",
"severity": "error",
"hint": null
},
{
"code": "VAL100",
"message": "orderList[0].orderStatus: Invalid or unknown order status.",
"severity": "error",
"hint": null
}
]
}
```
| Field | Description |
| ---------- | ---------------------------------------------------------------------------------- |
| `code` | An error code identifying the type of error (e.g., `VAL100` for validation errors) |
| `message` | A human-readable description, including the field path |
| `severity` | The severity level (e.g., `error`) |
| `hint` | An optional hint for resolving the error (may be `null`) |
**Key differences between the three formats:**
| Feature | Cloud-ERP REST | Cloud-ERP GraphQL | SCX |
| ------------------------- | ---------------------------------------- | ------------------------------------ | -------------------------------- |
| **Error location** | HTTP status code + body | `errors` array in body (HTTP is 200) | HTTP status code + body |
| **Multiple errors** | Single `errorMessage` | Multiple items in `errors` array | Multiple items in `errorList` |
| **Field mapping** | `validationErrors` object keyed by field | `path` array on each error | Field path embedded in `message` |
| **Machine-readable code** | `errorCode` field | `extensions.code` | `code` field |
### Error Message Language
The SCX Channel API returns error messages in **German by default**. To receive error messages in English, set the `Accept-Language` header:
```
Accept-Language: en
```
***
## Handling Errors Effectively
Examples are in TypeScript. The patterns translate directly to any language with an HTTP client.
### 1. Check the Status Code and the Response Body
For REST and SCX requests, the HTTP status code tells you if something went wrong. For GraphQL, the status code is almost always `200`, so you must check the body.
**REST.** Check `response.ok` first, then parse the error body for the top-level message and any field-level validation errors:
```typescript theme={null}
const response = await fetch(url, { headers });
if (!response.ok) {
const error = await response.json();
console.error(`API error (${response.status}): ${error.errorMessage}`);
for (const [field, message] of Object.entries(
error.validationErrors ?? {},
)) {
console.error(` - ${field}: ${message}`);
}
return;
}
const data = await response.json();
```
**GraphQL.** Check two layers: HTTP-level errors first, then the `errors` array inside the response body. If `data` is present alongside errors, the response is a partial success, decide whether to use the available data or treat it as a failure:
```typescript theme={null}
const response = await fetch(graphqlUrl, { method: 'POST', headers, body });
if (!response.ok) {
throw new Error(`HTTP error (${response.status})`);
}
const result = await response.json();
if (result.errors?.length) {
for (const error of result.errors) {
const at = error.path ? ` at ${error.path.join('.')}` : '';
console.error(`GraphQL error: ${error.message}${at}`);
}
if (!result.data) {
throw new Error('GraphQL request failed completely');
}
}
// Process data (may be partial if errors were present)
const items = result.data.QueryItems;
```
### 2. Handle Auth Errors (401) with Token Refresh
A `401` typically means your access token has expired. Refresh the token and retry once:
```typescript theme={null}
async function fetchWithAuth(url: string, tenantId: string): Promise {
let accessToken = getCachedToken();
let response = await fetch(url, {
headers: {
Authorization: `Bearer ${accessToken}`,
'X-Tenant-ID': tenantId,
},
});
// If token expired, refresh and retry once
if (response.status === 401) {
accessToken = await getNewAccessToken();
cacheToken(accessToken);
response = await fetch(url, {
headers: {
Authorization: `Bearer ${accessToken}`,
'X-Tenant-ID': tenantId,
},
});
}
return response;
}
```
Only retry **once** on a 401. If the second request also returns 401, the issue is likely invalid credentials rather than an expired token. Retrying indefinitely will not resolve it.
### 3. Handle SCX Batch Errors
SCX responses can contain multiple errors in a single response. Always iterate the full `errorList`:
```typescript theme={null}
const response = await fetch(
"https://scx.api.jtl-software.com/v1/seller/channel/orders",
{
method: "POST",
headers: {
Authorization: `Bearer ${authToken}`,
"Accept-Language": "en",
"Content-Type": "application/json",
},
body: JSON.stringify({ orderList }),
}
);
if (!response.ok) {
const body = await response.json();
if (body.errorList) {
for (const error of body.errorList) {
console.error(`[${error.code}] ${error.message}`);
// Handle each error, e.g., flag the specific item that failed
}
}
}
```
### 4. Retry with Exponential Backoff for Server Errors
For 5xx errors and 429 (rate limit), increase the wait time between each retry:
```typescript theme={null}
async function fetchWithRetry(
url: string,
options: RequestInit,
maxRetries = 3
): Promise {
for (let attempt = 0; attempt <= maxRetries; attempt++) {
const response = await fetch(url, options);
// Don't retry client errors (except 429)
if (
response.status >= 400 &&
response.status < 500 &&
response.status !== 429
) {
return response;
}
// Success: return immediately
if (response.ok) {
return response;
}
// Server error or rate limit: retry with backoff
if (attempt < maxRetries) {
const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
console.warn(
`Request failed (${response.status}). Retrying in ${delay}ms...`
);
await new Promise((resolve) => setTimeout(resolve, delay));
}
}
throw new Error(`Request failed after ${maxRetries + 1} attempts`);
}
```
**Backoff schedule:**
| Attempt | Wait time |
| --------- | --------- |
| 1st retry | 1 second |
| 2nd retry | 2 seconds |
| 3rd retry | 4 seconds |
Add **jitter** (a small random delay) to prevent multiple clients from retrying at the same time. Replace `Math.pow(2, attempt) * 1000` with `Math.pow(2, attempt) * 1000 + Math.random() * 500`.
### 5. Log Errors with Context
When an API call fails, log enough information to reproduce the failure later. At minimum, capture:
* The endpoint that was called (URL or operation name)
* The HTTP status code
* The error code and message from the response body
* Any field-level validation errors
* The tenant ID the request was made on behalf of
* A timestamp
Avoid logging access tokens, session tokens, client secrets, or personally identifiable information from request payloads.
***
## Quick Reference
| Situation | What to do |
| ------------------------------ | ------------------------------------------------------------------------------- |
| `200 OK` with GraphQL `errors` | Check `errors` array. Process partial `data` if available, or treat as failure. |
| `400` Bad Request | Check your request body, headers, and parameters. Fix and resend. |
| `401` Unauthorized | Missing or expired access token, invalid credentials |
| `403` Forbidden | Check your app's scopes. You may need additional permissions. |
| `404` Not Found | Verify the URL and resource ID. The resource may have been deleted. |
| `409` Conflict | The resource was modified by another request. Re-fetch and retry. |
| `422` Validation error | Read the error details. Fix the data and resend. |
| `429` Rate limited | Wait and retry with exponential backoff. |
| `5xx` Server error | Not your fault. Retry with exponential backoff. |
***
## What's Next?
Understand request quotas and how to handle 429 responses.
Navigate large result sets with page-based and cursor-based pagination.
Full guide to calling REST and GraphQL APIs from your Cloud App.
Handle real-time events from the JTL platform.
# GraphQL Conventions
Source: https://developer.jtl-software.com/guides/essentials/common-patterns/graphql-conventions
The naming, structure, and response conventions the JTL GraphQL schema follows, so you can construct a valid query directly from the reference.
The JTL GraphQL schema follows consistent naming, response, and pagination patterns. Once you understand these conventions, you can explore the [Schema Reference](/api-reference/graphql-playground) and build queries directly from the available types and fields.
This guide walks through the conventions you'll see across the GraphQL API. For authentication, request headers, and reusable client configuration, see [Using Platform APIs](/guides/cloud-apps/using-platform-apis#graphql-api).
## Operation Naming
Query and mutation root fields use **PascalCase** with a verb prefix that describes what the operation does. Most operations follow these naming patterns:
| Operation | Pattern | Example |
| ----------------- | ---------------------------------- | ---------------------------------- |
| List a resource | `Query` | `QueryItems`, `QueryCompanies` |
| Fetch one by ID | `GetById` | `GetSalesOrderById`, `GetItemById` |
| Create a resource | `Create` | `CreateCategory`, `CreateItem` |
| Modify a resource | `Update`, `Change` | `UpdateCategory`, `ChangeItem` |
Verbs extend beyond these four where an operation does something more specific. Items are modified with `ChangeItem` rather than `UpdateItem`, suppliers are attached with `AddItemSupplier`, and operations like `CalculateSalesOrder`, `ReleaseProductionOrder`, and `ListTaxClassesWithTaxRates` name the action they perform. Treat the table as the shape to expect, and check the [Schema Reference](/api-reference/graphql-playground) for the exact verb on any specific operation.
A query that lists items begins at the `QueryItems` root field:
```graphql theme={null}
query GetItems {
QueryItems(first: 10) {
nodes {
id
sku
name
}
totalCount
}
}
```
## Selection Sets
Every field that returns an object requires a selection set: the nested fields you want back from it.
A field that returns a scalar (a string, number, boolean, or ID) can be queried directly and requires no further nesting. If a field returns an object, you must specify which fields you want from that object. `QueryItems` returns a list object, so the query expands into `nodes`, and each node expands into the fields you want returned:
```graphql theme={null}
query GetItems {
QueryItems(first: 10) {
nodes {
id
name
}
totalCount
}
}
```
GraphQL lets you request only the fields you need. Listing fewer fields returns a smaller payload; listing more returns more detail in the same request. The operation string is the only thing that changes.
## List Responses
List queries return a connection object with a consistent shape across every resource.
| Field | Type | Description |
| ------------ | ------- | ------------------------------------------------------------ |
| `nodes` | array | The records on the current page |
| `pageInfo` | object | Pagination metadata, including `hasNextPage` and `endCursor` |
| `totalCount` | integer | Total number of matching records across all pages |
The actual records are returned in the nodes array:
```graphql theme={null}
query GetItems {
QueryItems(first: 20) {
nodes {
id
sku
name
}
pageInfo {
hasNextPage
endCursor
}
totalCount
}
}
```
## Pagination
To fetch large result sets, list queries use cursor-based pagination. You control pagination through query arguments and use the values returned in `pageInfo` to request the next or previous page.
Pass `first` to control how many records are returned. The first request typically omits `after`.
To fetch the next page, take the value of `pageInfo.endCursor` from the previous response and pass it as the `after` argument. Repeat this process until `pageInfo.hasNextPage` is false.
To page backward, use `last` and `before` instead, and use `pageInfo.startCursor` and `pageInfo.hasPreviousPage` to navigate earlier pages.
```graphql theme={null}
query GetItems($first: Int, $after: String) {
QueryItems(first: $first, after: $after) {
nodes {
id
name
}
pageInfo {
hasNextPage
endCursor
}
}
}
```
For the full pagination loop with code samples, see [Pagination](/guides/essentials/common-patterns/pagination).
## Arguments
Operations accept arguments for paging, sorting, and filtering, supplied as GraphQL variables.
Most list queries accept the same paging, sorting, and filtering arguments:
| Argument | Purpose |
| -------- | ----------------------------------------------------------- |
| `first` | Page size when paging forward |
| `after` | Cursor marking where the next page begins |
| `last` | Page size when paging backward |
| `before` | Cursor marking where the previous page ends |
| `order` | Sort order, as an array of `{ field: ASC \| DESC }` objects |
| `where` | Filter conditions, using a structured input type |
Some queries take additional arguments of their own. `QueryItems` and `QueryCustomers`, for example, also accept `searchTerm`, `searchOperator`, and `searchField` for text search. The reference lists the full argument set on each operation.
Sort with `order` and filter with `where`:
```graphql theme={null}
query GetItems($first: Int, $order: [ItemListItemSortInput!], $where: ItemListItemFilterInput) {
QueryItems(first: $first, order: $order, where: $where) {
nodes {
id
name
}
totalCount
}
}
```
```json theme={null}
{
"first": 20,
"order": [{ "name": "ASC" }],
"where": { "name": { "contains": "T-shirt" } }
}
```
The operators available in a `where` filter depend on the field type.
String fields typically support operators such as `eq`, `neq`, `contains`, `startsWith`, and `in`. Numeric and date fields typically support comparison operators such as `eq`, `gt`, `gte`, `lt`, `lte`, and `in`.
Each field uses a filter type that defines which operators are available. For example, string fields use `StringOperationFilterInput`. Refer to the [Schema Reference](/api-reference/graphql-playground) to see the operators supported by a specific field.
## Input Types
Mutations take their data as a single structured input object rather than loose arguments.
Input type names follow the operation they belong to and end in `Input`, such as `CreateCategoryCommandRequestInput`. A mutation declares the input as a variable, then passes it through:
```graphql theme={null}
mutation CreateCategory($request: CreateCategoryCommandRequestInput) {
CreateCategory(request: $request) {
categoryId
}
}
```
```json theme={null}
{
"request": {
"name": "Summer Collection",
"sortNumber": 1,
"parentId": null
}
}
```
The reference lists every field on an input type, which fields are required, and their types. Structure your variables object to match the input type definition shown in the schema.
## Reading the Schema Reference
The schema reference is generated from the live API, so the types and fields you see there reflect the conventions described above.
When you open a type in the [Schema Reference](/api-reference/graphql-playground), apply these conventions to read it:
* Root fields under `Query` are the entry points for reads; root fields under `Mutation` are the entry points for writes. Their names follow the patterns in [Operation Naming](#operation-naming).
* A field's type tells you whether you can request it directly or need to select additional fields from it. Scalar types (`String`, `Int`, `Boolean`, `ID`, and enums) can be requested directly. Object types require a selection set.
* List queries return a connection type carrying `nodes`, `pageInfo`, and `totalCount`.
* A field marked with `!` is non-null. On an input type, a non-null field is required in your variables.
* Arguments and input fields appear alongside each operation, with their own types and required markers.
The [GraphQL Playground](/api-reference/graphql-playground) supports autocomplete and inline schema docs, so you can confirm field names and types as you build a query.
## What's Next
Wire GraphQL into your backend with headers, authentication, and a
reusable client.
Explore the schema interactively with autocomplete and inline docs.
The full cursor-based pagination pattern with code samples.
Error formats, the `errors` array, and retry strategies.
# Pagination
Source: https://developer.jtl-software.com/guides/essentials/common-patterns/pagination
Paginate through large result sets from JTL APIs
JTL's APIs return large collections in **pages** rather than all at once. Any endpoint that returns a list of items (products, invoices, customers, orders, etc.) includes pagination metadata so you can navigate through the results.
The JTL Platform uses two pagination styles depending on the API surface:
| API | Pagination style | How it works |
| ---------------------------- | ---------------- | ---------------------------------------------------------------- |
| **REST API** (JTL-Wawi, SCX) | Page-based | Pass `pageNumber` and `pageSize` as query parameters |
| **GraphQL API** (JTL-Wawi) | Cursor-based | Pass `first` (page size) and `after` (cursor) as query variables |
## Page-based Pagination (REST)
The REST API uses page-based pagination. Each response includes the current page of items plus metadata telling you the total number of items, how many pages exist, and whether there are more pages to fetch.
Examples below are in TypeScript. The patterns applies to any language with
an HTTP client.
### Making a Paginated Request
```bash theme={null}
curl -X GET "https://api.jtl-cloud.com/erp/v2/invoices?pageNumber=1&pageSize=20" \
-H "Authorization: Bearer $ACCESS_TOKEN" \
-H "X-Tenant-ID: $TENANT_ID"
```
### Response Structure
Every paginated REST response follows this structure:
```json theme={null}
{
"totalItems": 256,
"pageNumber": 1,
"pageSize": 20,
"totalPages": 13,
"hasPreviousPage": false,
"hasNextPage": true,
"nextPageNumber": 2,
"previousPageNumber": null,
"items": [
{ ... },
{ ... }
]
}
```
### Metadata Fields
| Field | Type | Description |
| -------------------- | -------------- | ------------------------------------------------------------- |
| `totalItems` | number | Total items across all pages |
| `pageNumber` | number | Current page |
| `pageSize` | number | Number of items per page |
| `totalPages` | number | Total number of pages |
| `hasNextPage` | boolean | Whether more pages exist after this one |
| `hasPreviousPage` | boolean | Whether pages exist before this one |
| `nextPageNumber` | number \| null | The next page number, or `null` if this is the last page |
| `previousPageNumber` | number \| null | The previous page number, or `null` if this is the first page |
| `items` | array | Items for this page |
### Requesting a Specific Page
Pass pagination parameters in the query string:
```
GET https://api.jtl-cloud.com/erp/v2/invoices?pageNumber=2&pageSize=20
```
| Parameter | Type | Description |
| ------------ | ------ | ----------------------------- |
| `pageNumber` | number | The page number (starts at 1) |
| `pageSize` | number | Items per page |
### Fetching the Next Page
Use `hasNextPage` and `nextPageNumber` to decide whether more results exist:
```typescript theme={null}
const response = await fetch(`${baseUrl}?pageNumber=1&pageSize=20`, {
headers,
});
const data = await response.json();
if (data.hasNextPage) {
// Fetch the next page using data.nextPageNumber
}
```
### Fetching All Pages
To retrieve every item across all pages, loop until `hasNextPage` is `false`:
```typescript theme={null}
async function fetchAllItems(
baseUrl: string,
headers: HeadersInit,
pageSize = 20,
) {
const allItems = [];
let pageNumber = 1;
while (true) {
const url = `${baseUrl}?pageNumber=${pageNumber}&pageSize=${pageSize}`;
const response = await fetch(url, { headers });
if (!response.ok) {
throw new Error(
`API error (${response.status}) on page ${pageNumber}`,
);
}
const data = await response.json();
allItems.push(...data.items);
if (!data.hasNextPage) break;
pageNumber = data.nextPageNumber ?? pageNumber + 1;
}
return allItems;
}
```
## Cursor-based Pagination (GraphQL)
The GraphQL API uses cursor-based pagination. Instead of page numbers, you use an opaque cursor string to request the next set of results. This is more reliable for large, frequently changing datasets because new or deleted records don't shift the page boundaries.
### Making a Paginated Request
Pass `first` (page size) and optionally `after` (cursor) as query variables:
```typescript theme={null}
const query = `
query GetERPItems($first: Int, $after: String) {
QueryItems(first: $first, after: $after) {
nodes {
id
sku
name
}
pageInfo {
hasNextPage
endCursor
}
totalCount
}
}
`;
// First page
const variables = { first: 20 };
// Subsequent pages: include the cursor from the previous response
// const variables = { first: 20, after: "eyJza2lwIjoyMH0=" };
```
**What this does:** Fetches the first 20 items. The `pageInfo` object tells you whether more pages exist and provides the cursor for the next page.
### Response Structure
```json theme={null}
{
"data": {
"QueryItems": {
"nodes": [
{
"id": "895d2d4d-4ed4-44c7-ac61-ebec01000000",
"sku": "AR2016041-VKO",
"name": "Men's T-shirt"
}
],
"pageInfo": {
"hasNextPage": true,
"endCursor": "eyJza2lwIjoyMH0="
},
"totalCount": 674
}
}
}
```
### Metadata Fields
| Field | Type | Description |
| ---------------------- | ------- | -------------------------------------------------- |
| `nodes` | array | Items for this page |
| `pageInfo.hasNextPage` | boolean | Whether more results exist beyond this page |
| `pageInfo.endCursor` | string | Opaque cursor to pass as `after` for the next page |
| `totalCount` | number | Total number of matching items across all pages |
### Fetching the Next Page
Pass the `endCursor` from the previous response as the `after` variable on the next request, and stop when `hasNextPage` is `false`:
```typescript theme={null}
let cursor: string | null = null;
while (true) {
const response = await fetch(graphqlUrl, {
method: 'POST',
headers,
body: JSON.stringify({
operationName: 'GetERPItems',
query: ITEMS_QUERY,
variables: { first: 20, after: cursor },
}),
});
const { data } = await response.json();
const page = data.QueryItems;
// Process page.nodes here
if (!page.pageInfo.hasNextPage) break;
cursor = page.pageInfo.endCursor;
}
```
**What this does:** Loops through pages by passing the `endCursor` from each response as the `after` variable in the next request. Stops when `hasNextPage` is `false`.
***
## Best Practices
**Use the smallest page size you need.** Use smaller page sizes for UI-driven fetching (10-20 items). Use larger sizes only for background sync or batch jobs (50-100 items).
**Don't rely on total counts for logic.** Both `totalItems` (REST) and `totalCount` (GraphQL) can change between requests as data is created or deleted. Use them for display only, not for control flow.
**Handle empty pages gracefully.** If a page has no items (e.g., records were deleted between requests), the items array will be empty. Don't treat this as an error:
```typescript theme={null}
if (data.items.length === 0 && !data.hasNextPage) {
// No more items
break;
}
```
**Respect rate limits when fetching all pages.** Large paginated fetches can hit rate limits. Add a delay or use exponential backoff between requests.
```typescript theme={null}
// Add a delay between page requests to avoid rate limiting
await new Promise((resolve) => setTimeout(resolve, 200));
```
**Avoid parallel page fetches.** Fetch pages sequentially unless you control rate limits and ordering. Parallel fetches can cause ordering issues and increase the risk of rate limiting.
**Choose the right pagination style for your use case.** If you're calling REST endpoints (invoices, payments), use page-based. If you're querying ERP data through GraphQL (items, categories, customers), use cursor-based. Don't mix them up.
## Quick Reference
| Question | REST (page-based) | GraphQL (cursor-based) |
| ------------------------------ | -------------------------- | --------------------------------- |
| How do I set page size? | `pageSize` query parameter | `first` variable |
| How do I get the next page? | Use `nextPageNumber` | Use `endCursor` as `after` |
| How do I know when I'm done? | `hasNextPage` is `false` | `pageInfo.hasNextPage` is `false` |
| What's the total count? | `totalItems` | `totalCount` |
| Can I jump to a specific page? | Yes (`pageNumber=5`) | No (traverse from the start) |
***
## What's Next?
Understand request quotas, especially important when fetching many
pages.
Handle errors that may occur during paginated fetches.
Full guide to querying the GraphQL API with filtering, sorting, and
pagination.
Instead of polling pages for changes, use webhooks to get notified in
real time.
# Rate Limiting
Source: https://developer.jtl-software.com/guides/essentials/common-patterns/rate-limiting
Understand how rate limits work across JTL's APIs: quotas, response headers, and strategies for staying within limits.
Rate limiting controls how many requests your app can make to JTL's APIs within a given time window. It ensures fair usage across all developers and prevents any single app from overloading the system.
Exceeding the limit returns an **HTTP 429 "Too Many Requests"** error. Some endpoints have lower limits than others to protect resource-intensive operations.
## How Rate Limiting Works
```mermaid theme={null}
flowchart TD
A["App sends API request"] --> B{"Within rate limit?"}
B -->|Yes| C["API processes request"]
C --> D["Response includes rate limit headers"]
D --> E{"X-RateLimit-Remaining > 0?"}
E -->|Yes| A
E -->|No| F["Wait for interval to reset"]
F --> A
B -->|No| G["HTTP 429 Too Many Requests"]
G --> H["Wait + retry with backoff"]
H --> F
style A fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style C fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style G fill:#FCE4EC,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style H fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
```
Every API response includes headers that tell you your current quota status. Monitor these headers to stay within limits proactively rather than reacting to 429 errors.
## Rate Limit Response Headers
Every response from JTL's APIs includes these headers:
| Header | Description | Example |
| ------------------------------------- | ------------------------------------------------ | ------- |
| `X-RateLimit-Limit` | Maximum requests allowed in the current interval | `10` |
| `X-RateLimit-Interval-Length-Seconds` | Length of the rate limit window in seconds | `45` |
| `X-RateLimit-Remaining` | Requests remaining in the current interval | `5` |
**Read these headers after every request.** They're your real-time view of how much quota you have left. When `X-RateLimit-Remaining` approaches zero, slow down or pause until the interval resets.
```typescript theme={null}
const response = await fetch('https://api.jtl-cloud.com/erp/v2/products', {
headers: {
Authorization: `Bearer ${accessToken}`,
'X-Tenant-ID': tenantId,
},
});
// Check rate limit status
const limit = response.headers.get('X-RateLimit-Limit');
const remaining = response.headers.get('X-RateLimit-Remaining');
const interval = response.headers.get('X-RateLimit-Interval-Length-Seconds');
console.log(
`Rate limit: ${remaining}/${limit} remaining (resets every ${interval}s)`,
);
```
***
## Rate Limits by API
### Cloud-ERP API
The Cloud-ERP API applies rate limits to all endpoints. Use the `X-RateLimit-*` response headers to determine the limits for each endpoint in your environment.
### SCX Channel API
The SCX Channel API has published rate limits per route pattern:
| Route pattern | Requests | Interval | Effective Rate |
| ----------------------------------------- | -------- | -------------- | -------------------- |
| Default (all other routes) | 10 | 60 seconds | \~0.17/sec |
| `/v[version]/channel*` | 60 | 60 seconds | 1/sec |
| `/v[version]/channel/order*` | 600 | 60 seconds | 10/sec |
| `/v[version]/channel/event*` | 240 | 60 seconds | 4/sec |
| `/v[version]/channel/offer*` | 1,500 | 60 seconds | 25/sec |
| `/v[version]/channel/attribute/category*` | 86,400 | 86,400 seconds | 1/sec (daily) |
| `/v[version]/channel/attribute/global*` | 10 | 3,600 seconds | \~0.003/sec (hourly) |
| `/v[version]/channel/categories*` | 10 | 3,600 seconds | \~0.003/sec (hourly) |
Sandbox rate limits are different from production. Don't assume your sandbox
testing reflects production capacity. Always check the `X-RateLimit-*`
headers in each environment.
## Handling Rate Limit Errors
When you exceed the limit, the API returns HTTP `429 Too Many Requests`. Here's how to handle it properly.
### 1. Monitor Headers Proactively
Don't wait for a 429, prevent it. Track `X-RateLimit-Remaining` and pause before you hit zero:
```typescript theme={null}
async function fetchWithRateLimit(
url: string,
options: RequestInit,
): Promise {
const response = await fetch(url, options);
const remaining = parseInt(
response.headers.get('X-RateLimit-Remaining') || '999',
);
const interval = parseInt(
response.headers.get('X-RateLimit-Interval-Length-Seconds') || '60',
);
// If running low, pause before the next request
if (remaining <= 2) {
console.warn(
`Rate limit nearly exhausted (${remaining} remaining). Pausing...`,
);
await new Promise((resolve) => setTimeout(resolve, interval * 1000));
}
return response;
}
```
### 2. Retry with Exponential Backoff
When you get a 429, don't retry immediately. Wait at increasing intervals before retrying:
```typescript theme={null}
async function fetchWithRetry(
url: string,
options: RequestInit,
maxRetries = 3,
): Promise {
for (let attempt = 0; attempt <= maxRetries; attempt++) {
const response = await fetch(url, options);
if (response.status === 429 && attempt < maxRetries) {
const waitTime = Math.pow(2, attempt) * 1000 + Math.random() * 500;
console.warn(
`Rate limited. Retrying in ${Math.round(waitTime)}ms...`,
);
await new Promise((resolve) => setTimeout(resolve, waitTime));
continue;
}
return response;
}
throw new Error('Max retries exceeded');
}
```
**Backoff Schedule (with Jitter):**
| Attempt | Base wait | With Jitter |
| --------- | --------- | --------------- |
| 1st retry | 1 second | 1.0–1.5 seconds |
| 2nd retry | 2 seconds | 2.0–2.5 seconds |
| 3rd retry | 4 seconds | 4.0–4.5 seconds |
### 3. Queue and Spread Requests
Use a queue to enforce a fixed request rate and avoid bursts.
```typescript theme={null}
class RequestQueue {
private queue: (() => Promise)[] = [];
private processing = false;
private delayMs: number;
constructor(requestsPerMinute: number) {
this.delayMs = Math.ceil(60000 / requestsPerMinute);
}
async add(fn: () => Promise): Promise {
return new Promise((resolve, reject) => {
this.queue.push(async () => {
try {
resolve(await fn());
} catch (err) {
reject(err);
}
});
this.process();
});
}
private async process() {
if (this.processing) return;
this.processing = true;
while (this.queue.length > 0) {
const task = this.queue.shift()!;
await task();
await new Promise((resolve) => setTimeout(resolve, this.delayMs));
}
this.processing = false;
}
}
// Usage: limit to 50 requests per minute
const queue = new RequestQueue(50);
const result = await queue.add(() =>
fetch('https://api.jtl-cloud.com/erp/v2/products', { headers }),
);
```
### 4. Cache Responses
Cache data based on how often it changes:
* Rarely changes → cache longer (categories, attributes)
* Frequently changes → cache briefly or not at all (orders)
## Best Practices
| Practice | Why |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Read rate limit headers on every response** | Know your remaining quota before it runs out |
| **Spread requests evenly** | Avoid sending many requests at once. It wastes your quota window |
| **Add jitter to retries** | Prevents multiple clients from retrying at the exact same time |
| **Cache aggressively for reference data** | Categories, attributes, and settings don't change often |
| **Use webhooks instead of polling** | Instead of checking "did anything change?" every minute, let JTL tell you. See [Webhooks](/guides/essentials/common-patterns/webhooks). |
| **Max 3 retries on 429** | If you're still rate limited after 3 retries, something is fundamentally wrong with your request pattern |
| **Log rate limit events** | Track when you're being throttled to identify patterns and optimise your request timing |
## Quick Reference
| Question | Answer |
| ------------------------------------------ | ------------------------------------------------------ |
| What status code means rate limited? | `429 Too Many Requests` |
| How do I check my remaining quota? | Read the `X-RateLimit-Remaining` response header |
| How long until the limit resets? | Check `X-RateLimit-Interval-Length-Seconds` |
| What's the max requests per interval? | Check `X-RateLimit-Limit` (varies by endpoint) |
| Should I retry on 429? | Yes, with exponential backoff + jitter (max 3 retries) |
| Are sandbox limits the same as production? | No. Always check the response headers per environment |
***
## What's Next?
Reduce polling and API calls by reacting to events in real time.
How to page through large result sets without hitting rate limits.
Handle 429 errors alongside other error types.
Browse endpoints and their specific rate limits.
# Versioning
Source: https://developer.jtl-software.com/guides/essentials/common-patterns/versioning
Understand how JTL versions its APIs, manifests, and platform components, and how to keep your integration stable across updates.
JTL uses versioning across three layers of the platform:
1. **API versioning**: Controls which version of the JTL Cloud and JTL-Wawi API your requests target.
2. **Manifest versioning**: Declares the schema version and app version in your `manifest.json`.
3. **Client compatibility**: Lets SCX marketplace channels enforce minimum JTL-Wawi versions for new seller connections.
Understanding each layer helps you ship stable integrations, adopt new features safely, and avoid breaking changes when JTL updates the platform.
## API Versioning
JTL uses different versioning strategies depending on the API surface. Both the JTL Cloud and JTL-Wawi APIs share the same version catalogue, but they pass the version differently.
### Available Versions
| Version | Notes |
| ------- | ----------------------------------------------------------- |
| `1.0` | Original release |
| `1.1` | Incremental additions |
| `1.2` | Extended endpoints for items, customers, and orders |
| `1.3` | Last minor release before v2.0 |
| `2.0` | Major revision, many v1.x endpoints removed or restructured |
**v1.x → v2.0 is a breaking change.** Dozens of endpoints from v1.x were removed in v2.0. If you're building a new integration, **always use v2.0**. If you're migrating from v1.x, review the [API Changelog](/help/changelog) for the full list of removed paths.
### JTL Cloud: URL-path Versioning
The JTL Cloud API embeds the version in the URL path:
```bash theme={null}
# JTL Cloud: version is in the path (/erp/v2/)
curl -X GET "https://api.jtl-cloud.com/erp/v2/info" \
-H "Authorization: Bearer " \
-H "X-Tenant-ID: "
```
The version segment determines which API version handles the request. Check the [API Reference](/api-reference) to see available versions and choose the appropriate one for your integration.
### JTL-Wawi (OnPremise): Header-based Versioning
The JTL-Wawi API uses the `api-version` request header instead:
```bash theme={null}
# JTL-Wawi: version is in the header
curl -i -X GET "http://127.0.0.1:/api/eazybusiness/info" \
-H "Authorization: Wawi " \
-H "api-version: 2.0" \
-H "x-appid: MyApp/1.0.0" \
-H "x-appversion: 1.0.0" \
-H "x-challengecode: MyChallengeCode"
```
The `api-version` header is required on every OnPremise request. If omitted, the API may default to the earliest supported version. Always set it to `2.0` explicitly.
### SCX (Marketplace): URL-path Versioning
SCX APIs also use URL-path versioning:
```
GET https://scx-sbx.api.jtl-software.com/v1/channel/order
```
The version prefix (`/v1/`) is part of the endpoint URL. Currently only `v1` is available.
## Manifest Versioning
Your app's `manifest.json` contains two version fields:
```json theme={null}
{
"manifestVersion": "1.0.0",
"version": "2.3.1",
...
}
```
### `manifestVersion`
Declares which version of the manifest **schema** your file conforms to. JTL uses this to parse and validate your manifest correctly.
* Format: `major.minor.patch` (semantic versioning)
* Set this to the latest supported schema version when creating your manifest
* Changing `manifestVersion` may be required when JTL introduces new manifest capabilities (new fields, changed validation rules)
### `version`
Your **app's own version** to track releases of your application.
* Format: `major.minor.patch` (semantic versioning)
* Update this when you ship changes to your app
* Displayed to merchants in the Extension Store
Follow [semantic versioning](https://semver.org) conventions: increment `major` for breaking changes, `minor` for new features, and `patch` for bug fixes.
## Client Compatibility (SCX Channels)
If you're building an SCX marketplace channel, the `minClientsVersionRequired` property lets you enforce a minimum JTL-Wawi version for new seller signups.
### How it Works
When a seller connects to your channel, SCX compares the seller's Wawi version (from their `User-Agent` header) against your defined minimum. If their version is too low, onboarding fails with error code `SLR202`. Existing connected sellers are **not** affected and their connection continues even if their Wawi version is below the minimum.
### Configuration
Set the minimum version via `PATCH /v1/channel`:
```json theme={null}
{
"minClientsVersionRequired": [
{
"type": "Wawi",
"version": "1.11.0.0"
}
]
}
```
| Field | Type | Description |
| --------- | ------ | ----------------------------------------------------------------------- |
| `type` | string | Client type. Currently only `Wawi` is supported. |
| `version` | string | Minimum version in `major.minor.patch.build` format (e.g., `1.11.0.0`). |
### When to Use This
* **Gradual rollouts**: Require a minimum client version for new signups when your channel depends on features from a specific Wawi release.
* **Controlled upgrades**: Encourage merchants to update Wawi before connecting to your channel.
* **Legacy protection**: Prevent issues from outdated clients without disrupting merchants already connected.
## Best Practices
**Pin your API version explicitly.** For JTL Cloud, always use the `/erp/v2/` path prefix. For JTL-Wawi, always send `api-version: 2.0` in the header.
**Start new projects on v2.0.** Building on deprecated v1.x versions creates unnecessary migration work. Use v2.0 for both Cloud and OnPremise, and set the latest `manifestVersion` in your manifest.
**Monitor the changelog.** JTL publishes an [API Changelog](/help/changelog) documenting removed, added, and changed endpoints between versions. Subscribe to updates or check before each release cycle.
**Version your own app meaningfully.** Use the `version` field in your manifest to communicate changes to merchants. Consistent version bumps build trust in the App Store.
***
## What's next
Explore available endpoints across API versions.
Handle version-related errors and deprecation responses.
Understand request limits that apply across all API versions.
Full manifest.json schema documentation.
# Webhooks & Events
Source: https://developer.jtl-software.com/guides/essentials/common-patterns/webhooks
How event systems work on the JTL platform: AppBridge events, lifecycle hooks, and SCX polling events.
The JTL platform has three different event systems depending on what you're building and what kind of events you need to handle. This guide explains each one, how they differ, and when to use which.
## Event Systems at a Glance
| System | Model | Used by | Use when |
| -------------------- | ------------------------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| **AppBridge Events** | Real-time, bidirectional (push) | Cloud Apps | Communication between your app and the JTL App Shell like reacting to user actions and notifying the host of state changes |
| **Lifecycle Hooks** | iframe handshake | Cloud Apps | App installation: onboarding UI and the setup handshake |
| **SCX Events** | Polling (pull) | Marketplace Channels | Consuming seller actions: new offers, order updates, attribute changes |
```mermaid theme={null}
flowchart LR
subgraph EventSystems["JTL Event Systems"]
direction TB
subgraph AB["AppBridge Events"]
ABDesc["Real-time, bidirectional"]
end
subgraph LH["Lifecycle Hooks"]
LHDesc["Iframe handshake on install"]
end
subgraph SCX["SCX Events"]
SCXDesc["Polling-based"]
end
end
YourApp["Your App"] <-->|"publish / subscribe (iframe postMessage)"| Shell["App Shell"]
Platform["JTL Platform"] -->|"loads configurationUrl in an iframe"| YourBackend["Your App"]
YourChannel["Your Channel"] -->|"GET then DELETE /v1/channel/event"| SCXAPI["SCX API"]
AB ~~~ YourApp
LH ~~~ Platform
SCX ~~~ YourChannel
style AB fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style LH fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style SCX fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style Shell fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
style Platform fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
style SCXAPI fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style YourApp fill:#fff,stroke:#0B1B45,stroke-width:1px,color:#0B1B45
style YourBackend fill:#fff,stroke:#0B1B45,stroke-width:1px,color:#0B1B45
style YourChannel fill:#fff,stroke:#0B1B45,stroke-width:1px,color:#0B1B45
```
## AppBridge Events
**In development:** AppBridge publish/subscribe events are in development and not yet available. This section will be updated when the API ships.
**What they will be:** Real-time, bidirectional events between your Cloud App and the App Shell. Your app can both **publish** events (tell the host something happened) and **subscribe** to events (react when the host tells you something happened).
**How they will work:** AppBridge events use the iframe messaging channel. When your app publishes an event, the App Shell receives it instantly. When the App Shell publishes an event, your app's subscriber callback fires immediately. Communication is asynchronous and non-blocking, so your app continues executing while the message is delivered (no HTTP request, polling, or delay).
**When to use them (planned):**
* Notifying the JTL App Shell that your app completed an action (e.g. order verification finished)
* Reacting to user navigation or context changes in the JTL-Wawi
* Coordinating between your app and other platform components
### Publish and Subscribe
AppBridge events will support two capabilities:
* **Publishing events**: your app notifies the host that something happened (for example, a verification step completed or a generated description is ready to insert).
* **Subscribing to events**: your app listens for events from the host and reacts when context changes (for example, the merchant navigates to a different record).
Topics will follow a `resource:action` naming convention (for example, `order:verification:complete` or `inventory:updated`) so the intent of an event is clear from its name alone.
### Key Characteristics
| Property | Value |
| ---------------- | -------------------------------------------------------------------- |
| **Direction** | Bidirectional: your app ↔ App Shell |
| **Delivery** | Instant (through the iframe) |
| **Scope** | Only within the current user session. Events don't persist or queue. |
| **Availability** | Cloud Apps running inside the App Shell only |
## Lifecycle Hooks
**What they are:** A URL defined in your app's `manifest.json` that JTL loads in an iframe when a merchant installs your app.
**How they work:** You define a `configurationUrl` in the `lifecycle` section of your manifest. When a merchant installs your app, JTL loads that URL inside the JTL Hub. Your app shows its onboarding UI, completes the AppBridge handshake, and signals setup is done by calling `appBridge.method.call('setupCompleted')`.
**When to use it:**
* Showing onboarding UI when a merchant installs your app
* Verifying the session token from AppBridge and persisting the tenant connection
* Collecting any configuration the merchant needs to provide
### Manifest Configuration
The lifecycle hook is defined in your `manifest.json`:
```json theme={null}
{
"lifecycle": {
"configurationUrl": "https://app.yourcompany.com/setup"
}
}
```
| Hook | When it's triggered | What to do |
| ------------------ | ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `configurationUrl` | Merchant initiates app installation | Display a setup screen inside the App Shell. Verify the session token from AppBridge, persist the tenant connection, and complete the handshake with `appBridge.method.call('setupCompleted')`. |
### Key Characteristics
| Property | Value |
| ---------------- | --------------------------------------------- |
| **Direction** | One-way — JTL Hub loads your URL in an iframe |
| **Delivery** | Iframe render in the merchant's browser |
| **Scope** | Per-tenant onboarding |
| **Availability** | Cloud Apps with a registered manifest |
The `configurationUrl` is the most important lifecycle hook. It's the entry point for the merchant's first interaction with your app. If this URL is unreachable when a merchant tries to install your app, the installation fails. Make sure it's always available.
For implementation details, see the [Quick Start: From Scratch](/get-started/quick-start/from-scratch) guide, which walks through the full setup handshake.
## SCX Events (Polling)
**What they are:** An event queue for marketplace channel integrations. When sellers (merchants using JTL) take actions like creating a new product offer, updating prices, or shipping an order, those actions are queued as events. Your channel integration polls the queue, processes the events, and acknowledges them.
**How they work:** This is a **pull-based** system, not push-based. JTL doesn't send events to your server. Instead, your app periodically calls `GET /v1/channel/event` to check for new events, processes them, and then calls `DELETE /v1/channel/event` to acknowledge them. Unacknowledged events are redelivered.
**When to use them:**
* Processing new product listings from sellers
* Handling order status updates (paid, shipped, cancelled)
* Syncing attribute and category changes
### Poll → Process → Acknowledge
```mermaid theme={null}
sequenceDiagram
autonumber
participant App as Your Channel App
participant SCX as SCX Channel API
loop Every ~60 seconds
App->>SCX: GET /v1/channel/event
SCX-->>App: eventList (0 or more events)
alt Events received
App->>App: Process each event
App->>SCX: DELETE /v1/channel/event (eventIdList)
SCX-->>App: Acknowledged
end
end
```
1. **Poll**: Your app calls `GET /v1/channel/event` at regular intervals (recommended: every 60 seconds)
2. **Process**: Handle each event based on its `type` (new offer, order update, attribute change, etc.)
3. **Acknowledge**: Call `DELETE /v1/channel/event` with the IDs of events you've successfully processed
### Event Structure
Each event in the `eventList` has this shape:
```json theme={null}
{
"id": "63623b997d2c89a4e3e9f3c7",
"type": "Seller:Offer.New",
"createdAt": "2022-11-02T14:38:53+00:00",
"event": {
"sellerId": "1",
"offerId": 822,
"sku": "843609",
"title": "Fahrrad Halterung",
"quantity": "0",
"taxPercent": "19",
"priceList": [ ... ],
"channelAttributeList": [ ... ]
}
}
```
| Field | Description |
| ----------- | ------------------------------------------------------------------------------------- |
| `id` | Unique event identifier — use this for acknowledgement |
| `type` | The event type (e.g. `Seller:Offer.New`, `Seller:Meta.SellerAttributesUpdateRequest`) |
| `createdAt` | When the event was created (ISO 8601) |
| `event` | The event payload that varies by event type |
### Acknowledging Events
After processing, acknowledge events by sending their IDs:
```json theme={null}
// DELETE /v1/channel/event
{
"eventIdList": [
"63623b997d2c89a4e3e9f3c7",
"636280fd65a66c4430ec0d67"
]
}
```
**Always acknowledge events after successful processing.** If you don't acknowledge an event, it will be redelivered after a timeout — up to **10 times**. After 10 delivery attempts, the event becomes a **failed event** and is permanently discarded.
### Key Characteristics
| Property | Value |
| ---------------- | ------------------------------------------------------------------------------------------- |
| **Direction** | Pull: your app polls the SCX API |
| **Delivery** | Queued. Events wait until your app fetches them. |
| **Reliability** | Guaranteed delivery (up to 10 retries). Events persist until acknowledged or dead-lettered. |
| **Ordering** | Events are returned in creation order |
| **Scope** | Seller events for your connected channel |
| **Availability** | SCX Channel API (Marketplace Channels only) |
### Best Practices for SCX Event Polling
| Practice | Why |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **Poll every \~60 seconds** | Balances responsiveness with rate limit usage |
| **Acknowledge in batches** | Send all processed event IDs in a single DELETE call, not one per event |
| **Process idempotently** | Events can be redelivered if acknowledgement fails. Design handlers that produce the same result if called twice with the same event. |
| **Handle unknown event types gracefully** | New event types may be added. Log and acknowledge events your app doesn't recognise rather than failing. |
| **Monitor for dead letters** | If events are dead-lettering, your processing pipeline has a problem that needs investigation. |
## Choosing the Right Event System
| I'm building... | I need to... | Use |
| --------------------- | --------------------------------------------------- | -------------------- |
| A Cloud App | React to user actions in real time | **AppBridge Events** |
| A Cloud App | Handle app install onboarding | **Lifecycle Hooks** |
| A Marketplace Channel | Process seller actions (offers, orders, attributes) | **SCX Events** |
***
## What's Next?
Implementation guide for AppBridge events and lifecycle hooks in Cloud Apps.
Full guide to building a marketplace channel integration, including SCX event handling.
Manage your API usage when polling for events at regular intervals.
Handle failures in event processing and API calls.
# Guides Overview
Source: https://developer.jtl-software.com/guides/guides-overview
Guides for building Cloud Apps, marketplace channels, and ERP integrations on JTL.
These guides show how to build integrations on the JTL platform. Choose based on your integration type: Cloud App, Marketplace Channel, or ERP Integration.
**New here?** Start with [Get Started](/get-started/what-is-jtl-platform). These guides assume you already have credentials and a working development setup.
## Start with the Essentials
Some concepts apply across all integration types:
OAuth 2.0, API keys, scopes, and session tokens used across the platform.
Error handling, pagination, rate limits, webhooks, and versioning.
## Choose What you're Building
Build apps like dashboards, tools, and automation with UI inside JTL.
**Start here if:** your app runs inside JTL and has a user interface.
Connect external sales platforms using the SCX Channel API.
**Start here if:** you're integrating a marketplace or sales channel.
Sync data between JTL-Wawi and external systems.
**Start here if:** you need backend data integration without UI.
## Guide Structure
| Section | Covers | For |
| ------------------------ | -------------------------------------------------------- | ----------------------------- |
| **Essentials** | Auth, API patterns, error handling, webhooks, versioning | All integrations |
| **Cloud Apps** | App architecture, UI integration, APIs | Apps running inside JTL Cloud |
| **Marketplace Channels** | SCX API, product sync, order flows | Marketplace integrations |
| **ERP Integration** | Data sync and backend integrations | External system integrations |
You'll often move between sections. For example, reading about [OAuth 2.0](/guides/essentials/authentication/oauth2-flow) while implementing it in a [Cloud App](/guides/cloud-apps/authentication-login).
## Not Sure Where to Start?
* **I just finished the Quick Start**\
→ Go to [Cloud Apps: Architecture Overview](/guides/cloud-apps/architecture-overview), then [Using Platform APIs](/guides/cloud-apps/using-platform-apis)
* **I need to understand authentication**\
→ Start with [OAuth 2.0 Flow](/guides/essentials/authentication/oauth2-flow)
* **I'm building a marketplace connector**\
→ Go to [Channel API Overview](/guides/marketplace-channels/channel-api-overview)
* **I need to sync data with JTL**\
→ Start with [ERP Integration Overview](/guides/erp-integration/integration-overview)
# Authorization
Source: https://developer.jtl-software.com/guides/marketplace-channels/authorization
How to authenticate against the SCX APIs: refresh tokens, access tokens, and Bearer headers.
All SCX APIs (Channel, Seller, Public, Auth) use the same token-based authorization flow. You exchange a long-lived **refresh token** for a short-lived **access token**, then pass that access token as a Bearer header on every subsequent request.
Refresh tokens are issued during onboarding. If you don't have one yet, see [Seller Management](/guides/marketplace-channels/seller-management) for the sign-up flow.
## Token Exchange
Call `POST /v1/auth` with your refresh token to obtain an access token. See the [Auth API Reference](/api-reference/scx/auth) for the full request and response schema.
```json theme={null}
{
"scope": "SELLER",
"authToken": "eyJhbG.....",
"tokenExpireAt": "2036-04-01T12:00:00+00:00",
"expiresIn": 360
}
```
| Field | Description |
| --------------- | ---------------------------------------------------------------------------------------- |
| `authToken` | the access token to use as a Bearer credential. |
| `tokenExpireAt` | absolute expiry in ISO 8601. |
| `expiresIn` | lifetime in seconds. |
| `scope` | the authorization scope tied to your refresh token (for example, `CHANNEL` or `SELLER`). |
## Using the Access Token
Send the access token as a Bearer token in the `Authorization` header on every SCX API request:
```
Authorization: Bearer eyJ0eXAi....
```
## Expiry and Refresh
Access tokens are short-lived. Refresh them proactively before `tokenExpireAt` rather than waiting for a `401 Unauthorized` response.
Do not call `POST /v1/auth` for every API request. The Auth API is [rate limited](/guides/marketplace-channels/rate-limits), and excessive authentication requests may result in `429 Too Many Requests` responses. Cache and reuse the access token until it is close to expiring, then request a new one.
The following pattern caches the access token and refreshes it only when necessary:
1. On first use, call `POST /v1/auth` and store the `authToken` together with its `tokenExpireAt` value.
2. Before each API request, check whether `tokenExpireAt` is more than 60 seconds in the future. If it is, reuse the cached token.
3. Otherwise, call `POST /v1/auth` again using the same refresh token to obtain a new access token.
## What's Next?
Understand the per-endpoint quotas and 429 handling across all SCX APIs.
Endpoint-level reference for `POST /v1/auth`.
# Channel API Overview
Source: https://developer.jtl-software.com/guides/marketplace-channels/channel-api-overview
Introduction to the JTL Marketplace Channel API: events, metadata, and media content handling.
**The Channel API is available for OnPremise integrations.** Consuming SCX from within a Cloud App is in development and not yet available.
With the JTL-Channel API, you can:
* Describe connected marketplace data structure by providing category and attribute data
* Manage product and offer listings
* Update price and quantity of a listing
* Manage orders
* Manage the post-order process (returns, refunds)
## Terminology
The Channel API uses a small set of terms consistently throughout this guide.
| Term | Definition |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **Channel** | A connection to a marketplace or any external system which can be connected to the JTL-Channel API. |
| **Seller** | A person identified by a unique ID (SellerId) who wants to offer and sell their goods on the connected Channel. |
| **Event** | An action initiated by a seller. A channel needs to react to events in order to create or update a listing or to process post-order actions. |
| **Seller API** | The Channel API counterpart. The ERP system JTL-Wawi is connected with the Seller API. |
## Development Cycle
This section covers the hosts, prerequisites, and local setup you need to build and test a channel integration.
### API Hosts
The Channel API is available in a sandbox environment for development and a production environment for live traffic.
```text Sandbox theme={null}
https://scx-sbx.api.jtl-software.com
```
```text Production theme={null}
https://scx.api.jtl-software.com
```
### Prerequisites
To access the JTL-Channel API you need an API refresh token. These tokens are created during the onboarding process
together with JTL. Sellers connect to a channel with an eazyAuction subscription. If you are interested in connecting your
marketplace with the JTL ecosystem, please [contact us](https://www.jtl-software.de/kontakt).
### Development
The Channel implementation runs on your own infrastructure. You as the Channel integrator have the full responsibility to
run, manage, and secure your application.
### Error Handling
Error responses are indicated by an HTTP status code >= 400. The Channel API uses a consistent error response format:
```json theme={null}
{
"errorList": [
{
"code": "VAL100",
"message": "orderList[0].sellerId: SellerId must not be empty and may contain a maximum of 50 alphanumeric characters",
"severity": "error",
"hint": null
},
{
"code": "VAL100",
"message": "orderList[0].orderStatus: Invalid or unknown Order Status. Must be one of UNACKED, CREATED, ACCEPTED, SHIPPED, PARTIALLY_SHIPPED, CANCELED_BY_SELLER, CANCELED_BY_BUYER",
"severity": "error",
"hint": null
}
]
}
```
The default language for error messages is German (`de`). You can switch to English by setting the `Accept-Language: en` header.
### Setting Up a Local JTL-Wawi Instance
You can use the JTL-Wawi ERP system during development to create new listings or manage orders.
[Install JTL-Wawi](https://www.jtl-software.com/de/warenwirtschaftssystem-software/jtl-wawi-download/) version 1.8 or higher to connect with the sandbox environment.
Connect to the MSSQL Server directly and insert the seller's refresh token (created during onboarding):
```sql theme={null}
INSERT INTO SCX.tRefreshToken
(cRefreshToken, nType)
VALUES
(N'', 1);
```
```sql theme={null}
UPDATE dbo.tOptions
SET cValue = 'https://scx-sbx.api.jtl-software.com'
WHERE ckey = 'SCX.URL'
```
Restart JTL-Wawi to apply the changes.
### Using the Seller API Directly
To test workflows and send test data to the Channel API, you can use the Seller API directly.
See the [Seller API reference](/api-reference/scx/seller) and the [Postman Collection](https://www.postman.com/jtl-eazyauction/workspace/jtl-scx-public).
## Events
Two important components of SCX are **seller events** and **channel events**. Seller events are emitted by a seller integration such
as JTL-Wawi. Channel events are emitted by a channel integration. Such events are actions created by an actor
(either a seller or a channel) and may be handled by connected integrations.
A channel integration needs to handle the various seller events provided by `GET /v1/channel/event` in order to create new
listings, and mark orders as paid or shipped.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
Seller->>SCX: Emits seller event (e.g. Offer.New)
SCX->>SCX: Queues event for channel
loop Poll every ~60 seconds
Channel->>SCX: GET /v1/channel/event
SCX-->>Channel: Returns eventList
end
Channel->>Channel: Process events
Channel->>SCX: DELETE /v1/channel/event (acknowledge)
```
We recommend calling the seller event endpoint at regular intervals (such as once a minute) and consuming all available events.
When an event is consumed, it **must** be acknowledged by calling `DELETE /v1/channel/event`. Otherwise, the event will be
transmitted again after a timeout.
An event will be transmitted a maximum of 10 times. Afterwards it will be marked as a dead-letter and will
not be transmitted again.
### Seller Event Types
Seller events fall into three groups: offer events, order events, and seller meta events.
| Event Type | Description |
| -------------------------- | --------------------------------------------------------------- |
| `Seller:Offer.New` | A new listing/offer was created by the seller |
| `Seller:Offer.Update` | An existing listing/offer was updated |
| `Seller:Offer.StockUpdate` | Stock quantity changed (deprecated, use stock update endpoints) |
| `Seller:Offer.PriceUpdate` | Price changed for an existing offer |
| Event Type | Description |
| ------------------------------------- | -------------------------------------------------- |
| `Seller:Order.Shipping` | Seller has shipped (or partially shipped) an order |
| `Seller:Order.Payment` | Payment status changed |
| `Seller:Order.CancellationAccepted` | Seller accepted a cancellation request |
| `Seller:Order.CancellationDenied` | Seller denied a cancellation request |
| `Seller:Order.Refund` | Seller initiated a refund |
| `Seller:Order.ReturnProcessingResult` | Seller processed a return |
| Event Type | Description |
| ------------------------------------------- | -------------------------------------------------- |
| `Seller:Meta.SellerAttributesUpdateRequest` | Seller requested to update their seller attributes |
| `Seller:Channel.Unlinked` | Seller unlinked from the channel |
### Receiving Seller Events
A `GET /v1/channel/event` call returns an `eventList` containing the queued events for your channel.
```json theme={null}
// GET /v1/channel/event
{
"eventList": [
{
"id": "63623b997d2c89a4e3e9f3c7",
"event": {
"channel": "WAWIDEV001",
"sellerId": "EA4590MitName"
},
"createdAt": "2022-11-02T09:42:49+00:00",
"type": "Seller:Meta.SellerAttributesUpdateRequest"
},
{
"id": "636280fd498628e9f0b28984",
"event": {
"sellerId": "1",
"offerId": 822,
"channelCategoryId": "CAT7",
"quantity": "0",
"taxPercent": "19",
"priceList": [
{
"id": "B2C",
"quantityPriceList": [
{
"quantity": "1",
"amount": "19.99",
"currency": "EUR"
}
]
}
],
"title": "Fahrrad Halterung",
"channelAttributeList": [
{
"attributeId": "WAWI-61427_number_category",
"value": "954",
"group": "0"
}
],
"sku": "843609"
},
"createdAt": "2022-11-02T14:38:53+00:00",
"type": "Seller:Offer.New"
}
]
}
```
### Acknowledging Events
After processing, acknowledge the received events so they are not retransmitted:
```json theme={null}
// DELETE /v1/channel/event
{
"eventIdList": [
"63623b997d2c89a4e3e9f3c7",
"636280fd65a66c4430ec0d67"
]
}
```
## Metadata
Within the SCX context, there is no concept of a product catalogue. Instead, only listing data is transmitted via the SCX interface. Depending on the channel's requirements, this listing data may also include detailed product information.
A channel provides descriptive information that defines what a listing can look like on a connected marketplace. This descriptive information is called **Metadata**.
```mermaid theme={null}
graph TD
A[Channel Metadata] --> B[Price Types]
A --> C[Category Tree]
A --> D[Attributes]
D --> D1[Global Attributes]
D --> D2[Category Attributes]
D --> D3[Seller Attributes]
D --> D4[Item-specific Attributes]
```
### Price Types
There must be at least one price type available to create a listing on a connected marketplace.
Examples of price types are B2C or B2B prices.
```json theme={null}
// POST /v1/channel/price
{
"priceTypeId": "MarketplaceTypeId",
"displayName": "Marketplace Price",
"description": "Selling price on Marketplace"
}
```
The `priceTypeId` will be transmitted with the `Seller:Offer.New` or `Seller:Offer.Update` seller events:
```json theme={null}
{
"sellerId": "1",
"offerId": 4711,
"channelCategoryId": "Stuff",
"quantity": "508.00",
"taxPercent": "19",
"priceList": [
{
"id": "MarketplaceTypeId",
"quantityPriceList": [
{
"amount": "6.95",
"currency": "EUR",
"quantity": "1"
}
]
}
]
}
```
### Category Tree
A connected channel may provide a category structure to set specific attributes related to a category.
The API endpoint replaces the entire category structure on each call.
```json theme={null}
// PUT /v1/channel/categories
{
"categoryList": [
{
"categoryId": "1",
"displayName": "First Category",
"listingAllowed": false,
"parentCategoryId": "0"
},
{
"categoryId": "1.1",
"displayName": "First Leaf Category",
"listingAllowed": true,
"parentCategoryId": "1"
},
{
"categoryId": "1.2",
"displayName": "Second Leaf Category",
"listingAllowed": true,
"parentCategoryId": "1"
}
]
}
```
### Attributes
Attributes provide a simple way of describing a listing for a channel. This lets the channel
define all marketplace requirements for a listing as attributes. SCX differentiates between the following attribute types:
Global attributes should be used when data is required for each listing.
These are set via `PUT /v1/channel/attribute/global` and apply to all listings regardless of category.
Category attributes are related to a `categoryId` inside the category structure. JTL-Wawi will display these attributes
only when the listing is part of a given category.
These are set via `POST /v1/channel/attribute/category/{categoryId}`.
Seller attributes are global attributes and can be used when a seller requires individual settings for their listings.
These are set via `POST /v1/channel/attribute/seller`.
Item-specific attributes are not specified by the channel but are instead created and transferred by the seller.
Each attribute must provide a simple, non-schematic, key-value data structure. These attributes will be transmitted
along with the `channelAttributeList` in each `Seller:Offer.New` or `Seller:Offer.Update` event.
These attributes are highly specific and depend on the input of the seller. The channel can use these attributes to
provide product and listing data.
#### Attribute Types Reference
Each attribute is declared with one of the following types.
| Type | Description |
| ----------- | ---------------------------------------- |
| `smalltext` | Short text value |
| `text` | Longer text value |
| `integer` | Integer number |
| `decimal` | Decimal number |
| `boolean` | True/false value |
| `enum` | Enumerated value with predefined options |
| `htmltext` | HTML-formatted text |
| `date` | Date value |
| `image` | Link to an image file |
| `document` | Link to a document file |
#### Attributes with Different Types
The following request registers one attribute of each supported type against a category.
```json theme={null}
// POST /v1/channel/attribute/category/DEMO-TYPES
// DEMO-TYPES is a categoryId created earlier via PUT /v1/channel/categories
{
"attributeList": [
{
"attributeId": "DEMO-TYPES_smalltext",
"displayName": "Smalltext",
"type": "smalltext"
},
{
"attributeId": "DEMO-TYPES_text",
"displayName": "Text",
"type": "text"
},
{
"attributeId": "DEMO-TYPES_integer",
"displayName": "Integer",
"type": "integer"
},
{
"attributeId": "DEMO-TYPES_decimal",
"displayName": "Decimal",
"type": "decimal"
},
{
"attributeId": "DEMO-TYPES_boolean",
"displayName": "Boolean",
"type": "boolean"
},
{
"attributeId": "DEMO-TYPES_enum",
"displayName": "Enum",
"type": "enum",
"values": [
{ "display": "Value 1", "value": "Id1", "sort": 10 },
{ "display": "Value 2", "value": "Id2", "sort": 20 },
{ "value": "This has no Display" }
]
},
{
"attributeId": "DEMO-TYPES_htmltext",
"displayName": "Html-text",
"type": "htmltext"
},
{
"attributeId": "DEMO-TYPES_date",
"displayName": "Date",
"type": "date"
},
{
"attributeId": "DEMO-TYPES_image",
"displayName": "Image",
"description": "Link to Image file",
"type": "image"
},
{
"attributeId": "DEMO-TYPES_document",
"displayName": "Document",
"description": "Link to a Document file",
"type": "document"
}
]
}
```
#### Using Sections and Sub-sections
You can organize attributes into logical groups using sections and sub-sections:
```json theme={null}
// POST /v1/channel/attribute/category/DEMO-SECTIONS
// DEMO-SECTIONS is a categoryId created earlier via PUT /v1/channel/categories
{
"attributeList": [
{
"attributeId": "DEMO-SECTIONS_WAREHOUS",
"displayName": "Warehouse",
"type": "smalltext",
"section": "Shipping",
"sectionPosition": 100
},
{
"attributeId": "DEMO-SECTIONS_SHIPPING",
"displayName": "Shipping Group",
"type": "smalltext",
"section": "Shipping",
"sectionPosition": 80
},
{
"attributeId": "DEMO-SECTIONS_LEADTIME",
"displayName": "Lead time until shipment",
"type": "integer",
"section": "Shipping",
"sectionPosition": 50
},
{
"attributeId": "DEMO-SECTIONS_OFFER_START",
"displayName": "Start",
"type": "date",
"section": "Discount",
"sectionPosition": 50
},
{
"attributeId": "DEMO-SECTIONS_OFFER_DISCOUNT",
"displayName": "Discount Value",
"type": "decimal",
"section": "Discount",
"sectionPosition": 100,
"subSection": "Deduction",
"subSectionPosition": 100
},
{
"attributeId": "DEMO-SECTIONS_OFFER_DISCOUNT_UNIT",
"displayName": "Discount Unit",
"type": "enum",
"values": [
{ "value": "%" },
{ "value": "EUR" }
],
"section": "Discount",
"sectionPosition": 100,
"subSection": "Deduction",
"subSectionPosition": 90
}
]
}
```
#### Multiple-value Attributes
It is possible to create repeatable attributes if the attribute supports multiple values:
```json theme={null}
// POST /v1/channel/attribute/category/DEMO-MULTIPLY_ALLOWED
// DEMO-MULTIPLY_ALLOWED is a categoryId created earlier via PUT /v1/channel/categories
{
"attributeList": [
{
"attributeId": "DEMO-TYPES_isMultipleAllowed",
"displayName": "Attribute is Multiple Allowed",
"isMultipleAllowed": true,
"type": "smalltext"
}
]
}
```
#### Repeatable Sub-sections
You can also create repeatable sub-sections for grouped attribute sets:
```json theme={null}
// POST /v1/channel/attribute/category/DEMO-REPEATABLE_SUBSECTIONS
// DEMO-REPEATABLE_SUBSECTIONS is a categoryId created earlier via PUT /v1/channel/categories
{
"attributeList": [
{
"attributeId": "shipping_carrier",
"displayName": "Versanddienstleister",
"type": "enum",
"values": [
{ "value": "carrierID_2", "display": "Brief", "sort": 1 },
{ "value": "carrierID_3", "display": "DHL Paeckchen", "sort": 2 },
{ "value": "carrierID_4", "display": "DHL Paket", "sort": 3 },
{ "value": "carrierID_22", "display": "Kostenloser Download", "sort": 20 }
],
"section": "Versandkosten",
"sectionPosition": 2,
"subSection": "Versandart",
"subSectionPosition": 10,
"isRepeatableSubSection": true
},
{
"attributeId": "shipping_cost_nat",
"displayName": "National",
"type": "decimal",
"section": "Versandkosten",
"sectionPosition": 2,
"subSection": "Versandart",
"subSectionPosition": 9,
"isRepeatableSubSection": true
},
{
"attributeId": "shipping_cost_eu",
"displayName": "EU",
"type": "decimal",
"section": "Versandkosten",
"sectionPosition": 2,
"subSection": "Versandart",
"subSectionPosition": 8,
"isRepeatableSubSection": true
},
{
"attributeId": "shipping_cost_int",
"displayName": "International",
"type": "decimal",
"section": "Versandkosten",
"sectionPosition": 2,
"subSection": "Versandart",
"subSectionPosition": 7,
"isRepeatableSubSection": true
}
]
}
```
When using repeatable sections, JTL-Wawi generates a group ID which is then transferred back to the channel with the
listing. This makes it possible to recognize related attributes in the listing data:
```json theme={null}
// GET /v1/channel/event: Offer with repeatable sub-sections
{
"type": "Seller:Offer.New",
"sellerId": "1",
"offerId": 1,
"channelCategoryId": "DEMO-REPEATABLE_SUBSECTIONS",
"channelAttributeList": [
{ "attributeId": "shipping_carrier", "value": "DHL Paket", "group": "1" },
{ "attributeId": "shipping_cost_nat", "value": "2.99", "group": "1" },
{ "attributeId": "shipping_cost_eu", "value": "2.99", "group": "1" },
{ "attributeId": "shipping_cost_int", "value": "9.99", "group": "1" },
{ "attributeId": "shipping_carrier", "value": "Brief", "group": "2" },
{ "attributeId": "shipping_cost_nat", "value": "1.20", "group": "2" },
{ "attributeId": "shipping_cost_eu", "value": "2.40", "group": "2" },
{ "attributeId": "shipping_cost_int", "value": "2.40", "group": "2" }
]
}
```
## Media Content Handling
The SCX system **emits** seller events containing media file links; channels **receive** these events but do **not** generate them.
### Media Fields in Events and Attributes
Media reaches a channel through event payload fields and through channel-defined attributes.
* Events provided by SCX include `pictureList` and `mainPicture` in both `Seller:Offer.New` and `Seller:Offer.Update` payloads.
These fields are URLs to image files.
* Any channel-specific attribute defined as type `image` or `document` also appears as a URL to the corresponding file.
### Defining Media Attributes
Channels can register attributes of type `image` or `document`:
```json theme={null}
// PUT /v1/channel/attribute/global
{
"attributeList": [
{
"attributeId": "DEMO-TYPES_image",
"displayName": "Image",
"description": "Link to Image file",
"type": "image"
},
{
"attributeId": "DEMO-TYPES_document",
"displayName": "Document",
"description": "Link to a Document file",
"type": "document"
}
]
}
```
### File URL Structure
All media links are hosted on S3-compatible storage and follow this pattern:
```
https://s3.api.jtl-software.com/scx-api/public/{media-hash}.{ext}
```
Where:
* `{media-hash}` is the SHA-1 hash of the file contents.
* `{ext}` is the file extension (`gif`, `jpg`, `png`, `svg`, or `pdf`).
### Media URL Lifetime
Media links expire, so plan for retrieval within a fixed window.
Media URLs remain valid for **7 days** after event generation. After this period, requests may return HTTP 404 or 403.
If your marketplace integration requires access beyond 7 days, you **must** proactively fetch and store or rehost the file.
### Supported Formats and Size Limits
The Channel API accepts the following media MIME types and extensions.
| MIME Type | Extension |
| ----------------- | --------- |
| `image/gif` | `gif` |
| `image/jpeg` | `jpg` |
| `image/pjpeg` | `jpg` |
| `image/png` | `png` |
| `image/x-png` | `png` |
| `image/svg+xml` | `svg` |
| `application/pdf` | `pdf` |
Maximum file size is **16 MB** per media file. Files that do not match these MIME types or exceed the size limit may be rejected.
### Example: `Seller:Offer.New` Event with Media
The following payload shows how media URLs appear in an offer event.
```json theme={null}
{
"type": "Seller:Offer.New",
"sellerId": "MYSELLERID",
"offerId": 1,
"mainPicture": "https://s3.api.jtl-software.com/scx-api/public/ca953...872.jpg",
"pictureList": [
"https://s3.api.jtl-software.com/scx-api/public/ff5a3...4c3.jpg",
"https://s3.api.jtl-software.com/scx-api/public/11aa2...p77.png"
],
"channelAttributeList": [
{
"attributeId": "thumbnailImage",
"value": "https://s3.api.jtl-software.com/scx-api/public/aabbc...899.pdf"
}
]
}
```
***
## What's Next?
Learn how to synchronize product and offer listings with marketplace channels.
Handle orders, cancellations, returns, and refunds across channels.
Seller sign-up, update, and unlink flows.
Refresh tokens, access tokens, and Bearer headers for all SCX APIs.
Full endpoint reference for the Channel API.
Ready-made requests for the Channel and Seller APIs.
# Order Management
Source: https://developer.jtl-software.com/guides/marketplace-channels/order-management
Handle orders across marketplace channels: creation, status updates, cancellations, returns, and refunds.
This guide covers the full order lifecycle in SCX: creating orders, managing status transitions, handling cancellations from both sides, processing returns, and issuing refunds.
## Order Lifecycle
An order moves from creation through acceptance, shipping, and any post-order handling such as returns or refunds.
```mermaid theme={null}
stateDiagram-v2
[*] --> CREATED: Channel creates order
[*] --> UNACKED: Channel creates order (requires ack)
UNACKED --> ACCEPTED: Seller acknowledges
CREATED --> ACCEPTED: Address provided
state ACCEPTED {
[*] --> UNSHIPPED
UNSHIPPED --> SHIPPED: Seller ships
UNSHIPPED --> CANCELED_BY_SELLER: Seller cancels
UNSHIPPED --> CANCELED_BY_BUYER: Buyer cancels
SHIPPED --> RETURNED: Buyer returns
SHIPPED --> CANCELED_BY_SELLER: Seller cancels
SHIPPED --> CANCELED_BY_BUYER: Buyer cancels
RETURNED --> REFUNDED: Seller refunds
}
```
## Order Process
Orders are processed in four stages: create the order, provide address information (if required), accept the order, and update individual line items as fulfillment progresses.
A new order must be created by calling `POST /v1/channel/order` first.
If the order was created with status `CREATED` or `UNACKED`, send address data via `PUT /v1/channel/order/address-update` before transitioning to `ACCEPTED`.
Update the order status to `ACCEPTED` using `PUT /v1/channel/order/status`. The order is now ready for shipping.
Update individual order item statuses (shipped, cancelled, returned, refunded) via `PUT /v1/channel/order/status`.
### Order Constraints
* An order's purchase date must be later than the seller's creation date.
* An `orderId` must be be unique for each seller.
* Order line items cannot be added, removed, or modified after the order has been created.
## Order Status
An order carries one of the following statuses.
| Status | Description |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `CREATED` | The order is not yet ready for shipping. Can be used for stock reservation. Once ready for shipping, the status changes to `ACCEPTED`. |
| `UNACKED` | The order is not yet ready for shipping. The seller must first accept the order. **Note:** JTL-Wawi does not yet support order acknowledgment. |
| `ACCEPTED` | The order is ready for shipping. |
## Order Line Item Status
Each order line item has a status that should be used to determine the overall order status:
| Status | Description |
| -------------------- | ----------------------------------------------------------- |
| `UNSHIPPED` | Ready for shipping; can be shipped once order is `ACCEPTED` |
| `SHIPPED` | Marked as having been shipped |
| `CANCELED_BY_SELLER` | Cancelled by the seller |
| `CANCELED_BY_BUYER` | Cancelled by the buyer or the marketplace |
| `RETURNED` | Returned to the seller |
| `REFUNDED` | Refunded |
## State Transition Rules
The following rules govern when an order can change status.
* Orders with status `UNACKED` or `CREATED` may not have valid address information.
* An address update can only apply to orders with status `UNACKED` or `CREATED`.
* Address information must be available before a status transition to `ACCEPTED`.
* Once an order is assigned status `ACCEPTED`, the order status cannot be changed.
### Order Item Status Transition Matrix
The table below shows which transitions between order item statuses are allowed:
| From / To | UNSHIPPED | SHIPPED | CANCELED\_BY\_SELLER | CANCELED\_BY\_BUYER | RETURNED | REFUNDED |
| -------------------- | --------- | ------- | -------------------- | ------------------- | -------- | -------- |
| UNSHIPPED | yes | yes | yes | yes | yes | yes |
| SHIPPED | - | yes | yes | yes | yes | yes |
| CANCELED\_BY\_SELLER | - | - | yes | - | - | - |
| CANCELED\_BY\_BUYER | - | - | - | yes | - | - |
| RETURNED | - | - | - | - | yes | yes |
| REFUNDED | - | - | - | - | - | yes |
```mermaid theme={null}
flowchart LR
U[UNSHIPPED] --> S[SHIPPED]
S --> RT[RETURNED]
RT --> RF[REFUNDED]
style U fill:#FFF2EB,stroke:#FB581F,color:#0B1B45
style S fill:#FFF2EB,stroke:#FB581F,color:#0B1B45
style RT fill:#E8F4FF,stroke:#89D2FF,color:#0B1B45
style RF fill:#EEEEE7,stroke:#0B1B45,color:#0B1B45
```
This is the normal lifecycle. From `UNSHIPPED` or `SHIPPED`, an item can also jump directly to `CANCELED_BY_SELLER`, `CANCELED_BY_BUYER`, or `REFUNDED`; from `UNSHIPPED` it can additionally go straight to `RETURNED`.
## Tax Handling
The `orderItem[].taxPercent` field controls how VAT is applied to each order line item in JTL-Wawi. The field is optional and accepts a stringified numeric value (e.g. `"20"`, `"7"`). See the [Channel API Reference](/api-reference/scx/channel) for the full order payload schema.
### When `orderItem[].taxPercent` is provided
JTL-Wawi uses the value directly as the tax rate for that line item. This gives the channel full control over the applied VAT, for example setting `"20"` for a French buyer or `"21"` for a Spanish buyer.
### When `orderItem[].taxPercent` is omitted
JTL-Wawi calculates the tax rate itself based on:
* The **tax class** of the matched article in JTL-Wawi
* The **tax zone configuration** of the seller's JTL-Wawi instance (shipping country, tax rules, etc.)
The resulting tax rate depends entirely on the individual seller's JTL-Wawi setup. If the seller has configured tax zones correctly for international shipments (e.g. France 20%, Spain 21%), JTL-Wawi can apply the appropriate country-specific rate. Otherwise the seller's default domestic rate applies (e.g. 19% / 7% for Germany), depending on their configuration.
For unmatched line items (i.e. the SKU does not match any article in JTL-Wawi), the ERP default tax rate applies.
## Examples
The following examples walk through an order from creation to line-item status update.
### Create a `CREATED` Order
This request creates an order with status `CREATED` and two line items plus shipping.
```json theme={null}
// POST /v1/channel/order
{
"orderList": [
{
"sellerId": "1",
"orderStatus": "CREATED",
"orderId": "OrderId_000001",
"purchasedAt": "2020-02-25T15:05:20+00:00",
"lastChangedAt": "2020-02-25T15:05:20+00:00",
"currency": "EUR",
"orderItem": [
{
"orderItemId": "SHIPPING-0001",
"type": "SHIPPING",
"grossPrice": "2.00",
"taxPercent": "19",
"quantity": "1.0",
"shippingGroup": "test"
},
{
"orderItemId": "ABC-0001",
"type": "ITEM",
"grossPrice": "19.99",
"total": "19.99",
"taxPercent": "19",
"sku": "1234",
"channelOfferId": "1",
"quantity": "1",
"title": "Eine Hose (4006680069951)",
"note": "Zur Auswahl"
},
{
"orderItemId": "ABC-0002",
"type": "ITEM",
"grossPrice": "19.99",
"total": "19.99",
"taxPercent": "19",
"sku": "ART-WAWI-55070",
"channelOfferId": "2",
"quantity": 1,
"title": "Ein Hemd (ART-WAWI-55070)",
"note": "Zur Auswahl"
}
]
}
]
}
```
### Send Address Information
Send address information for an order with status `CREATED`:
```json theme={null}
// PUT /v1/channel/order/address-update
{
"orderList": [
{
"orderId": "OrderId_000001",
"sellerId": "1",
"billingAddress": {
"firstName": "Arno",
"lastName": "Nym",
"gender": "male",
"street": "Am Feld",
"houseNumber": "16",
"postcode": "123456",
"city": "Dingenskirschen",
"country": "DE"
},
"shippingAddress": {
"firstName": "Arno",
"lastName": "Nym",
"gender": "male",
"street": "Am Feld",
"houseNumber": "16",
"postcode": "123456",
"city": "Dingenskirschen",
"country": "DE"
}
}
]
}
```
### Update Order Status to `ACCEPTED`
This request transitions the order to `ACCEPTED`, making it ready for shipping.
```json theme={null}
// PUT /v1/channel/order/status
{
"orderList": [
{
"orderId": "OrderId_000001",
"sellerId": "1",
"orderStatus": "ACCEPTED"
}
]
}
```
### Update Order Line Item Status
This request marks individual line items as shipped and paid.
```json theme={null}
// PUT /v1/channel/order/status
{
"orderList": [
{
"orderId": "OrderId_000001",
"sellerId": "1",
"orderStatus": "ACCEPTED",
"orderItems": [
{
"orderItemId": "ABC-0001",
"itemStatus": "SHIPPED",
"paymentStatus": "PAID"
},
{
"orderItemId": "ABC-0002",
"itemStatus": "SHIPPED",
"paymentStatus": "PAID"
}
]
}
]
}
```
## Cancellation
Cancellations can originate from the seller or from the buyer, and each path follows its own flow.
Sellers send a cancellation request with a `CancellationRequestId` which JTL-Wawi uses to assign the response later.
* The `CancellationRequestId` provides unique assignment of the data (OrderId / OrderItemIDs) to the client.
* A cancellation should always include all items to be cancelled. If the entire order is cancelled, all order items must be specified. For partial cancellation, only the cancelled items need to be specified.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
Seller->>SCX: Seller:Order.CancellationRequest event
SCX->>Channel: Event includes CancellationRequestId + items
Channel->>Channel: Process cancellation on marketplace
Channel->>SCX: Update order item status to CANCELED_BY_SELLER
```
Buyers or marketplaces send a cancellation request with a `CancellationRequestId`.
* The `CancellationRequestId` provides unique assignment of the data (OrderId / OrderItemIDs) to the channel.
* A cancellation should always include all items to be cancelled. Partial order cancellations are supported.
Using the buyer cancellation workflow on the channel side is optional. You can simply set the order status to `CANCELED_BY_BUYER` instead.
```mermaid theme={null}
sequenceDiagram
participant Buyer
participant Channel as Channel Integration
participant SCX as SCX Platform
participant Seller as Seller (JTL-Wawi)
Buyer->>Channel: Requests cancellation
Channel->>SCX: Channel:Order.CancellationRequest event
SCX->>Seller: CancellationRequest with CancellationRequestId
alt Seller accepts
Seller->>SCX: CancellationAccepted event
SCX->>Channel: Event delivered
Channel->>Channel: Update items to CANCELED_BY_BUYER
else Seller denies
Seller->>SCX: CancellationDenied event
SCX->>Channel: Event delivered
end
```
**Buyer-initiated cancellation flow**
## Returns
A return can be announced by the channel, processed with or without a return shipment, and confirmed back to the seller.
```mermaid theme={null}
sequenceDiagram
participant Buyer
participant Channel as Channel Integration
participant SCX as SCX Platform
participant Seller as Seller (JTL-Wawi)
Buyer->>Channel: Initiates return
Channel->>SCX: Channel:Order.Return event
SCX->>Seller: Return announcement
alt No return shipping required
Seller->>SCX: POST /v1/seller/order/return (requireReturnShipping=false)
else Return shipping required
Note over Seller: Wait for return shipment
Buyer->>Seller: Ships items back
Seller->>Seller: Inspect returned items
Seller->>SCX: POST /v1/seller/order/return (with item details)
end
SCX->>Channel: Seller:Order.ReturnProcessingResult event
```
### Channel Informs About Upcoming Return
The `Channel:Order.Return` event notifies SCX that a return has been initiated on the connected marketplace.
This event is optional. Not all marketplaces support return announcements.
The event carries the following data:
* **Required data:** OrderId, OrderItem List (ItemId, Quantity, Reason, Comment)
* **Optional data:** ChannelReturnId (internal ID to identify the return case), Return Tracking Information (Carrier, TrackingNo.)
JTL-Wawi stores the upcoming return case:
* If no item return is required, the return can be answered directly via `POST /v1/seller/order/return`.
* If a return is required, the seller waits for the incoming return.
### Merchant Decides No Return Is Required (Optional)
The seller can decide whether the customer needs to make a return. If no return is required,
`POST /v1/seller/order/return` can be sent after receiving the `Channel:Order.Return` event
with the `requireReturnShipping` property set to `false`.
### Return Shipment Arrives
Once the return has arrived, the seller checks the items and confirms the return using `POST /v1/seller/order/return`.
If a return already exists in JTL-Wawi, the stored information (including the `channelReturnId`) should be used.
The following information about individual order items must be transferred:
| Field | Required | Description |
| -------------- | -------- | ------------------------------ |
| `orderId` | Yes | The order number |
| `quantity` | Yes | The quantity that was returned |
| `acceptReturn` | Yes | Whether the return is accepted |
| `condition` | Yes | Condition of the returned item |
| `reason` | No | Reason for the return |
| `note` | No | Additional note |
## Refunds
Refunds are initiated directly by the seller, for example after a return has been processed or following an agreement with the
buyer (via ticket/email/phone). The channel processes the refund and sends a `Channel:Order.RefundProcessingResult`
event back to the seller to confirm whether the refund was processed successfully or failed.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
Seller->>SCX: Seller:Order.Refund event
SCX->>Channel: Refund request with item details
Channel->>Channel: Process refund on marketplace
alt Refund successful
Channel->>SCX: Channel:Order.RefundProcessingResult (success)
else Refund failed
Channel->>SCX: Channel:Order.RefundProcessingResult (failed)
end
SCX->>Seller: RefundProcessingResult event
```
***
## What's Next?
Learn how listing and stock synchronization works.
Seller sign-up, update, and unlink flows.
Per-endpoint quotas and 429 handling.
Events, metadata, and media content handling.
Full endpoint reference for the Channel API.
# Platform Channels
Source: https://developer.jtl-software.com/guides/marketplace-channels/platform-channels
Multi-marketplace architectures with shared seller sign-up, multi-currency, and multi-language support.
This guide explains how platform channels group multiple marketplace channels under a single seller
sign-up flow in SCX.
## Why Platform Channels?
Some marketplaces operate across multiple geographic regions. Each region has its own language, currency,
and regulatory requirements. For example, a marketplace may operate in Germany (EUR, German), the UK (GBP, English),
and Spain (EUR, Spanish).
Without platform channels, each region would be a separate channel with its own sign-up flow. The seller
would need to sign up multiple times, once for each region.
Platform channels solve this:
* **One sign-up for the seller.** The seller sees only the platform channel in JTL-Wawi and signs up once.
Marketplace channels are invisible to the seller.
* **Multi-currency support.** Each marketplace channel defines its own currency.
* **Multi-language support.** Each marketplace channel represents a specific geographic region with its own
language context.
* **Centralized URL management.** The sign-up and update URLs live on the platform and are inherited by all
marketplace channels automatically.
* **Automatic marketplace assignment.** The channel integration creates or deactivates sellers on marketplace
channels without requiring additional sign-up sessions from the seller.
* **Shared inventory management.** Stock sync groups prevent duplicate stock updates across marketplace
channels that share the same warehouse.
## Terminology
Platform channels introduce a small set of terms used throughout this guide.
| Term | Definition |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Platform Channel** | A virtual channel that acts as an umbrella for one or more marketplace channels. It owns the sign-up and update URLs and is the only channel visible to the seller in JTL-Wawi. It cannot be accessed via the Channel API. Example: "Amazon". |
| **Marketplace Channel** | A channel that belongs to a platform. It inherits URLs from its parent and represents a specific geographic marketplace. Invisible to the seller. Example: "Amazon DE". |
| **marketplaceChannelList** | A property on the platform channel's public channel list response. It contains identifiers and metadata (including `stockSyncGroup`) for each marketplace channel that belongs to the platform. |
| **stockSyncGroup** | A label grouping marketplace channels that share inventory. Within a group, JTL-Wawi sends stock updates to only one channel. |
## Architecture
A platform channel is the entry point for seller sign-up. Each marketplace channel beneath it represents
a specific region or variant.
```mermaid theme={null}
graph TD
P["Platform Channel (e.g. Amazon)"]
P -->|"owns"| URL["signUpUrl / updateUrl"]
P -->|"parent of"| MC1["Marketplace Channel DE (EUR, German)"]
P -->|"parent of"| MC2["Marketplace Channel UK (GBP, English)"]
P -->|"parent of"| MC3["Marketplace Channel ES (EUR, Spanish)"]
MC1 -.->|"inherits URLs"| URL
MC2 -.->|"inherits URLs"| URL
MC3 -.->|"inherits URLs"| URL
```
The architecture has the following key characteristics:
* The platform channel holds the single source of truth for `signUpUrl` and `updateUrl`.
* When the platform's URLs change, all marketplace channels are updated automatically.
* Marketplace channels cannot override their own URLs.
* Only the platform channel appears in the public channel list (`GET /v1/public/channel`).
Marketplace channels are filtered out and invisible to the seller.
A platform channel is **virtual**. It cannot be accessed via the Channel API: no access token can be
created for it, and it does not receive or emit events. It exists purely as an organizational umbrella
that groups marketplace channels and owns the sign-up and update URLs.
## Seller Sign-up Flow
The seller sees only the platform channel in JTL-Wawi. They sign up once, and the channel integration
handles marketplace channel assignment.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
Seller->>SCX: POST /v1/seller/channel/amazon (initiate sign-up)
SCX-->>Seller: Returns platform signUpUrl + sessionId
Seller->>Channel: Opens signUpUrl in browser
Channel->>Channel: Authenticate seller and select marketplaces
Channel->>SCX: POST /v1/channel/seller (sessionId + sellerId)
SCX-->>Channel: Seller created on platform
Channel->>SCX: POST /v1/channel/seller/platform/{jtlAccountId}
Note over SCX: Seller assigned to marketplace channels
SCX-->>Channel: Seller active on amazon-de, amazon-uk
```
The flow proceeds through four steps.
In JTL-Wawi, the seller selects the platform channel (e.g. "Amazon") from the available channel list
and starts a sign-up session. SCX returns the platform's `signUpUrl` with a one-time session ID.
The seller is redirected to the platform's sign-up page (hosted by the channel integration). The
channel integration authenticates the seller and determines which marketplace regions the seller
should be connected to.
The channel integration reports the seller ID and session ID back to SCX via
`POST /v1/channel/seller`. This completes the platform-level sign-up.
The channel integration calls `POST /v1/channel/seller/platform/{jtlAccountId}` to activate
the seller on specific marketplace channels. No additional sign-up session is required.
Direct seller sign-up on a marketplace channel is not allowed. SCX rejects the request when a seller
attempts to create a sign-up session for a marketplace channel (HTTP 403, error code `SLR204`).
Sellers must always sign up using the parent platform.
## Managing Sellers on Marketplace Channels
After the initial sign-up, the channel integration manages which marketplace channels a seller is
active on. This happens without any seller interaction.
### Creating a Seller on a Marketplace Channel
Use `POST /v1/channel/seller/platform/{jtlAccountId}` to assign an existing platform seller to a
marketplace channel. This endpoint requires Channel API authentication (Bearer token).
```json theme={null}
// POST /v1/channel/seller/platform/{jtlAccountId}
// Content-Type: application/json
// Authorization: Bearer
{
"sellerId": "SELLER-123",
"channel": "amazon-de",
"isActive": true
}
```
The seller must already exist on the platform or on another marketplace channel of the same platform.
### Deactivating a Seller on a Marketplace Channel
The channel integration can deactivate a seller on a specific marketplace channel without affecting
other marketplace channels or the platform-level connection:
```json theme={null}
// POST /v1/channel/seller/platform/{jtlAccountId}
{
"sellerId": "SELLER-123",
"channel": "amazon-de",
"isActive": false
}
```
The channel integration decides which marketplace channels a seller is active on. SCX does not
dictate marketplace channel assignment.
## URL Inheritance
The platform channel owns the `signUpUrl` and `updateUrl`. All marketplace channels inherit these URLs
automatically.
* When the platform's URLs are updated, all marketplace channels receive the new URLs.
* Marketplace channels cannot set their own URLs independently.
* If no `updateUrl` is provided on the platform, the `signUpUrl` is used as fallback for both.
## Stock Sync Groups
Stock sync groups control how JTL-Wawi distributes inventory updates across marketplace channels that
share the same stock.
### Why Stock Sync Groups?
Marketplaces that belong to the same platform often share inventory. For example, Amazon DE, Amazon FR,
and Amazon ES all draw from the same European warehouse. The stock level is the same across all three
marketplaces. The marketplace synchronizes inventory internally.
Without stock sync groups, JTL-Wawi would send a separate stock update to each marketplace channel.
This creates unnecessary load and duplicate updates for stock that is already shared on the marketplace side.
### How it Works
A `stockSyncGroup` is a label assigned to marketplace channels that share inventory. Within a group,
JTL-Wawi sends the stock update for a given SKU to **only one** marketplace channel. The marketplace
handles internal synchronization across the other channels in the group.
### Rules
These constraints govern how `stockSyncGroup` behaves:
* Only marketplace channels can have a `stockSyncGroup` (channels with a `platform` reference).
* Platform channels and standalone channels must have `stockSyncGroup: null`.
* All marketplace channels with the same `stockSyncGroup` value are treated as one inventory pool.
* The platform channel's response in the public channel list (`GET /v1/public/channel`) includes the
`marketplaceChannelList` property, which contains each marketplace channel's `stockSyncGroup`. This
is how JTL-Wawi discovers the grouping and sends stock accordingly.
* Setting `stockSyncGroup` to `null` removes the channel from its group — stock updates resume
individually for that channel.
### Example
This configuration shows a platform with two separate inventory pools.
| Channel | Type | stockSyncGroup | Receives stock updates? |
| --------- | ----------- | -------------- | -------------------------------------------------- |
| amazon | Platform | `null` | No (virtual channel) |
| amazon-de | Marketplace | `"AMAZON-EU"` | Yes (Wawi sends to one active seller in the group) |
| amazon-fr | Marketplace | `"AMAZON-EU"` | No (synced by marketplace) |
| amazon-es | Marketplace | `"AMAZON-EU"` | No (synced by marketplace) |
| amazon-us | Marketplace | `"AMAZON-US"` | Yes (separate group) |
In this setup, Wawi sends one stock update per SKU to any single channel in the `"AMAZON-EU"` group
(e.g. amazon-de). Amazon synchronizes stock across DE, FR, and ES internally. The US marketplace belongs
to a separate group and receives its own stock updates.
Use the same `stockSyncGroup` value for all marketplace channels that share the same warehouse or
inventory pool on the marketplace side. Use different values for regions with independent stock
(e.g. EU vs US).
## Business Rules and Constraints
The following rules govern platform and marketplace channel behavior:
* Platform channels are virtual: no API access token, no events, no authentication.
* Seller sign-up on a marketplace channel is forbidden (`SLR204`). Sellers must sign up via the platform.
* A platform cannot be converted to a regular channel while `marketplaceChannelList` is non-empty.
* Marketplace channels cannot set their own sign-up or update URLs. These are always inherited from the platform.
* A channel cannot be both a platform and belong to a platform simultaneously.
* The referenced platform must exist when creating a marketplace channel.
* `stockSyncGroup` can only be set on marketplace channels. Platform and standalone channels must have `null`.
***
## What's Next?
Regular seller sign-up, update, and unlink flows.
Events, metadata, and media content handling.
Refresh tokens, access tokens, and Bearer headers.
Full endpoint reference for the Channel API.
# Product Sync
Source: https://developer.jtl-software.com/guides/marketplace-channels/product-sync
Synchronize product and offer listings between JTL and marketplace channels via the Channel API
This guide covers how product and offer listings flow from JTL-Wawi to your channel, how to report listing status back to sellers, and how to keep stock levels synchronized.
## Listing Sync Flow
Listings are transmitted by the `Seller:Offer.New` and `Seller:Offer.Update` events.
Each time listing data changes, JTL-Wawi transmits the entire listing again.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
participant MP as Marketplace
Seller->>SCX: Creates/updates listing
SCX->>SCX: Emits Seller:Offer.New or Seller:Offer.Update event
Channel->>SCX: GET /v1/channel/event
SCX-->>Channel: Returns offer event with full listing data
Channel->>SCX: DELETE /v1/channel/event (acknowledge)
Channel->>MP: Submit listing to marketplace
alt Listing accepted
MP-->>Channel: Listing live
Channel->>SCX: POST /v1/channel/offer/listed
else Listing rejected
MP-->>Channel: Validation error
Channel->>SCX: POST /v1/channel/offer/listing-failed
end
```
## Essential Properties
It is generally not necessary to provide attributes for essential data, as each listing already implements a set of
essential properties by default, including title, description, GTIN, quantity, and price.
## Pictures and Images
Product or listing images are transmitted as a link along with the listing event.
Image links have a lifetime of **7 days** after the listing event was triggered. Make sure to download and store images
if you need them beyond that period.
The filename is generated based on the file content, so each separate image will have a unique filename derived from its content.
## Listing State
We recommend informing the seller about the processing status of their listings. Most marketplaces use an
asynchronous listing process during which the listing data is curated in a semi-automated process that may take some time.
```mermaid theme={null}
stateDiagram-v2
[*] --> InProgress: Offer event received
InProgress --> Listed: Listing successful
InProgress --> Failed: Listing rejected
Failed --> InProgress: Seller resubmits offer
Listed --> InProgress: Seller updates offer
```
The three states are reported through their own endpoints.
Send this state to inform the seller that the listing process is now in progress:
```json theme={null}
// POST /v1/channel/offer/in-progress
{
"offerList": [
{
"offerId": 1,
"sellerId": "1",
"startedAt": "2022-11-28T01:00:13+00"
}
]
}
```
Inform the seller once a listing is successfully listed on the connected marketplace.
The optional `listingUrl` allows the seller to visit and directly check the listing.
```json theme={null}
// POST /v1/channel/offer/listed
{
"offerList": [
{
"sellerId": "1",
"offerId": 1,
"listedAt": "2022-11-28T01:00:13+00",
"listingUrl": "https://marketplace.de/offer1",
"channelOfferId": "AFGHDHDFH"
}
]
}
```
You need to inform the seller if the listing process for a listing failed:
```json theme={null}
// POST /v1/channel/offer/listing-failed
{
"offerList": [
{
"sellerId": "1",
"offerId": 1,
"errorList": [
{
"code": "123",
"message": "A listing error occurred",
"longMessage": "A serious listing error occurred."
}
],
"failedAt": "2019-02-09T05:33:12+00:00"
}
]
}
```
## Stock Updates
The Stock Updates API enables channels to keep their inventory synchronized with seller stock levels.
### Available Methods
There are multiple ways to synchronize stock:
| Method | Endpoint | Use Case |
| --------------- | ----------------------------------------- | ---------------------------------------------------------- |
| **Per-seller** | `GET /v1/channel/offer/stock-updates` | Parallel per-seller processing. Higher rate limit. |
| **All sellers** | `GET /v1/channel/offer/stock-updates/all` | Get stock changes for all active sellers in a single call. |
| **Event-based** | `Seller:Offer.StockUpdate` event | Consuming the seller event directly. |
Use the stock update endpoints rather than the `Seller:Offer.StockUpdate` event. The event remains available, but the
dedicated endpoints are the supported path for stock synchronization.
### Example Request and Response
The following request retrieves stock changes for all active sellers since a given timestamp.
```json theme={null}
// GET /v1/channel/offer/stock-updates/all?updatedAfter=2025-12-29T00:00:00+00:00
{
"stockUpdateList": [
{
"channel": "MYCHANNEL",
"sellerId": "SELLER001",
"offerId": 4711,
"channelOfferId": "SKU-WIDGET-001",
"quantity": 25,
"updatedAt": "2025-12-29T10:15:30+00:00"
},
{
"channel": "MYCHANNEL",
"sellerId": "SELLER002",
"offerId": 8822,
"channelOfferId": "SKU-GADGET-042",
"quantity": 0,
"updatedAt": "2025-12-29T11:22:45+00:00"
}
],
"lastUpdatedAt": "2025-12-29T11:22:45+00:00"
}
```
### Incremental Sync Pattern
Use the `lastUpdatedAt` cursor from each response to fetch only the changes since your last call.
For efficient synchronization, use the `lastUpdatedAt` value from the response as the `updatedAfter` parameter in your next request.
```mermaid theme={null}
sequenceDiagram
participant Channel as Channel Integration
participant SCX as SCX Platform
Channel->>SCX: GET /stock-updates/all?updatedAfter=2025-12-01T00:00:00Z
SCX-->>Channel: stockUpdateList + lastUpdatedAt=2025-12-29T11:22:45Z
Note over Channel: Wait for next sync interval
Channel->>SCX: GET /stock-updates/all?updatedAfter=2025-12-29T11:22:45Z
SCX-->>Channel: stockUpdateList + lastUpdatedAt=2025-12-29T14:30:00Z
Note over Channel: Continue with cursor-based polling...
```
```text theme={null}
1. First call: GET /v1/channel/offer/stock-updates/all?updatedAfter=2025-12-01T00:00:00Z
Response: lastUpdatedAt = "2025-12-29T11:22:45+00:00"
2. Next call: GET /v1/channel/offer/stock-updates/all?updatedAfter=2025-12-29T11:22:45+00:00
Response: lastUpdatedAt = "2025-12-29T14:30:00+00:00"
3. Continue...
```
***
## What's Next?
Handle orders, cancellations, returns, and refunds.
Review events, metadata, and media content handling.
Seller sign-up, update, and unlink flows.
Per-endpoint quotas and 429 handling.
Endpoint-level reference for the Channel API.
Try the API with ready-made requests.
# Rate Limits
Source: https://developer.jtl-software.com/guides/marketplace-channels/rate-limits
Per-endpoint quotas, rate-limit response headers, and 429 handling across the SCX APIs.
The SCX APIs enforce per-endpoint rate limits. Each limit defines the maximum number of requests allowed within a time window. Exceeding a limit returns `HTTP 429 Too Many Requests`.
Rate limits are applied by endpoint group rather than uniformly across all SCX APIs. High-volume operations such as offer and order updates have higher limits, while administrative operations such as category and attribute management have stricter limits.
## Response Headers
SCX API responses include the following headers so you can monitor your current rate limit usage:
| Header | Description |
| ------------------------------------- | ----------------------------------------------------------- |
| `X-RateLimit-Limit` | The total number of requests allowed in the current window. |
| `X-RateLimit-Interval-Length-Seconds` | The window length in seconds. |
| `X-RateLimit-Remaining` | Requests remaining in the current window. |
Monitor these headers to pace your requests rather than waiting for `429` responses.
## Production Limits
Each endpoint category has its own window. The numbers below apply to production; sandbox environments may use different values, so always verify against the response headers for the environment you're calling.
| Endpoint category | Limit |
| -------------------------------- | ------------------------------------------------- |
| General endpoints | 10 requests per 60 seconds |
| Channel endpoints | 60 requests per 60 seconds |
| Order endpoints | 600 requests per 60 seconds |
| Event endpoints | 240 requests per 60 seconds |
| Offer endpoints | 1500 requests per 60 seconds |
| Category attributes | 86,400 requests per 86,400 seconds (≈1/s average) |
| Global attributes and categories | 5-10 requests per 1,800-3,600 seconds |
## 429 Handling
When a request is rejected with `429`:
1. Stop sending additional requests in that endpoint category until the window resets.
2. Apply exponential backoff before retrying, and use the headers `X-RateLimit-Interval-Length-Seconds` and `X-RateLimit-Remaining` to adjust your request cadence.
3. Spread bursts across time rather than sending batches simultaneously.
For polling-based workflows like event consumption, a steady cadence (for example, once every 60 seconds) keeps you well within the event endpoint quota and avoids self-inflicted throttling.
## What's Next?
Token exchange and Bearer header usage for SCX APIs.
Endpoint-level reference for the Channel API.
# Seller Management
Source: https://developer.jtl-software.com/guides/marketplace-channels/seller-management
Managing seller accounts through SCX: sign-up, update, and unlink flows.
This guide covers the key integration patterns for managing seller accounts through the SCX platform: sign-up, update, and unlink flows.
A channel must manage seller accounts autonomously. JTL will never be aware of any credentials required by an
individual seller to connect to a marketplace or an external system (including API credentials).
Each channel must maintain a **sign-up URL** and an **update URL**. The sign-up URL must point to a login page and the update
URL to a settings page, both hosted by the channel itself. A seller will create a sign-up or update session in JTL-Wawi,
and from there they will be redirected to the channel-hosted URLs with a unique one-time session ID.
The sign-up flow described below applies to standalone channels. If the channel is a **platform channel**
(multi-marketplace architecture), see [Platform Channels](/guides/marketplace-channels/platform-channels).
## Seller Sign-up
The aim of the sign-up process is to avoid managing sensitive access data to a marketplace within the client
environment or SCX. The channel itself has sovereignty over the access data to the connected marketplace.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
Seller->>SCX: POST /v1/seller/channel/MYCHANNEL (initiate sign-up)
SCX-->>Seller: Returns signUpUrl + sessionId
Seller->>Channel: Opens signUpUrl in browser
Channel->>Channel: Authenticate seller & create account
Channel->>Channel: Generate unique SellerId
Channel->>SCX: POST /v1/channel/seller (sessionId + sellerId)
SCX-->>Seller: Sign-up complete, events now use this SellerId
```
The sign-up is initiated via the Seller API, which creates a session ID and a sign-up URL.
JTL-Wawi redirects the seller to the sign-up URL (via web browser). The destination is a website hosted by the channel where the registration process takes place.
The channel authenticates the seller, stores the new seller record, and assigns a unique Seller ID.
The channel reports the generated Seller ID together with the Session ID back to SCX. From now on, SCX sends all events with this Seller ID to the channel.
### Example: Create a Sign-up Session
Initiating a sign-up session returns a `signUpUrl` and a one-time session ID.
```json theme={null}
// POST /v1/seller/channel/MYCHANNEL
{
"signUpUrl": "https://www.mychannel.com/?session=demoSessionId123&expiresAt=1646759360",
"expiresAt": 1646759360
}
```
The seller is redirected to the `signUpUrl`, where the channel authenticates the seller and collects any information required to identify them. Once the seller has been successfully authenticated, the channel creates a unique Seller ID and sends it, together with the Session ID, to the Channel API.
All events received from the Channel API will carry this Seller ID.
The Seller ID is **immutable** and cannot be changed afterwards.
```json theme={null}
// POST /v1/channel/seller
{
"session": "demoSessionId123",
"sellerId": "1",
"companyName": "JTL-Software-GmbH"
}
```
## Seller Update
Sometimes it may be necessary to update the connection between a JTL account and the seller. For example, the access
data pertaining to the marketplace may have been changed. In these cases, the JTL account must be able to update
this data on the channel.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
Seller->>SCX: PATCH /v1/seller/channel/MYCHANNEL (initiate update)
SCX-->>Seller: Returns updateUrl + sessionId
Seller->>Channel: Opens updateUrl in browser
Channel->>SCX: GET /v1/channel/seller/update-session?sessionId=...
SCX-->>Channel: Returns sellerId
Channel->>Channel: Seller updates their settings
Channel->>SCX: PATCH /v1/channel/seller (update seller data)
```
The update process is initiated via the Seller API, which creates an update URL for the channel.
JTL-Wawi redirects the seller to the update URL. The destination is a website hosted by the channel where the update process takes place.
The channel asks SCX which Seller ID belongs to the current update Session ID (for security reasons, the Seller ID is not part of the update URL).
The channel enables an update of the seller account and, after the update process, can also update the seller on the SCX system.
### Example: Initiate an Update Session
Initiating an update session returns an `updateUrl` and a one-time session ID.
```json theme={null}
// PATCH /v1/seller/channel/MYCHANNEL?sellerId=1
{
"updateUrl": "https://www.mychannel.com/update?session=demoUpdateSessionId123&expiresAt=1646759360",
"expiresAt": 1646759360
}
```
The seller is redirected to the update URL and receives a one-time session ID. Resolve the Seller ID from the session:
```json theme={null}
// GET /v1/channel/seller/update-session?sessionId=demoUpdateSessionId123
{
"sellerId": "1"
}
```
After the update workflow is complete, the channel may update the seller at the Channel API:
```json theme={null}
// PATCH /v1/channel/seller
{
"sessionId": "demoUpdateSessionId123",
"isActive": true,
"companyName": "JTL-Software-GmbH"
}
```
## Seller Unlink
There are different scenarios when a seller reaches a state where they are no longer allowed to use a channel:
* The seller deactivates the connection on their own behalf.
* The seller does not have an active JTL-eazyAuction subscription.
```mermaid theme={null}
sequenceDiagram
participant Seller as Seller (JTL-Wawi)
participant SCX as SCX Platform
participant Channel as Channel Integration
alt Seller-initiated unlink
Seller->>SCX: Deactivates channel connection
SCX->>Channel: Seller:Channel.Unlinked event
else Channel-initiated unlink
Channel->>SCX: DELETE /v1/channel/sellerId/{sellerId}
SCX->>Seller: Seller:Channel.Unlinked event
end
alt permanentlyRemoved = false
Note over Channel: Deactivate seller, keep data
else permanentlyRemoved = true
Note over Channel: Safe to delete seller data
end
```
In this scenario, the channel receives a `Seller:Channel.Unlinked` event:
```json theme={null}
{
"sellerId": "1",
"reason": "deactivated by Seller",
"unlinkedAt": "2024-02-13T06:00:00+0000",
"permanentlyRemoved": false
}
```
When `permanentlyRemoved` is `false`, you should deactivate the seller in your system but **not** delete them. SCX will not accept any more data for that Seller ID until the seller initiates an update process.
When `permanentlyRemoved` is `true`, the Seller ID is completely removed from SCX and you can delete it on your end as well.
### Unlinking a Seller from the Channel Side
There are scenarios where the channel needs to unlink a seller:
* API credentials become invalid or are revoked, requiring re-authorization
* Seller does not have an active contract or subscription with your company
* Suspicious behavior detected and you want to stop the seller's activity
Send a `DELETE /v1/channel/sellerId/{sellerId}` request to unlink the seller.
Do not delete the Seller ID in your system until you receive a `Seller:Channel.Unlinked` event with `"permanentlyRemoved": true`.
## Managing Minimum Client Version
The `minimumClientsVersionRequired` property enables controlled rollout and compatibility assurance
between channels and JTL clients (JTL-Wawi). It defines which client versions are supported for connecting
to a specific channel and only affects the seller sign-up process.
### How It Works
Each entry in the list includes:
| Property | Description |
| --------- | -------------------------------------------------------------------------- |
| `type` | Defines the client (currently only `Wawi`). |
| `version` | Minimum version required in semantic versioning format (e.g., `1.11.0.0`). |
When a seller connects, SCX compares the seller's Wawi version (from the User-Agent) with the defined minimum:
* If the version is **lower**, onboarding fails with error code `SLR202`.
* If **equal or higher**, onboarding proceeds as usual.
Existing sellers are not affected. Their connection will not be interrupted when using a client version lower than the defined minimum.
### Configuration
A channel can manage this property using `PATCH /v1/channel`:
```json theme={null}
// PATCH /v1/channel
{
"minimumClientsVersionRequired": [
{
"type": "Wawi",
"version": "1.11.0.0"
}
]
}
```
### Use Cases
The property supports several rollout and compatibility scenarios.
| Scenario | Description |
| ----------------------- | ----------------------------------------------------------------------------------------- |
| **Gradual rollouts** | Require a minimum client version for new signups to ensure feature compatibility. |
| **Controlled upgrades** | Encourage merchants to update to the latest Wawi version when using new channel features. |
| **Legacy protection** | Avoid issues caused by outdated clients without disrupting existing integrations. |
***
## What's Next?
Events, metadata, and media content handling.
Listing and stock synchronization.
Orders, cancellations, returns, and refunds.
Token exchange and Bearer headers once a seller is onboarded.
Endpoint-level reference for the Channel API.
Try the API with ready-made requests.
# Vouchers API Changelog
Source: https://developer.jtl-software.com/guides/voucher/changelog
Version history and breaking changes for the Vouchers API.
## 1.8 (2022-02-01)
* Error responses now return unique error codes and more detail (see [Error Codes](/guides/voucher/error-codes))
## 1.7 (2021-11-23)
* The refund endpoint now returns the created refund object
* The full charged amount can now be refunded
* **Deprecated:** The cancel endpoint is deprecated and will be removed in a future version. Use the refund endpoint instead.
## 1.6 (2021-09-13)
* `usages` renamed to `charges` across all endpoints
## 1.5 (2021-08-16)
* `client_type` is now sent at the `oauth/token` call, not the `clients/connect` call
## 1.4 (2021-08-13)
* `client_type` is no longer restricted to fixed values
* Vouchers with active status or existing charges can no longer be deleted
## 1.3 (2021-08-10)
* `code` and `pin` properties (deprecated since v1.1) are now removed from all responses except the voucher create call
* Client groups with old scopes (`can-manage`, `can-use`) are migrated to the new scopes automatically
## 1.2 (2021-08-06)
* New optional `order_number` property on voucher creation
## 1.1 (2021-08-04)
* Refactored client group scopes for more granular access control
* Clients can request a subset of their available scopes when getting a token
* Vouchers can be created with an initial amount of 0
* `client_type` can now be sent in the connect call (optional)
* New endpoint: `PATCH /vouchers` to update `sku` and `batch` on inactive vouchers
* New endpoint: `POST /vouchers/recharge`
* New endpoint: `POST /clients/disconnect` to invalidate all credentials for a client
* New endpoint: `GET /vouchers/{id}/complete` to read voucher secrets (`code` and `pin`)
* **Deprecated:** `code` and `pin` will be removed from all responses except the create call - use the complete endpoint instead
# Vouchers API Error Codes
Source: https://developer.jtl-software.com/guides/voucher/error-codes
Error response format and validation error codes for the Vouchers API.
The Vouchers API returns structured error objects on failed requests. This page covers the response format, validation error codes, and general business logic error codes.
## Response Format
Failed requests return an error object:
```json theme={null}
{
"status": 404,
"code": "VOUCHER.NOT_FOUND",
"message": "The requested Voucher was not found."
}
```
`422 Unprocessable Entity` responses include a list of field-level errors:
```json theme={null}
{
"status": 422,
"code": "VOUCHER.CREATE.UNPROCESSABLE_ENTITY",
"message": "The given data was invalid.",
"errors": [
{
"code": "VOUCHER.CREATE.CURRENCY.VALID_CURRENCY",
"property": "currency",
"rule": "valid_currency",
"message": "Currency must be a valid currency code"
}
]
}
```
## Validation Error Codes
These appear in the `errors` array of `422` responses.
### Client
Errors returned when connecting a client.
#### Connect
| Code | Message |
| ----------------------------- | -------------------------- |
| `CLIENT.CONNECT.PIN.REQUIRED` | The pin field is required. |
| `CLIENT.CONNECT.PIN.STRING` | The pin must be a string. |
### Voucher
Errors returned when creating, updating, deleting, recharging, or changing the status of a voucher.
#### Create
| Code | Message |
| ------------------------------------------------------------------ | ------------------------------------------------------------------ |
| `VOUCHER.CREATE.CUSTOM_ID.STRING` | The custom\_id must be a string. |
| `VOUCHER.CREATE.CUSTOM_ID.MAX:255` | The custom\_id may not be greater than 255 characters. |
| `VOUCHER.CREATE.CUSTOM_ID.UNIQUE` | The custom\_id has already been taken. |
| `VOUCHER.CREATE.CODE.STRING` | The code must be a string. |
| `VOUCHER.CREATE.CODE.MAX:255` | The code may not be greater than 255 characters. |
| `VOUCHER.CREATE.CODE.UNIQUE` | The code has already been taken. |
| `VOUCHER.CREATE.SKU.STRING` | The sku must be a string. |
| `VOUCHER.CREATE.SKU.MAX:255` | The sku may not be greater than 255 characters. |
| `VOUCHER.CREATE.PIN.STRING` | The pin must be a string. |
| `VOUCHER.CREATE.PIN.MAX:255` | The pin may not be greater than 255 characters. |
| `VOUCHER.CREATE.BATCH.STRING` | The batch must be a string. |
| `VOUCHER.CREATE.BATCH.MAX:30` | The batch may not be greater than 30 characters. |
| `VOUCHER.CREATE.AMOUNT.REQUIRED` | The amount field is required. |
| `VOUCHER.CREATE.AMOUNT.STRING` | The amount must be a string. |
| `VOUCHER.CREATE.AMOUNT.NUMERIC` | The amount must be a number. |
| `VOUCHER.CREATE.AMOUNT.MIN:0` | The amount must be at least 0. |
| `VOUCHER.CREATE.AMOUNT.VALID_CURRENCY_AMOUNT` | Amount must have exactly two decimals. |
| `VOUCHER.CREATE.STATUS.VALID_VOUCHER_STATUS` | Voucher status can only be: inactive, active. |
| `VOUCHER.CREATE.CURRENCY.REQUIRED` | The currency field is required. |
| `VOUCHER.CREATE.CURRENCY.VALID_CURRENCY` | Currency must be a valid currency code. |
| `VOUCHER.CREATE.VALIDITY_VALUE.NUMERIC` | The validity\_value must be a number. |
| `VOUCHER.CREATE.VALIDITY_VALUE.GT:0` | The validity\_value must be greater than 0. |
| `VOUCHER.CREATE.VALIDITY_INTERVAL.STRING` | The validity\_interval must be a string. |
| `VOUCHER.CREATE.VALIDITY_INTERVAL.VALID_VOUCHER_VALIDITY_INTERVAL` | Voucher validity interval can only be: days, weeks, months, years. |
| `VOUCHER.CREATE.TYPE.VALID_VOUCHER_TYPE` | Voucher types can only be: print, digital. |
| `VOUCHER.CREATE.TAXABLE.BOOLEAN` | The taxable field must be true or false. |
| `VOUCHER.CREATE.TAX_RATE.REQUIRED_IF:TAXABLE,TRUE` | The tax\_rate field is required when taxable is true. |
| `VOUCHER.CREATE.TAX_RATE.NUMERIC` | The tax\_rate must be a number. |
| `VOUCHER.CREATE.TAX_RATE.BETWEEN:0,100` | The tax\_rate must be between 0 and 100. |
| `VOUCHER.CREATE.ORDER_NUMBER.STRING` | The order\_number must be a string. |
| `VOUCHER.CREATE.ORDER_NUMBER.MAX:255` | The order\_number may not be greater than 255 characters. |
| `VOUCHER.CREATE.DATA.JSON` | The data must be a valid JSON string. |
#### Delete
| Code | Message |
| --------------------------------- | --------------------------------------------------- |
| `VOUCHER.DELETE.COMMENT.REQUIRED` | The comment field is required. |
| `VOUCHER.DELETE.COMMENT.STRING` | The comment must be a string. |
| `VOUCHER.DELETE.COMMENT.MAX:255` | The comment may not be greater than 255 characters. |
#### Recharge
| Code | Message |
| ----------------------------------------------- | ------------------------------------------ |
| `VOUCHER.RECHARGE.AMOUNT.REQUIRED` | The amount field is required. |
| `VOUCHER.RECHARGE.AMOUNT.STRING` | The amount must be a string. |
| `VOUCHER.RECHARGE.AMOUNT.NUMERIC` | The amount must be a number. |
| `VOUCHER.RECHARGE.AMOUNT.BETWEEN:0.01,99999` | The amount must be between 0.01 and 99999. |
| `VOUCHER.RECHARGE.AMOUNT.VALID_CURRENCY_AMOUNT` | Amount must have exactly two decimals. |
| `VOUCHER.RECHARGE.CURRENCY.REQUIRED` | The currency field is required. |
| `VOUCHER.RECHARGE.CURRENCY.VALID_CURRENCY` | Currency must be a valid currency code. |
| `VOUCHER.RECHARGE.ORDER_NUMBER.REQUIRED` | The order\_number field is required. |
| `VOUCHER.RECHARGE.ORDER_NUMBER.STRING` | The order\_number must be a string. |
#### Status
| Code | Message |
| -------------------------------------------- | --------------------------------------------- |
| `VOUCHER.STATUS.STATUS.REQUIRED` | The status field is required. |
| `VOUCHER.STATUS.STATUS.VALID_VOUCHER_STATUS` | Voucher status can only be: inactive, active. |
#### Update
| Code | Message |
| ------------------------------------------------------------------ | ------------------------------------------------------------------ |
| `VOUCHER.UPDATE.CUSTOM_ID.STRING` | The custom\_id must be a string. |
| `VOUCHER.UPDATE.CUSTOM_ID.MAX:255` | The custom\_id may not be greater than 255 characters. |
| `VOUCHER.UPDATE.CUSTOM_ID.UNIQUE` | The custom\_id has already been taken. |
| `VOUCHER.UPDATE.CODE.STRING` | The code must be a string. |
| `VOUCHER.UPDATE.CODE.MAX:255` | The code may not be greater than 255 characters. |
| `VOUCHER.UPDATE.CODE.UNIQUE` | The code has already been taken. |
| `VOUCHER.UPDATE.SKU.STRING` | The sku must be a string. |
| `VOUCHER.UPDATE.SKU.MAX:255` | The sku may not be greater than 255 characters. |
| `VOUCHER.UPDATE.PIN.STRING` | The pin must be a string. |
| `VOUCHER.UPDATE.PIN.MAX:255` | The pin may not be greater than 255 characters. |
| `VOUCHER.UPDATE.BATCH.STRING` | The batch must be a string. |
| `VOUCHER.UPDATE.BATCH.MAX:30` | The batch may not be greater than 30 characters. |
| `VOUCHER.UPDATE.AMOUNT.STRING` | The amount must be a string. |
| `VOUCHER.UPDATE.AMOUNT.NUMERIC` | The amount must be a number. |
| `VOUCHER.UPDATE.AMOUNT.MIN:0` | The amount must be at least 0. |
| `VOUCHER.UPDATE.AMOUNT.VALID_CURRENCY_AMOUNT` | Amount must have exactly two decimals. |
| `VOUCHER.UPDATE.STATUS.VALID_VOUCHER_STATUS` | Voucher status can only be: inactive, active. |
| `VOUCHER.UPDATE.CURRENCY.VALID_CURRENCY` | Currency must be a valid currency code. |
| `VOUCHER.UPDATE.VALIDITY_VALUE.NUMERIC` | The validity\_value must be a number. |
| `VOUCHER.UPDATE.VALIDITY_INTERVAL.STRING` | The validity\_interval must be a string. |
| `VOUCHER.UPDATE.VALIDITY_INTERVAL.VALID_VOUCHER_VALIDITY_INTERVAL` | Voucher validity interval can only be: days, weeks, months, years. |
| `VOUCHER.UPDATE.TYPE.VALID_VOUCHER_TYPE` | Voucher types can only be: print, digital. |
| `VOUCHER.UPDATE.TAXABLE.BOOLEAN` | The taxable field must be true or false. |
| `VOUCHER.UPDATE.TAX_RATE.REQUIRED_IF:TAXABLE,TRUE` | The tax\_rate field is required when taxable is true. |
| `VOUCHER.UPDATE.TAX_RATE.NUMERIC` | The tax\_rate must be a number. |
| `VOUCHER.UPDATE.TAX_RATE.BETWEEN:0,100` | The tax\_rate must be between 0 and 100. |
| `VOUCHER.UPDATE.ORDER_NUMBER.STRING` | The order\_number must be a string. |
| `VOUCHER.UPDATE.ORDER_NUMBER.MAX:255` | The order\_number may not be greater than 255 characters. |
| `VOUCHER.UPDATE.DATA.JSON` | The data must be a valid JSON string. |
### VoucherCharge
Errors returned when refunding a charge.
#### Refund
| Code | Message |
| --------------------------------------------------- | ------------------------------------------------------- |
| `VOUCHERCHARGE.REFUND.AMOUNT.REQUIRED` | The amount field is required. |
| `VOUCHERCHARGE.REFUND.AMOUNT.STRING` | The amount must be a string. |
| `VOUCHERCHARGE.REFUND.AMOUNT.NUMERIC` | The amount must be a number. |
| `VOUCHERCHARGE.REFUND.AMOUNT.BETWEEN:0.01,0` | The amount must be between 0.01 and the charged amount. |
| `VOUCHERCHARGE.REFUND.AMOUNT.VALID_CURRENCY_AMOUNT` | Amount must have exactly two decimals. |
| `VOUCHERCHARGE.REFUND.CURRENCY.REQUIRED` | The currency field is required. |
| `VOUCHERCHARGE.REFUND.CURRENCY.VALID_CURRENCY` | Currency must be a valid currency code. |
### VoucherReservation
Errors returned when creating or charging a reservation.
#### Create
| Code | Message |
| --------------------------------------------------------- | ---------------------------------------------- |
| `VOUCHERRESERVATION.CREATE.AMOUNT.REQUIRED` | The amount field is required. |
| `VOUCHERRESERVATION.CREATE.AMOUNT.STRING` | The amount must be a string. |
| `VOUCHERRESERVATION.CREATE.AMOUNT.NUMERIC` | The amount must be a number. |
| `VOUCHERRESERVATION.CREATE.AMOUNT.BETWEEN:0.01,99999` | The amount must be between 0.01 and 99999. |
| `VOUCHERRESERVATION.CREATE.AMOUNT.VALID_CURRENCY_AMOUNT` | Amount must have exactly two decimals. |
| `VOUCHERRESERVATION.CREATE.CODE.REQUIRED` | The code field is required. |
| `VOUCHERRESERVATION.CREATE.CODE.STRING` | The code must be a string. |
| `VOUCHERRESERVATION.CREATE.CODE.VALID_VOUCHER_CODE` | Invalid voucher code. |
| `VOUCHERRESERVATION.CREATE.CODE.VALID_CLIENT_DESTINATION` | The client is not allowed to use this voucher. |
| `VOUCHERRESERVATION.CREATE.PIN.VALID_VOUCHER_PIN` | Invalid voucher pin. |
| `VOUCHERRESERVATION.CREATE.CURRENCY.REQUIRED` | The currency field is required. |
| `VOUCHERRESERVATION.CREATE.CURRENCY.VALID_CURRENCY` | Currency must be a valid currency code. |
#### Charge
| Code | Message |
| ------------------------------------------------- | ------------------------------------ |
| `VOUCHERRESERVATION.CHARGE.ORDER_NUMBER.REQUIRED` | The order\_number field is required. |
| `VOUCHERRESERVATION.CHARGE.ORDER_NUMBER.STRING` | The order\_number must be a string. |
## General error codes
These appear at the top level (not in `errors`) for business logic failures.
### VoucherReservation
#### Create
| Code | Message |
| ------------------------------------- | -------------------------------- |
| `VOUCHERRESERVATION.CREATE.INACTIVE` | This voucher is inactive. |
| `VOUCHERRESERVATION.CREATE.EXPIRED` | This voucher is expired. |
| `VOUCHERRESERVATION.CREATE.NO_CREDIT` | This voucher has no credit left. |
***
## What's Next?
Set up a client, get credentials, and run the full voucher lifecycle.
Full endpoint reference for all Vouchers API operations and parameters.
# Vouchers API Quickstart
Source: https://developer.jtl-software.com/guides/voucher/quickstart
Set up a client, get credentials, and run through the full voucher lifecycle.
This guide walks you through the complete voucher lifecycle using the Vouchers API. By the end, you'll have:
* Created a voucher
* Activated it after payment
* Reserved and charged part of its balance
* Refunded the charge
* Recharged the voucher with additional credit
## 1. Set up Clients and Client Groups
Before your application can access the Vouchers API, it must be registered as a client.
Start in the **Voucher Cloud Admin UI**.
A **client group** defines the permissions available to one or more clients, such as POS terminals or online shops.
| Scope | Permission |
| -------------- | ------------------------------------- |
| `read` | Read a single voucher |
| `read-lists` | Read voucher lists |
| `read-secrets` | Read voucher code and pin |
| `use` | Activate, reserve, charge, and cancel |
| `manage` | Create and delete vouchers |
| `update` | Update vouchers |
| `recharge` | Recharge a voucher |
Create a client group with the scopes your integration requires, then create a client and assign it to that group.
## 2. Connect your Client
Each client needs OAuth credentials before it can authenticate with the API.
In the Admin UI:
1. Select the **Connect** button (Wi-Fi icon) for your client.
2. Copy the generated connection PIN. The PIN is valid for **30 minutes**.
Exchange the PIN for OAuth credentials:
```http theme={null}
POST https://vouchers.api.jtl-software.com/v1/clients/connect
Content-Type: application/json
{
"pin": ""
}
```
The response contains your `client_id` and `client_secret`. Store both securely, as you'll use them to request access tokens.
## 3. Request an Access Token
Use the OAuth 2 Client Credentials flow to get an access token:
```http theme={null}
POST https://vouchers.api.jtl-software.com/oauth/token
Content-Type: application/x-www-form-urlencoded
grant_type=client_credentials
&client_id=
&client_secret=
&client_type=my_pos
```
`client_type` is optional and used for internal statistics only (max 32 chars).
Include the returned access token in the `Authorization` header of every subsequent request:
```http theme={null}
Authorization: Bearer
```
The Vouchers API uses its own OAuth server. Access tokens issued by the JTL Platform or ERP API cannot be used with the Vouchers API.
## 4. Create a Voucher
Create a voucher with an initial balance.
```http theme={null}
POST https://vouchers.api.jtl-software.com/v1/vouchers
Authorization: Bearer
Content-Type: application/json
{
"amount": "10.00",
"currency": "EUR"
}
```
Save the returned voucher `id` and `code`. You'll use them throughout the remaining steps.
## 5. Activate the Voucher
New vouchers are created with the `inactive` status and cannot be redeemed until they are activated.
Typically, activation happens after the customer has completed payment.
```http theme={null}
PATCH https://vouchers.api.jtl-software.com/v1/vouchers/{id}/status
Authorization: Bearer
Content-Type: application/json
{
"status": "active"
}
```
## 6. Redeem a Voucher
Redeeming a voucher consists of two operations:
1. Reserve the amount to verify that sufficient balance is available.
2. Charge the reservation to deduct the reserved amount from the voucher.
This two-step process allows a voucher to be combined with other payment methods while the final order total is calculated.
### Create a Reservation
Reserve an amount against the voucher. This locks the voucher and confirms sufficient balance.
```http theme={null}
POST https://vouchers.api.jtl-software.com/v1/reservations
Authorization: Bearer
Content-Type: application/json
{
"amount": "5.00",
"currency": "EUR",
"code": ""
}
```
Save the returned reservation `id`.
Reservations expire after 30 minutes. Creating a new reservation for the same voucher automatically replaces the existing one.
### Charge the Reservation
Execute the deduction against the reservation:
```http theme={null}
POST https://vouchers.api.jtl-software.com/v1/reservations/{reservation_id}/charge
Authorization: Bearer
Content-Type: application/json
{
"order_number": "ORDER-001"
}
```
Save the returned charge `id`, which you'll use if the charge needs to be refunded.
## 7. Refund a Charge
If an order is cancelled or returned, refund all or part of the original charge.
```http theme={null}
POST https://vouchers.api.jtl-software.com/v1/charges/{charge_id}/refund
Authorization: Bearer
Content-Type: application/json
{
"amount": "5.00",
"currency": "EUR"
}
```
The response returns a new charge with `type: refund`.
## 8. Recharge a Voucher
You can add additional credit to an existing voucher, for example as store credit or part of a loyalty programme.
```http theme={null}
POST https://vouchers.api.jtl-software.com/v1/vouchers/recharge
Authorization: Bearer
Content-Type: application/json
{
"code": "",
"amount": "10.00",
"currency": "EUR",
"order_number": "RECHARGE-001"
}
```
The response returns a new charge with `type: recharge`.
***
## What's Next?
Reference for Vouchers API error codes and their meanings.
Full endpoint reference for all Vouchers API operations and parameters.
# Aufbau der XML-Datei (Auftragimport)
Source: https://developer.jtl-software.com/jtlwawiextern/AufbauXMLDateiAuftrag
Für die einfache Validierung eines Auftragsimportes in Form einer XML Datei stellen wir Ihnen gerne ein Schema bereit. Dieses Schema deckt die grundlegend erforderlichen Informationen der XML Datei ab. Diese kann jedoch nach belieben erweitert werden. Dabei können alle Tabellenfelder aus der Tabelle **tbestellung** in Form von Tags, bzw. deren Namen, direkt gefüllt werden
* [Header](#header)
## Tags
* [tBestellungen](#tbestellungen)
* [tBestellung](#tbestellung)
* [tzahlung](#tzahlung)
* [tbestellpos](#tbestellpos)
* [tbestelleigenschaft](#tbestelleigenschaft)
* [twarenlagerausgang](#twarenlagerausgang)
* [tlieferadresse](#tlieferadresse)
* [tzahlungsinfo](#tzahlungsinfo)
* [Erweiterung um weitere Felder](#erweiterung-um-weitere-felder)
## Header
Die XML Datei muss mit dieser Kopfinformation beginnen.
```xml theme={null}
```
Die Datei muss in Latin-1 codiert sein, damit die Daten richtig in die Datenbank übernommen werden und die Wawi sie korrekt darstellen kann.
## tBestellungen
Unter der Header - Zeile befindet sich der Tag **\**, welcher beliebig viele Bestellungen zum Import bereitstellen kann.
```xml theme={null}
```
## tBestellung
Der Tag **\** enthält alle Tags die für den Import einer Bestellung verwendet werden.
Zusätzlich stellt er Attribute bereit, über welchen der Import individuell gesteuert werden kann.
Zum Beispiel kann hier definiert werden, ob ein Lieferschein erstellt oder gedruckt werden soll.
### Attribute
Folgende Attribute müssen/können im Tag **\** für den Import angegeben werden:
```xml theme={null}
```
* **nRechnungErstellen**: Gibt an ob eine Rechnung zum importierten Auftrag erstellt werden soll.
* **nRechnungDrucken**: Gibt an ob die erstelle Rechnung gedruckt werden soll (Erfordert: nRechnungErstellen = "1")
* **kRechnungsFormular**: Gibt die Druckvorlage zum Druck der Rechnung an (Tabelle: tFormular Feld: kFormular vom nTyp = 2)
* **nLieferscheinErstellen**: Gibt an ob ein Lieferschein zum importieren Auftrag erstellt werden soll.->Achtung: Detailinformationen dazu werden unter den Auftragspositionen angegeben.
* **nLieferscheinDrucken**: Gibt an ob der erstellte Lieferschein gedruckt werden soll. (Erfordert: nLieferscheinErstellen = "1")
* **kLieferscheinFormular**: Gibt die Druckvorlage zum Druck des Lieferscheins an (Tabelle: tFormular Feld: kFormular vom nTyp = 3)
* **nAuftragDrucken**: Gibt an ob der erstellte Lieferschein gedruckt werden soll.
* **kAuftragsFormular**: Gibt die Druckvorlage zum Druck des Lieferscheins an (Tabelle: tFormular Feld: kFormular vom nTyp = 1)
* **kFirma**: Gibt die Firma an, welche zum Auftrag hinterlegt werden soll (Tabelle: tfirma Feld: kFirma)
* **tKunde\_kKunde**: Gibt den Kunden an, für welchen der Auftrag erstellt wird (Tabelle: tkunde Feld: kKunde) ->Achtung: Der Kunde muss in der Datenbank, in welche die XML importiert wird, vorhanden sein.
### Tags
Innerhalb des Tags **\** werden die Informationen zur Bestellung hinterlegt, die übertragen werden sollen.
Dies beinhaltet zum Einen Informationen, die direkt für den Auftrag erforderlich sind und zum Anderen Auflistungen der Positionen und Zahlungen. Des Weiteren werden hier die Lieferadresse und Zahlungsinformationen hinterlegt.
Im Folgenden werden die Tags beschrieben, die unmittelbar in die Erzeugung eines Auftrags einfließen.
```xml theme={null}
1EURBELEG 12345678922012-08-012012-07-13Anmerkung2012-07-16K214
```
* **kSprache**: Enthält einen Verweis auf die Sprache des Auftrags (Tabelle: tSprachen Feld: kSprache)
* **cWaehrung**: Währung wird hier als Text hinterlegt (im Beispiel: 'EUR')
* **cBestellNr**: Enthält die Bestellnummer. Sie wird automatisch über den Nummernkreis der Wawi ermittelt, sofern hier keine Bestellnummer angegeben wird.
* **cInetBestellNr**: Enthält eine von der Wawi abweichende Bestellnummer. z.B. die Nummer eines Kassenbons.
* **tVersandArt\_kVersandArt**: Enthält einen Verweis auf die Versandart, mit welcher der Auftrag ausgeliefert wird. (Tabelle: tversandart Feld: kSprache)
Versandarten können in den Wawi Statistiken individuell ausgewertet werden. Um importierte Aufträge auszuwerten empfiehlt sich aber die Verwendung einer Erweiterung (siehe unten) um das Tag (z.B. 151 für LS-Pos)
* **dVersandt**: Enthält das Datum, an welchem die Ware versendet wurde / wird. (Format: yyyy-mm-dd oder yyyy-mm-dd hh:nn:ss)
* **dLieferdatum**: Enthält das voraussichtliche Lieferdatum (Format: yyyy-mm-dd oder yyyy-mm-dd hh:nn:ss).
* **cAnmerkung**: Enthält eine Anmerkung zu Auftrag.
* **dErstellt**: Enthält das Datum der Auftragserstellung. (Format: yyyy-mm-dd oder yyyy-mm-dd hh:nn:ss)
* **cBeschreibung**: (K)Kurz- oder (L)Langbeschreibung des Artikels beim Druck.
* **kZahlungsArt**: Enthält einen Verweis auf die Zahlart, mit welcher der Auftrag bezahlt wird. (Tabelle: tZahlungsart Feld: kZahlungsart)
* **nZahlungsziel**: Das Zahlungsziel in Tagen.
## tzahlung
Jeder Auftrag kann über beliebig viele Zahlungen bezahlt werden. Z.B. könnte ein Kunde einen Teil bar und einen anderen Teil per Überweisung bezahlen.
```xml theme={null}
93.1100Mit Bargeld10.0000Mit Karte0
```
Dazu können innerhalb des **\**-Tags beliebig viele Tags von **\** enthalten sein.
Folgende Tags müssen innerhalb von **\** enthalten sein:
* **fBetrag**: Enthält den Zahlbetrag.
* **nAnzahlung**: Gibt an ob es sich um eine Anzahlung handelt ("1" = Ja und "0" = Nein).
* **kZahlungsart**: Enthält einen Verweis auf die Zahlungsart. (Tabelle: tZahlungsart Feld: kZahlungsart) \[ Ist die Zahlungsart nicht bekannt, kann hier einfach eine "0" eingetragen werden.]
* **cZahlungsArtName**: Wird in kZahlungsart "0" hinterlegt, kann hier der Name der gewünschten Zahlungsart hinterlegt werden.
* **cHinweis**: Hinweis zur Zahlung.
* **nZahlungstyp**: Zahlung = 0; Mahnung = 1; Skonto=2; Standard ist immer 0 (Zahlung)
*Wird keine passende Zahlungsart zum angegebenen Namen gefunden, wird diese automatisch angelegt.*
## tbestellpos
Jeder Auftrag beinhaltet beliebig viele Positionen, die im Tag **\** einzeln definiert werden können. Hier bietet sich zusätzlich die Möglichkeit die Warenlagerausgänge zu einer Positionen anzugeben und somit den zu erstellenden (wenn gewünscht) Lieferschein zu definieren.
```xml theme={null}
339684.2019.001.0017.000.00003396841511.000
```
**Folgende Tags müssen innerhalb eines \-Tags enthalten sein:**
* **tArtikel\_kArtikel**: Beinhaltet einen Verweis auf den gewünschten Artikel und ist "0" bei Frei-Positionen (Tabelle: tartikel Feld: kArtikel).
* **cArtNr**: Beinhaltet die gewünschte Artikelnummer, die auf der Bestellung gedruckt werden soll (Im Normalfall ).
* **fVKNetto**: Beinhaltet den Netto-Verkaufspreis (pro Einheit) der Position. Der Brutto-Verkaufspreis ermittelt sich automatisch.
* **fMwSt**: Beinhaltet die Mehrwertsteuer in % (z.B. '19.00' für 19 % MwSt).
* **nAnzahl**: Beinhaltet die Menge der Position.
* **nType**: Beinhaltet den Typ der Position (0 = Freiposition 1 = Artikel 2 = Versand). Freiposition können z.B. von Kassensystem genutzt werden um Freitextpositionen zu erzeugen. Achtung: Hier wird immer Menge und Preis mit 0 gedruckt.
* **fRabatt**: Beinhaltet einen Rabatt auf die Position (wird automatisch vom VK abgezogen!).
* **fEKNetto**: Beinhaltet den Netto-Einkaufspreis, sollte für die Statistik gepflegt werden. (Tabelle: tArtikel Feld: fEKNetto)
## tbestelleigenschaft
Ein Tag **\** kann beliebig viele Tags **\** abbilden. Diese beinhalten jeweils einen Verweis auf eine kEigenschaftwert (entspricht einer Variation) (Tabelle: teigenschaftwert Feld: kEigenschaftWert)
```xml theme={null}
119117
```
* **kEigenschaftWert**: Beinhaltet einen Verweis auf die Eigenschaft eines Variationsartikels, z.B. Größe L oder Farbe gelb.
## twarenlagerausgang
Eine Position innerhalb eines Auftrags kann über verschiedene Lieferungen erfüllt werden. Diese werden über die **\**-Tags innerhalb des **\**-Tags definiert. Wenn nichts ausgebucht werden soll, dann wird das **\**/-Tag ausgelassen.
```xml theme={null}
33963016.00033964014.000
```
Folgende Tags müssen innerhalb eines **\**-Tags enthalten sein:
* **kArtikel**: Beinhaltet den auszuliefernden Artikel. Bei Stücklisten z.B. werden hier die Komponenten ausgeliefert und mit der tatsächlich ausgebuchten Menge angegeben.
Beispiel: Eine Stückliste als Position mit der Menge 2 mit 2 Komponenten (jeweils 2 Stück in Komponente) ergibt zwei Tags von twarenlagerausgang:
1. Artikel Komponente 1 mit Menge 4 (\ (2) \* \ (2) = (4))
2. Artikel Komponente 2 mit Menge 4 (\ (2) \* \ (2) = (4))
* **kWarenLagerEingang**: Chargen- und MHD-Artikel werden immer einem Wareneingang zugeordnet, der den Eingang des Mindesthaltbarkeitsdatums-, bzw. der Charge definiert. Dazu kann der entsprechende Wert aus dem Feld kWarenLagerEingang aus der Tabelle tWarenLagerEingang mit der gewünschten Chargennummer, bzw. dem gewünschten MHD referenziert werden.
**Achtung**: Ein kWarenLagerEingang bezieht sich auch IMMER auf ein ein kWarenLagerPlatz (Tabelle: tWarenLagerPlatz Feld: kWarenLagerPlatz).
Um zu prüfen, ob noch genügend Bestand auf einem MHD- oder einer Charge liegt, können die kumulierten Mengen in tWarenLagerEingang, denen von tWarenLagerAusgang gegenübergestellt werden.
* **kWarenLagerPlatz**: Enthält den WarenLagerPlatz, von welchem die Ware geliefert wird. (Tabelle: tWarenLagerPlatz Feld: kWarenLagerPlatz) Das entsprechende WarenLager befindet sich in der Tabelle tWarenlager.
* **fAnzahl**: Gibt die Anzahl des Warenlagerausgangs an (Bei Seriennummernartikeln z.B. immer 1 pro Seriennummer).
* **kLagerArtikel**: Bei der Auslieferung von Seriennummern-Artikeln muss der entsprechende Lagerartikel angegeben werden, der die gewünschte Seriennummer enhält.
Mit dem Tag `` kann man sich ganz schnell die Bestände kaputt machen. Immer mit Vorsicht und Bedacht nutzen. Es ist z.B. möglich, 2 Seriennummern-Artikel auszubuchen aber nur eine Seriennummer, somit bleibt eine Seriennummer zu viel übrig. Bei Seriennummern-Artikeln muss immer ein Bestand von 1 angegeben werden.
Hier wird 2 mal der selbe Seriennummern-Artikel richtig ausgebucht:
```xml theme={null}
15011.001015011.0011
```
* In Zukunft wird es eine Prüfung geben, damit die Bestände nicht mehr so schnell zerstört werden können. Aktuell wird überprüft, ob genügend Bestand vorhanden ist.
## tlieferadresse
Über den Tag **\** wird einem Auftrag die entsprechende Lieferadresse zugewiesen. Im Folgenden werden die selbsterklärenden Tags innerhalb von **\** angegeben, bei allen handelt es sich um Freitext-Felder.
```xml theme={null}
LCTT_AnredeLCTT_VornameLCTT_NameLCTT_TitelLCTT_FirmaLCTT_StraßeLCTT_AZusatzLCTT_PLZLCTT_OrtLCTT_BundeslandMarshallinselnLCTT_TelLCTT_MobilLCTT_FaxLCTT@jtl-software.de
```
## tzahlungsinfo
Der Tag **\** definiert zusätzliche Zahlungsinformationen zu einem Auftrag.
Bei allen Tags handelt es sich ausschließlich um Textfelder.
```xml theme={null}
```
## Erweiterung um weitere Felder
Innerhalb des Tags **\** können weitere Tags angegeben werden, die in dieser Dokumentation nicht aufgeführt sind.
Dabei können alle Felder aus der Tabelle tBestellung direkt angesprochen werden.
**Beispiel:**
Für die Erstellung eines reinen Angebotes, kann z.B. folgender Tag hinzugefügt werden:
```xml theme={null}
A
```
Sobald das Tag `cType` mit dem Wert `A` verwendet wird, darf keine Rechnung mehr erstellt werden. Dazu **muss** das Attribut `nRechnungErstellen` unbedingt auf `0` gesetzt werden. Ebenfalls darf auch kein Lieferschein mehr erstellt werden. Dazu **muss** das Attribut `nLieferscheinErstellen` unbedingt auf `0` gesetzt werden.
# Beispiel: XML Auftragsimport
Source: https://developer.jtl-software.com/jtlwawiextern/AuftragsimportBeispiel
In diesem Beispiel sehen Sie, wie man eine XML-Auftragsdatei über die `JTLwawiExtern.dll` importieren kann.
Wie im Abschnitt [JTLwawiExtern.dll einbinden](/jtlwawiextern/JTLwawiExterndll_einbinden) beschrieben, ist ein Objekt der Klasse `CJTLwawiExtern` in der Klasse `Worker` in einem privaten Feld initialisiert worden, auf das in der Methode `Import()` zugegriffen wird.
Durch die Methode `JTL_OrderXmlImport()` ist es möglich, einen Auftrag in die Datenbank der Wawi zu importieren.
## Code-Beispiel
```csharp theme={null}
class Worker
{
CJTLwawiExtern _wawiExtern = new CJTLwawiExtern();
public void Import(string server, string datenbank, string benutzer, string passwort, int kBenutzer, string filePath)
{
string cKRechnungen;
this._wawiExtern.JTL_OrderXmlImport(server, datenbank, benutzer, passwort, kBenutzer, filePath, out cKRechnungen);
}
}
```
## Übergabeparameter
Zugangsdaten des Servers:
* **server**: Enthält den Servernamen
* **datenbank**: Enthält den Datenbanknamen. In der Wawi sollte dies standardmäßig eazybusiness sein.
* **benutzer**: Enthält den Benutzernamen des Servers.
* **passwort**: Enthält das Passwort passend zum Benutzernamen.
* **kBenutzer**: Enthält den Key des Benutzers, der in diesem Fall die JTL-Wawi verwendet. Bsp.: Admin hat den Wert 1. Dieser Wert ist aus der Tabelle tbenutzer zu entnehmen.
* **filePath**: Enthält den Dateipfad, an dem sich die zu importierende XML-Datei befindet.
## Ausgabeparameter
* **out cKRechnungen**: In diesem Ausgabeparameter vom Typ String wird der Wert für `kRechnung` zurückgegeben. Falls mehrere Aufträge in einer XML-Datei enthalten sind, werden alle Werte für `kRechnung` in einem String, durch Komma getrennt, zurückgegeben.
# Beispielprojekt
Source: https://developer.jtl-software.com/jtlwawiextern/Beispielprojekt
Im Download finden Sie ein Beispielprojekt, welches die Einbindung und Benutzung der `JTLwawiExtern.dll` erläutert.
Eventuell müssen Sie die `JTLwawiExtern.dll` in den Verweisen erneut einbinden.
Vollständiges C#-Projekt als ZIP.
# Druckmethoden
Source: https://developer.jtl-software.com/jtlwawiextern/Druckmethoden
In diesem Beispiel sehen Sie, wie man eine Druckmethode über ein Objekt der `JTLwawiExtern.dll` ansteuern kann.
Wie im Abschnitt [JTLwawiExtern.dll einbinden](/jtlwawiextern/JTLwawiExterndll_einbinden) beschrieben, ist ein Objekt der Klasse `CJTLwawiExtern` in der Klasse `Worker` in einem privaten Feld initialisiert worden, auf das in der Methode `Drucken()` zugegriffen wird.
Mittels der folgenden Methode ist es möglich, entsprechende Aufträge zu drucken.
## Code-Beispiel
```csharp theme={null}
class Worker
{
CJTLwawiExtern _wawiExtern = new CJTLwawiExtern();
public void Drucken(string server, string datenbank, string benutzer, string passwort, int kBenutzer, int key, int id)
{
this._wawiExtern.JTL_DruckeAuftrag(server, datenbank, benutzer, passwort, kBenutzer, key, id);
}
}
```
## Übergabeparameter
Zugangsdaten des Servers:
* **server**: Enthält den Servernamen
* **datenbank**: Enthält den Datenbanknamen. In der Wawi sollte dies standardmäßig **eazybusiness** sein
* **benutzer**: Enthält den Benutzernamen des Servers.
* **passwort**: Enthält das Passwort passend zum Benutzernamen.
* **kBenutzer**: Enthält den Key des Benutzers, der in diesem Fall die JTL-Wawi verwendet. Bsp.: Admin hat den Wert 1. Dieser Wert ist aus der Tabelle **tbenutzer** zu entnehmen.
* **key**: Enthält im Programmbeispiel den Wert `kBestellung` aus der Tabelle `tBestellung`. In einer anderen Druckmethode, wie z.B. `JTL_DruckeRechnung`, muss man den Wert `kRechnung` aus der Tabelle `trechnung` verwenden. Für jede weitere Druckmethode muss ein entsprechender Key aus der entsprechenden Tabelle entnommen werden.
* **id**: Enthält den Wert von `kFormular` aus der Tabelle `tFormular` für den entsprechenden Namen in der Spalte `cName`, welcher das zugehörige Druckformular auswählt.
## Verfügbare Druckmethoden
* `JTL_DruckeAuftrag`
* `JTL_DruckeAngebot`
* `JTL_DruckeRechnung`
# Beispiel: XML Gutschriftenimport
Source: https://developer.jtl-software.com/jtlwawiextern/GutschriftimportBeispiel
In diesem Beispiel sehen Sie, wie man eine XML-Gutschriftsdatei über die `JTLwawiExtern.dll` importieren kann.
Wie im Abschnitt [JTLwawiExtern.dll einbinden](/jtlwawiextern/JTLwawiExterndll_einbinden) beschrieben, ist ein Objekt der Klasse `CJTLwawiExtern` in der Klasse `Worker` in einem privaten Feld initialisiert worden, auf das in der Methode `Import()` zugegriffen wird.
Durch die Methode `JTL_CreditXmlImport()` ist es möglich, eine Gutschrift in die Datenbank der Wawi zu importieren.
## Code-Beispiel
```csharp theme={null}
class Worker
{
CJTLwawiExtern _wawiExtern = new CJTLwawiExtern();
public void Import(string server, string datenbank, string benutzer, string passwort, int kBenutzer, string filePath)
{
string cKGutschriften;
this._wawiExtern.JTL_CreditXmlImport(server, datenbank, benutzer, passwort, kBenutzer, filePath, out cKGutschriften);
}
}
```
## Übergabeparameter
Zugangsdaten des Servers:
* **server**: Enthält den Servernamen
* **datenbank**: Enthält den Datenbanknamen. In der Wawi sollte dies standardmäßig **eazybusiness** sein.
* **benutzer**: Enthält den Benutzernamen des Servers.
* **passwort**: Enthält das Passwort passend zum Benutzernamen.
* **kBenutzer**: Enthält den Key des Benutzers, der in diesem Fall die JTL-Wawi verwendet. Bsp.: Admin hat den Wert 1. Dieser Wert ist aus der Tabelle **tbenutzer** zu entnehmen
* **filePath**: Enthält den Dateipfad, an dem sich die zu importierende XML-Datei befindet.
## Ausgabeparameter
* **out cKGutschriften**: In diesem Ausgabeparameter vom Typ String wird der Wert für **kGutschrift** zurückgegeben. Falls mehrere Gutschriften in einer XML-Datei enthalten sind, werden alle Werte für **kGutschrift** in einem String, durch Komma getrennt zurückgegeben.
# JTLwawiExtern.dll einbinden
Source: https://developer.jtl-software.com/jtlwawiextern/JTLwawiExterndll_einbinden
In diesem Abschnitt finden Sie eine Erklärung zur Einbindung der `JTLwawiExtern.dll`. Im Beispielprojekt können Sie sich das gesamte Projekt anschauen.
Öffnen Sie Ihr Projekt in Ihrem Visual Studio.
Klicken Sie mit rechts auf **Verweise** und anschließend auf **Verweis hinzufügen**.
Klicken Sie nun auf der linken Seite auf **Durchsuchen** und anschließend auf den Durchsuchen-Button unten am Dialog-Fensterrand.
Suchen Sie nun die `JTLwawiExtern.dll` in dem JTL-Software Verzeichnis. Klicken Sie anschließend auf **OK**.
* **Standardpfad (x64-System):** `C:\Program Files (x86)\JTL-Software`
* **Standardpfad (x86-System):** `C:\Program Files\JTL-Software`
Nun müssen Sie in den Eigenschaften des Verweis für die `JTLwawiExtern.dll` die **Lokale Kopie** auf **False** setzen, was standardmäßig auf **True** gesetzt ist.
Dies ist für die nächsten Schritte notwendig, da nur über das Einbinden des Verweis nicht alle von der `JTLwawiExtern.dll` benötigten Verweise nachgeladen werden können, da das Projekt nur im Projektverzeichnis oder im Global Assembly Cache nach den DLLs sucht und nicht dort, wo sich die DLL lokal auf dem Rechner befindet.
Zusätzlich muss die DLL dynamisch zur Laufzeit eingebunden werden. Dazu müssen Sie die folgenden Methoden verwenden, welche die Registry nach dem Installationspfad der Wawi durchsuchen.
Die Methode `FindInstallLocation()` übergibt der Methode `FindUninstallSubkey()` den Basis-Registry-Zweig für 32-Bit oder 64-Bit Systeme.
In der Methode `FindUninstallSubkey()` wird im übergebenen Registryzweig nach dem Pfad zur Installation der Wawi gesucht und falls dieser gefunden wird, wird er zurückgegeben.
```csharp theme={null}
private string FindInstallLocation()
{
var cLocation = FindUninstallSubkey(@"Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall");
return !string.IsNullOrEmpty(cLocation) ? cLocation : FindUninstallSubkey(@"Software\Microsoft\Windows\CurrentVersion\Uninstall");
}
private string FindUninstallSubkey(string baseKey)
{
var oKey = Registry.LocalMachine.OpenSubKey(baseKey);
if (oKey == null)
return null;
return oKey.GetSubKeyNames()
.Select(oKey.OpenSubKey)
.Where(oSubKey => Equals("JTL-Wawi", oSubKey.GetValue("DisplayName")))
.Select(oSubKey => Convert.ToString(oSubKey.GetValue("InstallLocation")))
.FirstOrDefault();
}
```
Des Weiteren sollten Sie prüfen, ob die Versionsnummer der lokal gefundenen `JTLwawiExtern.dll` mindestens genau so groß ist, wie die der über Verweise eingebundenen `JTLwawiExtern.dll`. Dies ist notwendig, da man nicht davon ausgehen kann, dass in einer kleineren Version die gleichen Methoden enthalten sind.
Allerdings muss die Version der über Verweise eingebundenen `JTLwawiExtern.dll` per Hand angegeben werden. Die Version findet man unter den Eigenschaften der eingebundenen DLL.
```csharp theme={null}
private bool ValidExternDllVersion()
{
var externDllPath = Path.Combine(this._wawiPath, "JTLwawiExtern.dll");
var externDllVersion = new Version(FileVersionInfo.GetVersionInfo(externDllPath).FileVersion);
var eingebundeneExternDllVersion = new Version(1, 1, 0, 9);
return externDllVersion >= eingebundeneExternDllVersion;
}
```
Mittels der folgenden Programmzeile müssen Sie ein Event für den Resolver abonnieren, welches es ermöglicht die benötigten DLLs zur Laufzeit nachzuladen.
Das Abonnieren des Events im Resolver muss zwingend vor dem Ausführen von Code, der auf die `JTLwawiExtern.dll` zugreift, stattfinden, da es ansonsten zu Laufzeitfehlern kommen kann. Falls kein Installationspfad gefunden werden kann oder die Versionsprüfung aus Schritt 6 fehlschlägt, sollte das Programm beendet werden, da man nicht auf die DLLs zugreifen kann.
```csharp theme={null}
AppDomain.CurrentDomain.AssemblyResolve += this.LoadAssemblys;
```
Das Event `LoadAssemblys()` lädt dann aus dem Installationspfad der Wawi, hier im Feld `_wawiPath` gespeichert, die benötigten DLLs nach, sofern diese existieren.
```csharp theme={null}
private Assembly LoadAssemblys(object sender, ResolveEventArgs args)
{
var folderPath = Path.GetDirectoryName(this._wawiPath);
var assemblyPath = Path.Combine(folderPath ?? throw new InvalidOperationException(), $"{new AssemblyName(args.Name).Name}.dll");
if (!File.Exists(assemblyPath))
return null;
var assembly = Assembly.LoadFrom(assemblyPath);
return assembly;
}
```
Nun müssen Sie in Ihrer Klasse die **using-Directive** für die `JTLwawiExtern.dll` hinzufügen.
Nun müssen Sie ein Objekt der Klasse `CJTLwawiExtern` erstellen, das Ihnen ermöglicht die Methoden der `JTLwawiExtern.dll` zu nutzen.
```csharp theme={null}
private readonly CJTLwawiExtern _wawiExtern;
public Worker()
{
this._wawiExtern = new CJTLwawiExtern();
}
```
# Speichermethoden
Source: https://developer.jtl-software.com/jtlwawiextern/Speichermethoden
In diesem Beispiel sehen Sie, wie man eine Speichermethode über ein Objekt der `JTLwawiExtern.dll` ansteuern kann.
Wie im Abschnitt [JTLwawiExtern.dll einbinden](/jtlwawiextern/JTLwawiExterndll_einbinden) beschrieben, ist ein Objekt der Klasse `CJTLwawiExtern` in der Klasse `Worker` in einem privaten Feld initialisiert worden, auf das in der Methode `Speichern()` zugegriffen wird.
Der Speicherpfad ist in der Wawi hinterlegt und änderbar. Der Standardspeicherort befindet sich auf dem Desktop.
Mittels der folgenden Methode ist es möglich, entsprechende Rechnungen zu speichern.
## Code-Beispiel
```csharp theme={null}
class Worker
{
CJTLwawiExtern _wawiExtern = new CJTLwawiExtern();
public void Speichern(string server, string datenbank, string benutzer, string passwort, int kBenutzer, int key, int id)
{
this._wawiExtern.JTL_SpeicherRechnung(server, datenbank, benutzer, passwort, kBenutzer, key, id);
}
}
```
## Übergabeparameter
Zugangsdaten des Servers:
* **server**: Enthält den Servernamen
* **datenbank**: Enthält den Datenbanknamen. In der Wawi sollte dies standardmäßig **eazybusiness** sein
* **benutzer**: Enthält den Benutzernamen des Servers.
* **passwort**: Enthält das Passwort passend zum Benutzernamen.
* **kBenutzer**: Enthält den Key des Benutzers, der in diesem Fall die JTL-Wawi verwendet. Bsp.: Admin hat den Wert 1. Dieser Wert ist aus der Tabelle **tbenutzer** zu entnehmen.
* **key**: Enthält im Programmbeispiel den Wert **kRechnung** aus der Tabelle **trechnung**. In einer anderen Speicher Methode, wie z.B. **JTL\_SpeicherRechnungsKorrektur** muss man den Wert **kGutschrift** aus der Tabelle **tgutschrift** verwenden. Für jede weitere Speicher Methode muss ein entsprechender Key aus der entsprechenden Tabelle entnommen werden.
* **id**: Enthält den Wert von **kFormular** aus der Tabelle **tFormular** für den entsprechenden Namen in der Spalte **cName**, welcher das zugehörige Rechnungsformular auswählt.
## Weitere Speichermethoden
Es stehen noch weitere Speichermethoden zur Verfügung, mit denen weitere Dateien gespeichert werden können:
* `JTL_SpeicherRechnung`
* `JTL_SpeicherRechnungsKorrektur`
# Beispiel: Versanddatenimport
Source: https://developer.jtl-software.com/jtlwawiextern/VersanddatenimportBeispiel
In diesem Beispiel sehen Sie, wie man einen Versanddatenimport über ein Objekt der `JTLwawiExtern.dll` durchführen kann.
## Code-Beispiel
```csharp theme={null}
class Versandinformation
{
public string Id { get; set; }
public DateTime Versanddatum { get; set; }
public string TrackingId { get; set; }
public string VersandInfo { get; set; }
}
class WorkerVersand
{
CJTLwawiExtern _wawiExtern = new CJTLwawiExtern();
public void VersanddatenImport(string server, string datenbank, string benutzer, string passwort, int kBenutzer, IList versandinformationen)
{
//Ein Objekt vom VersanddatenImporter erzeugen
var versanddatenImporter = this._wawiExtern.VersanddatenImporter(server, datenbank, benutzer, passwort, kBenutzer);
//Versandinformationen in einer Schleife durchlaufen und dem VersanddatenImporter übergeben
foreach (var versandinformation in versandinformationen)
{
versanddatenImporter.Add(versandinformation.Id, versandinformation.Versanddatum, versandinformation.TrackingId, versandinformation.VersandInfo);
}
//Den Import bestätigen. Hier werden die Daten in die DB geschrieben.
versanddatenImporter.Apply();
}
}
```
## Übergabeparameter der Methode VersanddatenImport
Zugangsdaten des Servers:
* **server**: Enthält den Servernamen
* **datenbank**: Enthält den Datenbanknamen. In der Wawi sollte dies standardmäßig eazybusiness sein.
* **benutzer**: Enthält den Benutzernamen des Servers.
* **passwort**: Enthält das Passwort passend zum Benutzernamen.
* **kBenutzer**: Enthält den Key des Benutzers, der in diesem Fall die JTL-Wawi verwendet. Bsp.: Admin hat den Wert 1. Dieser Wert ist aus der Tabelle **tbenutzer** zu entnehmen.
* **versandinformationen**: Eine erzeugte Klasse für die Demonstation die Versanddaten enthält, es könnte genauso auch eine CSV oder Text Datei sein.
## Übergabeparameter der Methode VersanddatenImporter
*VersanddatenImporter.Add(string id, DateTime versandDatum, string trackingId, string versandinfo)*
**Id** kann folgendes sein:
* P1234 => 1234 = kVersand = InternePaketnummer
* V1234 => 1234 = kVersand = InternePaketnummer
* L1234 => 1234 = kLieferschein = InterneLieferscheinnummern
* AU12345-001 => Lieferscheinnummer (muss mit -XXX enden)
* AU12345-001\$1234 => Interne Paketnummer 1234 vom Lieferschein AU12345-001
* **VersandDatum**: Enthält das Versanddatum
* **TrackingId**: Enthält die Tracking-ID
* **Versandinfo**: Enthält die Versandinfo bzw. einen Hinweis
# Workflow Event-IDs
Source: https://developer.jtl-software.com/jtlwawiextern/WorkflowEventIDs
Hier finden Sie die Event-IDs, welche Sie mit der `JTLwawiExtern.dll` und den verfügbaren `JTL_Workflow`-Methoden nutzen können. Diese IDs lösen die unterschiedlichen Workflows für z.B. den Auftrag `20135` aus.
## void JTL\_WorkflowRechnung
Verfügbare Event IDs:
* 1 = Rechnung erstellt
* 3 = KomplettBezahlt
## void JTL\_WorkflowGutschriften
Verfügbare Event IDs:
* 1 = Gutschrift erstellt
* 2 = Gutschrift gelöscht
* 3 = Gutschrift geändert
*Bekannt als Rechnungskorrektur*
## void JTL\_WorkflowArtikel
Verfügbare Event IDs:
* 1 = Artikel erstellt
* 2 = Artikel geändert
* 3 = Artikel gelöscht
## void JTL\_WorkflowAuftrag
Verfügbare Event IDs:
* 1 = Auftrag erstellt
* 2 = Auftrag gelöscht
* 3 = Auftrag geändert
* 4 = Auftrag ausgeliefert
* 5 = Auftrag storniert
* 6 = Auftrag Zusammengefasst
* 7 = Auftrag Abgesplittet
* 9 = Auftrag Ohne Versand abgeschlossen
* 10 = Auftrag komplett bezahlt
## void JTL\_WorkflowEingangsrechnung
Verfügbare Event IDs:
* 1 = Eingangsrechnung erstellt
## void JTL\_WorkflowLieferantenbestellung
Verfügbare Event IDs:
* 0 = Lieferantenbestellung erstellt
* 1 = Lieferantenbestellung Abgeschlossen
* 2 = Lieferantenbestellung Freigegeben
* 3 = Lieferantenbestellung In Bearbeitung
* 5 = Lieferantenbestellung ist bestätigt
* 6 = Lieferantenbestellung Bestellposition reduziert
## void JTL\_WorkflowLieferschein
Verfügbare Event IDs:
* 1 = Lieferschein erstellt
* 2 = Lieferschein gelöscht
* 3 = Lieferschein versendet
## void JTL\_WorkflowPickliste
Verfügbare Event IDs:
* 1 = Pickliste erstellt
* 2 = Pickliste geändert
* 3 = Pickliste gepickt
* 4 = Pickliste abgeschlossen
## void JTL\_WorkflowWarenlagerausgang
Verfügbare Event IDs:
* 1 = Warenlagerausgang Fehlmenge
* 2 = Warenlagerausgang minusbuchung
## void JTL\_WorkflowWarenlagereingang
Verfügbare Event IDs:
* 1 = Warenlagereingang plusbuchung
## void JTL\_WorkflowZahlungserinnerung
Verfügbare Event IDs:
* 1 = Zahlungserinnerung erstellt
* 2 = Zahlungserinnerung gelöscht
* 3 = Zahlungserinnerung geändert
## void JTL\_WorkflowKunde
Verfügbare Event IDs:
* 1 = Kunde angelegt
* 2 = Kunde geändert
# Workflow-Methoden
Source: https://developer.jtl-software.com/jtlwawiextern/Workflowmethoden
In diesem Beispiel sehen Sie, wie man einen Workflow über ein Objekt der `JTLwawiExtern.dll` ansteuern kann. Im Beispielprojekt finden Sie dieses Beispiel in der Klasse `Worker` in der Methode `WorkFlow()`.
Wie im Abschnitt [JTLwawiExtern.dll einbinden](/jtlwawiextern/JTLwawiExterndll_einbinden) beschrieben, ist ein Objekt der Klasse `CJTLwawiExtern` in der Klasse `Worker` in einem privaten Feld initialisiert worden, auf das in der Methode `WorkFlow()` zugegriffen wird.
Mittels der folgenden Methode ist es möglich, einen Workflow für Aufträge anzusteuern, mit einer bestimmten Event-ID im Parameter `id`, die ein bestimmtes Ereignis repräsentiert.
## Code-Beispiel
```csharp theme={null}
class Worker
{
CJTLwawiExtern _wawiExtern = new CJTLwawiExtern();
public void WorkFlow(string server, string datenbank, string benutzer, string passwort, int kBenutzer, int key, int id)
{
this._wawiExtern.JTL_WorkflowAuftrag(server, datenbank, benutzer, passwort, kBenutzer, key, id);
}
}
```
## Übergabeparameter
Zugangsdaten des Servers:
* **server**: Enthält den Servernamen
* **datenbank**: Enthält den Datenbanknamen. In der Wawi sollte dies standardmäßig eazybusiness sein.
* **benutzer**: Enthält den Benutzernamen des Servers.
* **passwort**: Enthält das Passwort passend zum Benutzernamen.
* **kBenutzer**: Enthält den Key des Benutzers, der in diesem Fall die JTL-Wawi verwendet. Bsp.: Admin hat den Wert 1. Dieser Wert ist aus der Tabelle **tbenutzer** zu entnehmen
* **key**: Enthält im Programmbeispiel den Wert `kBestellung` aus der Tabelle `tBestellung`. In einem anderen Workflow, wie z.B. `JTL_WorkflowLieferschein`, muss man den Wert `kLieferschein` aus der Tabelle `tLieferschein` verwenden. Für jeden Workflow muss daher aus der entsprechenden Tabelle der Key entnommen werden, um den Workflow korrekt anzusteuern.
* **id**: Enthält die Event-ID, die pro Workflow-Methode verwendet wird, um ein bestimmtes Ereignis anzusteuern. Bsp.: Für einen Auftrag, dessen Ereignis **Auftrag erstellt** lautet, muss als Event-ID `1` angegeben werden.
Weitere `JTL_Workflow`-Methoden und Event-IDs finden Sie unter [Workflow Event-IDs](/jtlwawiextern/WorkflowEventIDs).
# Beispiel-XML-Dateien
Source: https://developer.jtl-software.com/jtlwawiextern/XML-Dateien
In den Downloads finden Sie mehrere Beispiel-XML-Dateien, die Sie zum Import über die `JTLwawiExtern.dll` verwenden können.
Dies sind nur Beispieldaten. Vor dem Import müssen alle relevanten Daten und Keys an Ihre Umgebung angepasst werden.
## Auftragsimport
Einzelauftrag mit Lagerartikeln und Variationskombinationen.
Einzelauftrag mit einer Stücklisten-Position.
Mehrere Aufträge in einer XML-Datei.
## Gutschriftenimport
Gutschrift mit Lagerartikel-Positionen.
Gutschrift mit einer Stücklisten-Position.
# JTL-Wawi Wiki für Externe Entwickler
Source: https://developer.jtl-software.com/jtlwawiextern/index
Diese Dokumentation richtet sich an externe Entwickler, die mit der `JTLwawiExtern.dll` gegen JTL-Wawi integrieren. Die Inhalte sind aus dem bisherigen Wiki übernommen und werden hier unverändert bereitgestellt.
## Allgemein
Einrichtung der DLL in Visual Studio inklusive Resolver und Versionsprüfung.
## Erweiterter XML Auftragsimport
Schema, Tags und Attribute für den Auftragsimport.
Code-Beispiel und Übergabeparameter von `JTL_OrderXmlImport()`.
## Erweiterter XML Gutschriftenimport
Code-Beispiel und Übergabeparameter von `JTL_CreditXmlImport()`.
## Versand, Druck und Speicher
Versanddaten per `VersanddatenImporter` in die Wawi schreiben.
Aufträge, Angebote und Rechnungen aus Code drucken.
Rechnungen und Rechnungskorrekturen speichern.
## Workflows
Workflows per Event-ID aus Code auslösen.
Referenzliste aller verfügbaren Event-IDs je Workflow.
## Downloads
Vollständiges C#-Projekt als ZIP.
Beispieldaten für Auftrags- und Gutschriftenimport.
# Concepts & Terminology
Source: https://developer.jtl-software.com/platform/concepts-terminology
Glossary of JTL Platform concepts: App Shell, SCX, ERP, and more
A reference of terms used throughout the JTL Platform docs. If you encounter an unfamiliar term in a guide, check here first. Industry-standard terms (OAuth 2.0, JWT, GraphQL, REST) are not defined here; refer to their specifications.
| Term | Definition |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **App Store** | The marketplace where JTL merchants discover and install Cloud Apps. Reachable at [apps.jtl-cloud.com](https://apps.jtl-cloud.com). Apps submitted through the Partner Portal are published here after review. |
| **AppBridge** | The messaging layer between your app's frontend running on either the ERP Cloud or JTL Hub. Built on iframe `postMessage`. Provides the session token, exposes host methods, and is scoped to iframe surfaces (ERP-iFrame and Panel). Packaged as [`@jtl-software/cloud-apps-core`](https://www.npmjs.com/package/@jtl-software/cloud-apps-core). See [App Shell & UI Integration](/guides/cloud-apps/app-shell-ui-integration). |
| **Client credentials** | The `clientId` and `clientSecret` pair issued by the Partner Portal when you create an app. Used by your backend to obtain access tokens via OAuth 2.0. The secret is shown only once at creation and can be recreated if lost. |
| **Cloud App** | An app built on the JTL Platform that integrates with JTL-Wawi. Consists of a manifest, a backend that calls the API, and optionally a frontend rendered in ERP Cloud. Distinct from OnPremise Wawi apps, which use a different registration flow. |
| **ERP Cloud** | The browser-based runtime where installed Cloud Apps render as iframes for merchants. Reachable at [erp.jtl-cloud.com](https://erp.jtl-cloud.com). Not to be confused with JTL Cloud (the install surface). |
| **ERP-iFrame** | A Cloud App integration type. Your frontend renders inside the main content area of ERP Cloud, reached from the ERP sidebar. Declared in the manifest under `capabilities.erp.menuItems`. See [Cloud Apps Architecture](/guides/cloud-apps/architecture-overview). |
| **Hub-Link** | A Cloud App integration type. Adds a card to JTL Hub; clicking redirects the merchant to a URL you specify. No iframe, no AppBridge, no session token; just a redirect. Declared under `capabilities.hub.appLauncher.redirectUrl`. |
| **JTL Cloud** | The overall install surface that includes JTL Hub. "JTL Hub" is the specific merchant-facing page; "JTL Cloud" is the broader platform namespace (e.g., `partner.jtl-cloud.com`, `hub.jtl-cloud.com`, `apps.jtl-cloud.com`). Not to be confused with ERP Cloud. |
| **JTL Hub** | The merchant-facing surface for discovering, launching, and managing installed apps. Reachable at [hub.jtl-cloud.com](https://hub.jtl-cloud.com). Developers also use Hub to install and test their own apps during development. |
| **JTL-Wawi** | JTL's ERP, the system at the centre of the merchant's business. Available as OnPremise (installed on the merchant's own server) or as JTL-Wawi Cloud (hosted by [ecomData](https://www.ecomdata.de/jtl-wawi-cloud-server/)). Holds products, stock, orders, customers, and invoices. |
| **Manifest** | A `manifest.json` file that declares your app's identity, lifecycle URLs, requirements, and capabilities. Uploaded to the Partner Portal at registration. Defines which surfaces your app integrates with (Hub-Link, ERP-iFrame, and Panel). See [App Shell & UI Integration](/guides/cloud-apps/app-shell-ui-integration). |
| **Panel** | A Cloud App integration type. Your frontend renders as a resizable sidebar on specific ERP Cloud views. Context-aware: the panel receives information about the current view (customer, order, product) and can react to navigation. Declared under `capabilities.erp.panel`. |
| **Partner Portal** | The portal where developers register apps, manage client credentials, and submit listings to the App Store. Reachable at [partner.jtl-cloud.com](https://partner.jtl-cloud.com). Currently requires email registration; SSO with JTL ID is planned. |
| **Scope** | A permission that gates access to a specific API resource or action. Declared in the manifest under `capabilities.erp.api.scopes` (Cloud Apps) or under `mandatoryApiScopes` / `optionalApiScopes` (OnPremise). Format: `resource.action` (e.g., `items.read`, `items.write`). |
| **SCX** | The API for OnPremise marketplace channel integrations. Used by channel apps to sync products and orders with external marketplaces (Amazon, eBay). Uses polling-based events: your channel calls GET `/v1/channel/event` to fetch events and DELETE `/v1/channel/event` to acknowledge them. Cloud App support is in development. See [webhooks](/guides/essentials/webhooks). |
| **Session token** | A short-lived JWT issued by AppBridge that identifies the current user, tenant, and session. Your frontend calls `appBridge.method.call('getSessionToken')` to obtain it, then sends it to your backend. Your backend verifies it via JWKS before trusting the tenant. Only issued for iframe surfaces (ERP-iFrame and Pane). See [API keys and tokens](/guides/essentials/authentication/api-keys-tokens). |
| **Tenant** | A merchant's isolated workspace in JTL Cloud. Each merchant has one tenant; all their data (products, orders, customers) belongs to that tenant. Identified by `tenantId` (a stable UUID) and `tenantSlug` (a human-readable identifier). Every Cloud API request must include `X-Tenant-ID` to specify which tenant's data to access. |
| **Tenant slug** | The human-readable identifier for a tenant (e.g., `acme-gmbh`). Used in URLs and panel context notation (`$tenantSlug.customers`). The `tenantId` is the stable UUID used for API calls; the slug can change. |
## What's Next
How the platform is structured and how the pieces relate.
The four integration types in detail, with manifest fields.
Auth, errors, pagination, webhooks, versioning.
OpenAPI reference for the Cloud API.
# Platform Overview
Source: https://developer.jtl-software.com/platform/overview
What JTL Cloud platform is and how the architecture works
The JTL Cloud platform is the developer surface for JTL Software’s ERP and commerce suite. It exposes core merchant systems (products, inventory, orders, and marketplace connectors) through APIs, a messaging layer, a manifest-based app model, and an App Store.
For hands-on setup, see [Get Started](/get-started/create-developer-account). For implementation detail on a specific app type, see [Cloud Apps Architecture](/guides/cloud-apps/architecture-overview).
## Platform Capabilities
| Capability | What you get | Reference |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------- |
| **Integration surfaces** | Render inside ERP Cloud, launch from a JTL Hub tile, or as a panel in ERP Cloud | [Integration Surfaces](#integration-surfaces) |
| **Data access** | Read and write merchant data (orders, products, customers, invoices) over REST and GraphQL | [Using Platform APIs](/guides/cloud-apps/using-platform-apis) |
| **Authentication** | OAuth 2.0 client credentials for your backend, short-lived session tokens for your frontend | [Security & Compliance](/platform/security-compliance) |
| **AppBridge** | Two-way messaging between your app and ERP Cloud for exchanging data and triggering events, | [App Shell & UI Integration](/guides/cloud-apps/app-shell-ui-integration) |
| **Design system** | Platform UI, a React component library matching the JTL look and feel | [App Shell & UI Integration](/guides/cloud-apps/app-shell-ui-integration) |
| **Distribution** | Register in the Partner Portal, publish to the App Store, install via JTL Hub | [Get Started](/get-started/create-developer-account) |
| **Monetization** | Configure pricing plans for your app. JTL handles invoicing, billing, and payouts on your behalf. *(Coming soon.)* | — |
| **Marketplace sync** | Connect a marketplace channel via SCX, a separate platform that integrates with JTL-Wawi | [Marketplace Channels](/guides/marketplace-channels/channel-api-overview) |
## Integration Surfaces
A Cloud App declares its integration surfaces in the `manifest.json`. Three types are available, and a single app can use any combination.
| Type | Where it renders | Communication | Typical use |
| -------------- | ------------------------------------------------------------------ | ---------------------------------- | ------------------------------------------------------------ |
| **Hub-Link** | Card in JTL-Cloud Hub; clicking redirects the merchant to your URL | None (redirect only) | Entry points to external tools and dashboards |
| **ERP-iFrame** | Main content area of ERP Cloud, reached from the ERP sidebar | AppBridge messaging | Rich interactive UI inside the merchant's ERP workspace |
| **Panel** | Sidebar panel on specific ERP Cloud views | AppBridge messaging; context-aware | Panels that react to the current customer, order, or product |
All three require app registration in the Partner Portal and OAuth 2.0 client credentials for backend API access. The UI-bearing types (ERP-iFrame and Panel) render as iframes and have full AppBridge access; the difference between them is placement. Hub-Link is a redirect, not an iframe.
See [Cloud Apps: Architecture](/guides/cloud-apps/architecture-overview) for more details.
## Developer Lifecycle
Building on JTL follows a consistent lifecycle, regardless of the integration surface.
```mermaid theme={null}
flowchart LR
A["Register app"] --> B["Build & test"]
B --> C["Create listing & pricing plan"]
C --> D["Merchants buy and install"]
style A fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style B fill:#FFF2EB,stroke:#FB581F,stroke-width:2px,color:#0B1B45
style C fill:#E8F4FF,stroke:#89D2FF,stroke-width:2px,color:#0B1B45
style D fill:#EEEEE7,stroke:#0B1B45,stroke-width:2px,color:#0B1B45
```
You register your app in the Partner Portal and receive client credentials. You build and test against a sandbox tenant inside the ERP shell. When ready, you create an App Store listing and attach a pricing plan. Approved apps become available for merchants to buy and install.
Each step is covered in [Get Started](/get-started/create-developer-account).
## What's Next
Set up accounts and ship your first app.
How a Cloud App is structured and communicates with JTL.
Auth, errors, pagination, webhooks, versioning.
OpenAPI reference for the Cloud API.
# Security & Compliance
Source: https://developer.jtl-software.com/platform/security-compliance
Data handling, authentication model, and compliance information for the JTL Platform
This guide describes the JTL Platform security model: how your app authenticates with the platform, how tenant access is enforced, and what responsibilities apply when handling merchant data.
## Trust Model
Three parties are involved when a merchant uses your app.
| Party | Role | Trusts |
| --------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
| **JTL Platform** | Issues credentials, verifies tokens, enforces tenant boundaries, hosts merchant data | Cryptographic proof (JWT signatures, client secrets) |
| **Your app** | Authenticates with JTL, reads and writes tenant data, declares the scopes it intends to use | Tokens issued by JTL; session claims verified via JWKS |
| **Merchant (tenant)** | Installs the app, owns the data | The platform to enforce tenant boundaries |
Security is enforced at the boundaries between these parties. The platform verifies your app’s identity using OAuth 2.0 client credentials. Your app verifies the merchant session by validating JWT signatures against the platform’s JWKS. The merchant grants access during installation and evaluates your app based on its behaviour.
No party trusts another by default. Every cross-boundary action is authenticated.
## Platform Security
The platform enforces the following security guarantees. These are platform-level properties and do not require configuration in your app.
### Authentication
How the platform verifies the identity of your app and the user's session.
* **OAuth 2.0 client credentials.** Your backend obtains access tokens from the Identity Provider using your `clientId` and `clientSecret`. Tokens are signed JWTs with a one-hour lifetime.
* **Session token verification via JWKS.** When your frontend (loaded inside ERP Cloud) passes a session token to your backend, your backend verifies it against the platform's JWKS endpoint: `https://api.jtl-cloud.com/account/.well-known/jwks.json`. Tokens that fail signature verification are rejected.
* **HTTPS enforced.** All platform endpoints require HTTPS. HTTP requests are rejected.
### Authorization
What an authenticated request is allowed to do, enforced at the API layer.
* **Scope-based access control.** Apps declare the API resources they need as scopes in the manifest. Declared scopes are validated at registration.
Scope enforcement at the API layer is being worked on and is not yet live. Today, declared scopes do not restrict what an app can call. This is a temporary state. Declare what your app actually needs so behavior stays consistent once enforcement ships.
* **Tenant isolation.** Every Cloud API request must include `X-Tenant-ID`. The platform enforces that the presenting app may only access data belonging to the specified tenant, and only tenants that have installed the app.
### Operational Security
The platform protects itself at runtime through the following:
* **API monitoring.** JTL monitors endpoint consumption, error rates, and request frequency across all apps. Anomalous patterns may trigger investigation.
* **Credential revocation.** JTL may revoke API credentials without prior notice if unauthorized use is suspected. This is a platform-level protection against compromised secrets.
* **Change notification commitments.** General API modifications (minor or breaking changes) are announced in advance. Emergency fixes for security incidents, critical errors, or external partner changes may be applied with less or no notice, with notification sent after the fact. For detail, see [versioning](/guides/essentials/common-patterns/versioning).
## Your Responsibilities
The platform protects its boundaries. Everything inside your app's boundary is your responsibility. The following checklist covers what every Cloud App should do.
### Credentials
Your `clientId` and `clientSecret` authenticate your app to the platform. Treat them as secrets.
* **Never ship `clientSecret` to the browser.** The secret belongs on your backend only. If it appears in frontend code, network requests, or a public repository, treat it as compromised and recreate it immediately in the Partner Portal.
* **Store secrets in a secrets manager or environment variables.** Not in source code, not in config files committed to version control.
* **Share credentials on a need-to-know basis.** Internal personnel, contractors, and external developers may access credentials only when their role requires it, and only when bound to the API License Terms.
* **Notify JTL immediately if credentials are lost or compromised.** Contact [partner@jtl-software.com](mailto:partner@jtl-software.com). The client secret can be regenerated; the client ID stays the same.
### Token Handling
Access tokens and session tokens are the credentials your app uses at runtime. Both need deliberate handling.
* **Verify every session token before trusting the tenant it claims.** Fetch the platform's JWKS, verify the JWT signature, check expiry. Never trust the `tenantId` in a session token payload without first verifying the signature.
* **Cache access tokens with a safety buffer.** Refresh before the token's `exp` claim with a 60-second margin, not after it expires.
* **Don't log tokens.** Access tokens and session tokens are credentials. Exclude them from application logs, error reports, and analytics.
### Scopes
Scopes define what your app can do on a merchant's behalf.
* **Request the minimum scopes your app actually uses.** Broader scopes mean broader blast radius if your app is compromised. Declare only what you need in `capabilities.erp.api.scopes`.
* **Treat scope requests as user-visible.** Merchants see the scopes you request at install time. Over-requesting damages trust and install conversion.
### Application Security
The platform secures its boundaries. Inside your app, you're responsible for the fundamentals.
* **Serve your app over HTTPS.** HTTPS is required for apps that run inside ERP Cloud and helps ensure they embed and function correctly.
* **Validate input from AppBridge messages.** Messages from the shell are still untrusted input. Validate types, bounds, and expected values before acting on them.
* **Handle tenant boundaries correctly.** If your app stores data keyed by tenant, every query and write must include the tenant ID from the verified session token to ensure data remains isolated between tenants.
### Incident Response
What to have in place before an incident and how to respond when one occurs.
* **Maintain an incident response plan.** Third-party providers must have an incident response plan for both privacy/security breaches and operational disruptions. JTL may request a copy during an audit.
* **Report security incidents promptly.** If your app experiences a data breach or suspected compromise affecting merchant data, report to [partner@jtl-software.com](mailto:partner@jtl-software.com) and to affected merchants per your data processing obligations.
## Data Handling and GDPR
Merchant data processed through the JTL Platform often qualifies as personal data under the GDPR. Customer names, contact information, order history, and transaction details are all personal data. This affects what your app can do with that data and what agreements must be in place.
### Your Role Under GDPR
Your role depends on the relationship between your app and the merchant.
| Your role | When it applies | Your obligation |
| ------------------------------ | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Independent data processor** | You provide an app that merchants install and use independently | Enter into a data processing agreement (DPA) directly with each merchant using your app. The merchant is the controller; you are their processor. |
| **JTL's data processor** | You were engaged by JTL to build, operate, or maintain a JTL product | Enter into a data processing agreement with JTL. JTL remains the processor for the merchant; you are a sub-processor. |
Most partner apps fall into the first category. If you're uncertain which applies, consult your legal team.
### Data Minimisation
GDPR favours holding less data for less time. The platform can't enforce this for you; it's a property of how your app handles data once it has it.
* **Only fetch the data your app needs.** Broad scopes and over-fetching create GDPR risk that you're responsible for, not the platform.
* **Don't persist data longer than necessary.** If your app can operate statelessly or with short-lived caches, prefer that over indefinite storage.
* **Respect deletion requests.** When a merchant uninstalls your app or requests data deletion, delete the data you hold on their behalf within a reasonable period.
## Reporting Security Issues
If you discover a vulnerability in the JTL Platform, report it to [partner@jtl-software.com](mailto:partner@jtl-software.com) rather than disclosing it publicly.
For security issues in your own app affecting merchant data, follow the incident [response guidance](/platform/security-compliance#incident-response) above.
## What's Next
Full detail on client credentials and session token flows.
API versioning and breaking change commitments.
Production readiness checklist for Cloud Apps.
# API Client Libraries
Source: https://developer.jtl-software.com/sdks-tools/api-client-libraries
Auto-generated API client libraries for various languages
This page is a stub. Content coming soon.
# C# / .NET SDK
Source: https://developer.jtl-software.com/sdks-tools/csharp-dotnet-sdk
Official JTL SDK for C# and .NET
This page is a stub. Content coming soon.
# JavaScript / TypeScript SDK
Source: https://developer.jtl-software.com/sdks-tools/javascript-typescript-sdk
Official JTL SDK for JavaScript and TypeScript, including React Hooks
This page is a stub. Content coming soon.
# JTL CLI
Source: https://developer.jtl-software.com/sdks-tools/jtl-cli
Command-line interface for JTL app development, auth, and scaffolding
This page is a stub. Content coming soon.
# PHP SDK
Source: https://developer.jtl-software.com/sdks-tools/php-sdk
Official JTL SDK for PHP
This page is a stub. Content coming soon.
# VS Code Extension
Source: https://developer.jtl-software.com/sdks-tools/vscode-extension
JTL extension for Visual Studio Code
This page is a stub. Content coming soon.
# Cloud App Starter (React)
Source: https://developer.jtl-software.com/templates/cloud-app-react
React starter template for building JTL Cloud Apps
This page is a stub. Content coming soon.
# Cloud App Starter (Vue)
Source: https://developer.jtl-software.com/templates/cloud-app-vue
Vue.js starter template for building JTL Cloud Apps
This page is a stub. Content coming soon.
# Marketplace Channel Starter
Source: https://developer.jtl-software.com/templates/marketplace-channel-starter
Starter template for building JTL marketplace channel integrations
This page is a stub. Content coming soon.
# Webhook Handler Template
Source: https://developer.jtl-software.com/templates/webhook-handler
Template for handling JTL Platform webhook events
This page is a stub. Content coming soon.
# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# GraphQL playground
Source: https://developer.jtl-software.com/api-reference/graphql-playground
Interactive GraphQL IDE to explore and test the JTL Platform API
Explore the JTL ERP API using GraphQL. Use the schema explorer on the left to
browse available queries and mutations, or type directly in the editor. Log in
to run queries against your own ERP instance.
Best Viewed on Desktop
The GraphQL playground is a full interactive IDE built for larger screens.
Open this page on a desktop or tablet to browse the schema and run queries.
# Query Accounting Data
Source: https://developer.jtl-software.com/api-reference/v2.0/accountingdata/query-accounting-data
/openapi/2.0.json get /v2/accountingData
Delivers a paginated overview of finalized accounting transactions, including invoices, credits, and their cancellations and corrections.
# Fetch Registration Status
Source: https://developer.jtl-software.com/api-reference/v2.0/appregistration/fetch-registration-status
/openapi/2.0.json get /v2/authentication/{registrationId}
Obtain information about a registration request
# Register App
Source: https://developer.jtl-software.com/api-reference/v2.0/appregistration/register-app
/openapi/2.0.json post /v2/authentication
Send a registration request for an (external) application
# Register Multi Instance App
Source: https://developer.jtl-software.com/api-reference/v2.0/appregistration/register-multi-instance-app
/openapi/2.0.json post /v2/authentication/{registrationId}
Sends a registration request for another instance of the same application
# Deletes a bill of materials item from a bill of materials.
Source: https://developer.jtl-software.com/api-reference/v2.0/billofmaterialscomponentscommand/deletes-a-bill-of-materials-item-from-a-bill-of-materials
/openapi/2.0.json delete /v2/bill-of-materials-items/{id}/delete
# Retrieves a bill of materials item by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/billofmaterialscomponentsquery/retrieves-a-bill-of-materials-item-by-its-id
/openapi/2.0.json get /v2/bill-of-materials-items/{id}
# Retrieves a bill of materials operation by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/billofmaterialscomponentsquery/retrieves-a-bill-of-materials-operation-by-its-id
/openapi/2.0.json get /v2/bill-of-materials-operations/{id}
# Query Availabilities
Source: https://developer.jtl-software.com/api-reference/v2.0/item/query-availabilities
/openapi/2.0.json get /v2/availabilities
Query all availabilites for items
# Query Conditions
Source: https://developer.jtl-software.com/api-reference/v2.0/item/query-conditions
/openapi/2.0.json get /v2/conditions
Query all item conditions
# Query Responsible Persons
Source: https://developer.jtl-software.com/api-reference/v2.0/item/query-responsible-persons
/openapi/2.0.json get /v2/responsiblePersons
Query all ResponsiblePerson
# Query Shipping Classes
Source: https://developer.jtl-software.com/api-reference/v2.0/item/query-shipping-classes
/openapi/2.0.json get /v2/shippingClasses
Query all shipping classes
# Query Tax Classes
Source: https://developer.jtl-software.com/api-reference/v2.0/item/query-tax-classes
/openapi/2.0.json get /v2/taxClasses
Query all tax classes
# Login
Source: https://developer.jtl-software.com/api-reference/v2.0/login/login
/openapi/2.0.json post /v2/authentication/login
Sends a request to log in the user / dynamically assign the WAWI user. Only use this request if your API uses SSL.
# Logout
Source: https://developer.jtl-software.com/api-reference/v2.0/logout/logout
/openapi/2.0.json post /v2/authentication/logout
Sends a request to log out the user
# Deletes a bill of materials operation from a bill of materials.
Source: https://developer.jtl-software.com/api-reference/v2.0/billofmaterialscomponentscommand/deletes-a-bill-of-materials-operation-from-a-bill-of-materials
/openapi/2.0.json delete /v2/bill-of-materials-operations/{id}/delete
# Deletes a bill of materials.
Source: https://developer.jtl-software.com/api-reference/v2.0/billsofmaterialscommand/deletes-a-bill-of-materials
/openapi/2.0.json delete /v2/bills-of-materials/{id}/delete
# Retrieves a bill of materials by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/billsofmaterialsquery/retrieves-a-bill-of-materials-by-its-id
/openapi/2.0.json get /v2/bills-of-materials/{id}
# Query Cancellation Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/cancellationreason/query-cancellation-reasons
/openapi/2.0.json get /v2/cancellationReasons
Query all cancellation reasons for sales orders
# Query Invoice Cancellation Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/cancellationreason/query-invoice-cancellation-reasons
/openapi/2.0.json get /v2/invoices/cancellationReasons
Query all cancellation reasons for invoices
# Query Refund Cancellation Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/cancellationreason/query-refund-cancellation-reasons
/openapi/2.0.json get /v2/refunds/cancellationReasons
Query all cancellation reasons for refunds
# Query Sales Invoice Correction Cancellation Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/cancellationreason/query-sales-invoice-correction-cancellation-reasons
/openapi/2.0.json get /v2/salesInvoiceCorrections/cancellationReasons
Query all cancellation reasons for sales invoice corrections
# Query Sales Order Cancellation Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/cancellationreason/query-sales-order-cancellation-reasons
/openapi/2.0.json get /v2/salesOrders/cancellationReasons
Query all cancellation reasons for sales orders
# Creates a new Category.
Source: https://developer.jtl-software.com/api-reference/v2.0/categorycommand/creates-a-new-category
/openapi/2.0.json post /v2/CreateCategory
# Delete a Category
Source: https://developer.jtl-software.com/api-reference/v2.0/categorycommand/delete-a-category
/openapi/2.0.json delete /v2/DeleteCategory
# Updates a new Category
Source: https://developer.jtl-software.com/api-reference/v2.0/categorycommand/updates-a-new-category
/openapi/2.0.json patch /v2/UpdateCategory
# Delivers a single category
Source: https://developer.jtl-software.com/api-reference/v2.0/categoryquery/delivers-a-single-category
/openapi/2.0.json get /v2/category/{CategoryId}
# Query Color Codes
Source: https://developer.jtl-software.com/api-reference/v2.0/colorcodes/query-color-codes
/openapi/2.0.json get /v2/colorCodes
Query all color codes for sales orders
# Query Companies
Source: https://developer.jtl-software.com/api-reference/v2.0/company/query-companies
/openapi/2.0.json get /v2/companies
Query all companies
# Delivers a single company
Source: https://developer.jtl-software.com/api-reference/v2.0/companydetailsquery/delivers-a-single-company
/openapi/2.0.json get /v2/company/{CompanyId}
# Create Number Range
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/create-number-range
/openapi/2.0.json post /v2/configuration/numberRanges/{numberRangeId}
Create a new NumberRange based on the given NumberRange
# Delete Number Range
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/delete-number-range
/openapi/2.0.json delete /v2/configuration/numberRanges/{numberRangeId}
Delete a NumberRange, but only Deletable Numberranges
# Get Number Range
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/get-number-range
/openapi/2.0.json get /v2/configuration/numberRanges/{numberRangeId}
Returns the requested NumberRange
# Get Number Ranges
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/get-number-ranges
/openapi/2.0.json get /v2/configuration/numberRanges
Returns all available Number Ranges
# Number Range Increment
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/number-range-increment
/openapi/2.0.json post /v2/configuration/numberRanges/{numberRangeId}/increment
Increment and returns the Next Number for the given NumberRange
# Number Range Preview
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/number-range-preview
/openapi/2.0.json get /v2/configuration/numberRanges/{numberRangeId}/preview
Returns a Preview of the Next Number for the given NumberRange
# Update Number Range
Source: https://developer.jtl-software.com/api-reference/v2.0/configuration/update-number-range
/openapi/2.0.json put /v2/configuration/numberRanges/{numberRangeId}
Updates an Existing NumberRange
# Post v2copyitemdetails
Source: https://developer.jtl-software.com/api-reference/v2.0/copyitemdetailscommand/post-v2copyitemdetails
/openapi/2.0.json post /v2/CopyItemdetails
# Definition to query countries
Source: https://developer.jtl-software.com/api-reference/v2.0/countryquery/definition-to-query-countries
/openapi/2.0.json get /v2/Countries/QueryCountries
# Creates a new bill of materials for a production item, including its components.
Source: https://developer.jtl-software.com/api-reference/v2.0/createcommand/creates-a-new-bill-of-materials-for-a-production-item-including-its-components
/openapi/2.0.json post /v2/production-items/{productionItemId}/bills-of-materials/create
# Creates a new bill of materials item for a bill of materials operation.
Source: https://developer.jtl-software.com/api-reference/v2.0/createcommand/creates-a-new-bill-of-materials-item-for-a-bill-of-materials-operation
/openapi/2.0.json post /v2/bill-of-materials-operations/{billOfMaterialsOperationId}/bill-of-materials-items/create
# Creates a new bill of materials operation for a bill of materials, including its items.
Source: https://developer.jtl-software.com/api-reference/v2.0/createcommand/creates-a-new-bill-of-materials-operation-for-a-bill-of-materials-including-its-items
/openapi/2.0.json post /v2/bills-of-materials/{billOfMaterialsId}/bill-of-materials-operations/create
# Creates a new lot size for a production item.
Source: https://developer.jtl-software.com/api-reference/v2.0/createcommand/creates-a-new-lot-size-for-a-production-item
/openapi/2.0.json post /v2/production-items/{productionItemId}/lot-sizes/create
# Creates a new production item, including its bills of materials with their components.
Source: https://developer.jtl-software.com/api-reference/v2.0/createcommand/creates-a-new-production-item-including-its-bills-of-materials-with-their-components
/openapi/2.0.json post /v2/production-items/create
# Mail Credit Note
Source: https://developer.jtl-software.com/api-reference/v2.0/creditnote/mail-credit-note
/openapi/2.0.json post /v2/creditNotes/{creditNoteId}/output/mail
Execute the mailing of a CreditNote
# Pdf Credit Note
Source: https://developer.jtl-software.com/api-reference/v2.0/creditnote/pdf-credit-note
/openapi/2.0.json post /v2/creditNotes/{creditNoteId}/output/pdf
Execute the pdf creation of a CreditNote
# Print Credit Note
Source: https://developer.jtl-software.com/api-reference/v2.0/creditnote/print-credit-note
/openapi/2.0.json post /v2/creditNotes/{creditNoteId}/output/print
Execute the printing of a CreditNote
# Create Customer
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/create-customer
/openapi/2.0.json post /v2/customers
Create a new customer
# Create Customer Bank Account
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/create-customer-bank-account
/openapi/2.0.json post /v2/customers/{customerId}/bankaccounts
Create a new bank account for a specific customer
# Create Customer Contact
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/create-customer-contact
/openapi/2.0.json post /v2/customers/{customerId}/contacts
Create a new customer contact
# Create Customer Note
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/create-customer-note
/openapi/2.0.json post /v2/customers/{customerId}/notes
Create a new note for a specific customer
# Delete Customer
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/delete-customer
/openapi/2.0.json delete /v2/customers/{customerId}
Delete a specific customer
# Delete Customer Bank Account
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/delete-customer-bank-account
/openapi/2.0.json delete /v2/customers/{customerId}/bankaccounts/{customerBankAccountId}
Delete a specific bank account
# Delete Customer Contact
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/delete-customer-contact
/openapi/2.0.json delete /v2/customers/{customerId}/contacts/{customerContactId}
Delete a specific customer concact
# Delete Customer Custom Field
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/delete-customer-custom-field
/openapi/2.0.json delete /v2/customers/{customerId}/customfields/{customfieldId}
Delete the value for a specific customer field for a given customer
# Delete Customer Note
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/delete-customer-note
/openapi/2.0.json delete /v2/customers/{customerId}/notes/{noteId}
Delete a specific note for a customer
# Get Customer
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/get-customer
/openapi/2.0.json get /v2/customers/{customerId}
Get a specific customer
# Get Customer Bank Account
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/get-customer-bank-account
/openapi/2.0.json get /v2/customers/{customerId}/bankaccounts/{customerBankAccountId}
Get a specific bank account
# Get Customer Contact
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/get-customer-contact
/openapi/2.0.json get /v2/customers/{customerId}/contacts/{customerContactId}
Get a specific contact from a customer
# Get Customer Last Change
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/get-customer-last-change
/openapi/2.0.json get /v2/customers/{customerId}/lastChange
Get the date of the last change for a customer
# Get Customer Note
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/get-customer-note
/openapi/2.0.json get /v2/customers/{customerId}/notes/{noteId}
Get a specific note from a customer
# Query Customer Bank Accounts
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customer-bank-accounts
/openapi/2.0.json get /v2/customers/{customerId}/bankaccounts
Query all bank accounts for a specific customer
# Query Customer Contacts
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customer-contacts
/openapi/2.0.json get /v2/customers/{customerId}/contacts
Query all contacts for a specific customer
# Query Customer Custom Field Values
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customer-custom-field-values
/openapi/2.0.json get /v2/customers/{customerId}/customfields
Query all custom fields and corresponding values for a specific customer
# Query Customer Custom Fields
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customer-custom-fields
/openapi/2.0.json get /v2/customers/customfields
Query all custom fields available for a customer
# Query Customer Notes
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customer-notes
/openapi/2.0.json get /v2/customers/{customerId}/notes
Query all notes for a specific customer
# Query Customer Workflow Events
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customer-workflow-events
/openapi/2.0.json get /v2/customers/workflowEvents
Query all workflow events for customers
# Query Customers
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/query-customers
/openapi/2.0.json get /v2/customers
Query all customers
# Trigger Customer Workflow
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/trigger-customer-workflow
/openapi/2.0.json post /v2/customers/{customerId}/workflow/{workflowEventId}
Trigger a specific workflow event for a given customer
# Trigger Customer Workflow Event
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/trigger-customer-workflow-event
/openapi/2.0.json post /v2/customers/{customerId}/workflowEvents
Trigger a specific workflow event for a given customer
# Update Customer
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/update-customer
/openapi/2.0.json patch /v2/customers/{customerId}
Update a specific customer
# Update Customer Bank Account
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/update-customer-bank-account
/openapi/2.0.json patch /v2/customers/{customerId}/bankaccounts/{customerBankAccountId}
Update a specific bank account
# Update Customer Contact
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/update-customer-contact
/openapi/2.0.json patch /v2/customers/{customerId}/contacts/{customerContactId}
Update a specific customer contact
# Update Customer Custom Field
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/update-customer-custom-field
/openapi/2.0.json patch /v2/customers/{customerId}/customfields/{customfieldId}
Update the value of a specific custom field for a given customer
# Update Customer Note
Source: https://developer.jtl-software.com/api-reference/v2.0/customer/update-customer-note
/openapi/2.0.json patch /v2/customers/{customerId}/notes/{noteId}
Update a specific note for a customer
# Create Customer Category
Source: https://developer.jtl-software.com/api-reference/v2.0/customercategory/create-customer-category
/openapi/2.0.json post /v2/customerCategories
Create a new customer category
# Delete Customer Category
Source: https://developer.jtl-software.com/api-reference/v2.0/customercategory/delete-customer-category
/openapi/2.0.json delete /v2/customerCategories/{customercategoryId}
Delete a specific customercategory
# Get Customer Category
Source: https://developer.jtl-software.com/api-reference/v2.0/customercategory/get-customer-category
/openapi/2.0.json get /v2/customerCategories/{customercategoryId}
Get a specific customercategory
# Query Customer Categories
Source: https://developer.jtl-software.com/api-reference/v2.0/customercategory/query-customer-categories
/openapi/2.0.json get /v2/customerCategories
Query all customer categories
# Update Customer Category
Source: https://developer.jtl-software.com/api-reference/v2.0/customercategory/update-customer-category
/openapi/2.0.json patch /v2/customerCategories/{customercategoryId}
Update a specific customer category
# Creates a customer
Source: https://developer.jtl-software.com/api-reference/v2.0/customerdomaincommand/creates-a-customer
/openapi/2.0.json post /v2/customer/create
# Updates a customer
Source: https://developer.jtl-software.com/api-reference/v2.0/customerdomaincommand/updates-a-customer
/openapi/2.0.json patch /v2/customer/update
# Delivers a single customer by its id
Source: https://developer.jtl-software.com/api-reference/v2.0/customerdomainquery/delivers-a-single-customer-by-its-id
/openapi/2.0.json get /v2/customer/{CustomerId}
# Create Customer Group
Source: https://developer.jtl-software.com/api-reference/v2.0/customergroup/create-customer-group
/openapi/2.0.json post /v2/customerGroups
Create a new customer group
# Delete Customer Group
Source: https://developer.jtl-software.com/api-reference/v2.0/customergroup/delete-customer-group
/openapi/2.0.json delete /v2/customerGroups/{customergroupId}
Delete a specific customergroup
# Get Customer Group
Source: https://developer.jtl-software.com/api-reference/v2.0/customergroup/get-customer-group
/openapi/2.0.json get /v2/customerGroups/{customergroupId}
Get a specific customergroup
# Query Customer Groups
Source: https://developer.jtl-software.com/api-reference/v2.0/customergroup/query-customer-groups
/openapi/2.0.json get /v2/customerGroups
Query all customer groups
# Update Customer Group
Source: https://developer.jtl-software.com/api-reference/v2.0/customergroup/update-customer-group
/openapi/2.0.json patch /v2/customerGroups/{customergroupId}
Update a specific customer group
# Get Delivery Note
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/get-delivery-note
/openapi/2.0.json get /v2/deliveryNotes/{deliveryNoteId}
Get a specific delivery note
# Get Delivery Note Packages
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/get-delivery-note-packages
/openapi/2.0.json get /v2/deliveryNotes/{deliveryNoteId}/packages
Get all packages for a specific delivery note
# Mail Delivery Note
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/mail-delivery-note
/openapi/2.0.json post /v2/deliveryNotes/{deliveryNoteId}/output/mail
Execute the mailing of a DeliveryNote
# Patch Package Data
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/patch-package-data
/openapi/2.0.json patch /v2/deliveryNotes/packages/{packageId}
Transmit Package Data
# Pdf Delivery Note
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/pdf-delivery-note
/openapi/2.0.json post /v2/deliveryNotes/{deliveryNoteId}/output/pdf
Execute the pdf creation of a DeliveryNote
# Post Package Data For Delivery Note
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/post-package-data-for-delivery-note
/openapi/2.0.json post /v2/deliveryNotes/{deliveryNoteId}/packages
Transmit Package Data
# Print Delivery Note
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/print-delivery-note
/openapi/2.0.json post /v2/deliveryNotes/{deliveryNoteId}/output/print
Execute the printing of a DeliveryNote
# Query Delivery Notes
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/query-delivery-notes
/openapi/2.0.json get /v2/deliveryNotes
Query all delivery notes
# Trigger Delivery Note Workflow
Source: https://developer.jtl-software.com/api-reference/v2.0/deliverynote/trigger-delivery-note-workflow
/openapi/2.0.json post /v2/deliveryNotes/{deliveryNoteId}/workflow/{workflowEventId}
Trigger a specific workflow event for a given delivery Note
# Creates one or more duplicates of an existing item with specified duplication options.
Source: https://developer.jtl-software.com/api-reference/v2.0/duplicateitemcommand/creates-one-or-more-duplicates-of-an-existing-item-with-specified-duplication-options
/openapi/2.0.json post /v2/DuplicateItems
# Create Extension
Source: https://developer.jtl-software.com/api-reference/v2.0/extensibility/create-extension
/openapi/2.0.json post /v2/extensions
Create a new Extension and Validate the Signature of the Manifest
# Delete Extension
Source: https://developer.jtl-software.com/api-reference/v2.0/extensibility/delete-extension
/openapi/2.0.json delete /v2/extensions/{extensionId}
DELETE an existing Extension
# Get Extension
Source: https://developer.jtl-software.com/api-reference/v2.0/extensibility/get-extension
/openapi/2.0.json get /v2/extensions/{extensionId}
Returns the requested Extension
# Get Extensions
Source: https://developer.jtl-software.com/api-reference/v2.0/extensibility/get-extensions
/openapi/2.0.json get /v2/extensions
Returns the installed Extensions
# Put Extension Manifest
Source: https://developer.jtl-software.com/api-reference/v2.0/extensibility/put-extension-manifest
/openapi/2.0.json put /v2/extensions/{extensionId}/manifest
Push the Extension Manifest
# Update Extension
Source: https://developer.jtl-software.com/api-reference/v2.0/extensibility/update-extension
/openapi/2.0.json patch /v2/extensions/{extensionId}
Updates an Existing Extension
# Get Features
Source: https://developer.jtl-software.com/api-reference/v2.0/features/get-features
/openapi/2.0.json get /v2/feature
Returns the available feature sets with release state and API version
# Get Status
Source: https://developer.jtl-software.com/api-reference/v2.0/info/get-status
/openapi/2.0.json get /v2/info
Returns the status of the API
# Get Invoice
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/get-invoice
/openapi/2.0.json get /v2/invoices/{invoiceId}
Get a specific invoice
# Mail Invoice
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/mail-invoice
/openapi/2.0.json post /v2/invoices/{invoiceId}/output/mail
Execute the mailing of a Invoice
# Pdf Invoice
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/pdf-invoice
/openapi/2.0.json post /v2/invoices/{invoiceId}/output/pdf
Execute the pdf creation of a Invoice
# Print Invoice
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/print-invoice
/openapi/2.0.json post /v2/invoices/{invoiceId}/output/print
Execute the printing of a Invoice
# Query Invoice Line Items
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/query-invoice-line-items
/openapi/2.0.json get /v2/invoices/{invoiceId}/lineitems
Query all line items for a specific invoice
# Query Invoice Workflow Events
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/query-invoice-workflow-events
/openapi/2.0.json get /v2/invoices/workflowEvents
Query all available workflow events for invoices
# Query Invoices
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/query-invoices
/openapi/2.0.json get /v2/invoices
Query all Invoices
# Trigger Invoice Workflow
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/trigger-invoice-workflow
/openapi/2.0.json post /v2/invoices/{invoiceId}/workflow/{workflowEventId}
Trigger a specific workflow event for a given invoice
# Trigger Invoice Workflow Event
Source: https://developer.jtl-software.com/api-reference/v2.0/invoice/trigger-invoice-workflow-event
/openapi/2.0.json post /v2/invoices/{invoiceId}/workflowEvents
Trigger a specific workflow event for a given invoice
# Exclude marketplace invoice correction PDFs from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/invoicingcommand/exclude-marketplace-invoice-correction-pdfs-from-upload
/openapi/2.0.json post /v2/Marketplace/Invoicing/ExcludeInvoiceCorrectionPdfFromUpload
# Exclude marketplace invoice corrections from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/invoicingcommand/exclude-marketplace-invoice-corrections-from-upload
/openapi/2.0.json post /v2/Marketplace/Invoicing/ExcludeInvoiceCorrectionFromUpload
# Exclude marketplace invoice PDFs from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/invoicingcommand/exclude-marketplace-invoice-pdfs-from-upload
/openapi/2.0.json post /v2/Marketplace/Invoicing/ExcludeInvoicePdfFromUpload
# Reset the upload counter for marketplace invoice correction PDFs.
Source: https://developer.jtl-software.com/api-reference/v2.0/invoicingcommand/reset-the-upload-counter-for-marketplace-invoice-correction-pdfs
/openapi/2.0.json post /v2/Marketplace/Invoicing/ResetInvoiceCorrectionPdfUploadCounter
# Reset the upload counter for marketplace invoice corrections.
Source: https://developer.jtl-software.com/api-reference/v2.0/invoicingcommand/reset-the-upload-counter-for-marketplace-invoice-corrections
/openapi/2.0.json post /v2/Marketplace/Invoicing/ResetInvoiceCorrectionUploadCounter
# Resets PDF generation for marketplace invoices/invoice corrections so they can be reprinted and uploaded again.
Source: https://developer.jtl-software.com/api-reference/v2.0/invoicingcommand/resets-pdf-generation-for-marketplace-invoicesinvoice-corrections-so-they-can-be-reprinted-and-uploaded-again
/openapi/2.0.json post /v2/Marketplace/Invoicing/ResetInvoicePdfPrinting
# Adds a new value to an existing item variation.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/adds-a-new-value-to-an-existing-item-variation
/openapi/2.0.json post /v2/itemdetails/variationvalues/add
# Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/adds-a-new-variation-eg-color-size-to-an-existing-item-variations-allow-customers-to-select-different-product-options
/openapi/2.0.json post /v2/itemdetails/variations/add
# Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/adds-supplier-information-to-an-existing-regular-item-this-command-allows-the-association-of-suppliers-with-the-item-including-details-such-as-purchase-prices-delivery-times-and-order-intervals
/openapi/2.0.json post /v2/itemdetails/suppliers/add
# Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/creates-a-new-regular-item-with-all-specified-properties-this-command-enables-complete-configuration-of-an-item-including-identifiers-descriptions-prices-and-measurements
/openapi/2.0.json post /v2/itemdetails/create
# Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/modifies-an-existing-regular-item-with-all-specified-properties-this-command-enables-complete-reconfiguration-of-an-item-including-identifiers-descriptions-prices-measurements-and-miscellaneous-information
/openapi/2.0.json patch /v2/itemdetails/change
# Removes a specific value from an item variation.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/removes-a-specific-value-from-an-item-variation
/openapi/2.0.json post /v2/itemdetails/variationvalues/delete
# Removes an existing variation from an item. All associated variation values and combinations will also be removed.
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailscommand/removes-an-existing-variation-from-an-item-all-associated-variation-values-and-combinations-will-also-be-removed
/openapi/2.0.json post /v2/itemdetails/variations/delete
# Retrieves a single article by its ID including all sub-elements
Source: https://developer.jtl-software.com/api-reference/v2.0/itemdetailsquery/retrieves-a-single-article-by-its-id-including-all-sub-elements
/openapi/2.0.json get /v2/items/{Id}
# Activates a language in the system
Source: https://developer.jtl-software.com/api-reference/v2.0/languagescommand/activates-a-language-in-the-system
/openapi/2.0.json post /v2/languages/activate
# Deactivates a language in the system
Source: https://developer.jtl-software.com/api-reference/v2.0/languagescommand/deactivates-a-language-in-the-system
/openapi/2.0.json post /v2/languages/deactivate
# Query for activated languages
Source: https://developer.jtl-software.com/api-reference/v2.0/languagesquery/query-for-activated-languages
/openapi/2.0.json get /v2/languages/QueryLanguages
# Retrieves a lot size by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/lotsizesquery/retrieves-a-lot-size-by-its-id
/openapi/2.0.json get /v2/lot-sizes/{id}
# Mail Offer
Source: https://developer.jtl-software.com/api-reference/v2.0/offer/mail-offer
/openapi/2.0.json post /v2/offer/{offerId}/output/mail
Execute the mailing of a Offer
# Pdf Offer
Source: https://developer.jtl-software.com/api-reference/v2.0/offer/pdf-offer
/openapi/2.0.json post /v2/offer/{offerId}/output/pdf
Execute the pdf creation of a Offer
# Print Offer
Source: https://developer.jtl-software.com/api-reference/v2.0/offer/print-offer
/openapi/2.0.json post /v2/offer/{offerId}/output/print
Execute the printing of a Offer
# Deletes the specified marketplace offers.
Source: https://developer.jtl-software.com/api-reference/v2.0/offerscommand/deletes-the-specified-marketplace-offers
/openapi/2.0.json post /v2/Marketplace/Offers/DeleteOffer
# Removes the item assignment from the specified marketplace offers.
Source: https://developer.jtl-software.com/api-reference/v2.0/offerscommand/removes-the-item-assignment-from-the-specified-marketplace-offers
/openapi/2.0.json post /v2/Marketplace/Offers/RemoveItemFromOffer
# Sets the maximum stock quantity for the specified marketplace offers.
Source: https://developer.jtl-software.com/api-reference/v2.0/offerscommand/sets-the-maximum-stock-quantity-for-the-specified-marketplace-offers
/openapi/2.0.json post /v2/Marketplace/Offers/SetOfferMaxQuantity
# Sets the minimum stock quantity for the specified marketplace offers.
Source: https://developer.jtl-software.com/api-reference/v2.0/offerscommand/sets-the-minimum-stock-quantity-for-the-specified-marketplace-offers
/openapi/2.0.json post /v2/Marketplace/Offers/SetOfferMinQuantity
# Triggers stock synchronisation for the specified marketplace offers.
Source: https://developer.jtl-software.com/api-reference/v2.0/offerscommand/triggers-stock-synchronisation-for-the-specified-marketplace-offers
/openapi/2.0.json post /v2/Marketplace/Offers/TriggerStockSynchronisation
# Query On Hold Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/onholdreason/query-on-hold-reasons
/openapi/2.0.json get /v2/onHoldReasons
Query all on hold reasons for sales orders
# Cancel marketplace order cancellation request uploads.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/cancel-marketplace-order-cancellation-request-uploads
/openapi/2.0.json post /v2/Marketplace/Orders/CancelOrderCancellationRequestUpload
# Exclude marketplace order cancellation uploads from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/exclude-marketplace-order-cancellation-uploads-from-upload
/openapi/2.0.json post /v2/Marketplace/Orders/ExcludeOrderCancellationUploadFromUpload
# Exclude marketplace payment uploads from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/exclude-marketplace-payment-uploads-from-upload
/openapi/2.0.json post /v2/Marketplace/Orders/ExcludePaymentUploadFromUpload
# Exclude marketplace return uploads from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/exclude-marketplace-return-uploads-from-upload
/openapi/2.0.json post /v2/Marketplace/Orders/ExcludeReturnUploadFromUpload
# Exclude marketplace shipping information uploads from upload.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/exclude-marketplace-shipping-information-uploads-from-upload
/openapi/2.0.json post /v2/Marketplace/Orders/ExcludeShippingInformationUploadFromUpload
# Reset the upload counter for marketplace order cancellation uploads.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/reset-the-upload-counter-for-marketplace-order-cancellation-uploads
/openapi/2.0.json post /v2/Marketplace/Orders/ResetOrderCancellationUploadCounter
# Reset the upload counter for marketplace payment uploads.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/reset-the-upload-counter-for-marketplace-payment-uploads
/openapi/2.0.json post /v2/Marketplace/Orders/ResetPaymentUploadCounter
# Reset the upload counter for marketplace return uploads.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/reset-the-upload-counter-for-marketplace-return-uploads
/openapi/2.0.json post /v2/Marketplace/Orders/ResetReturnUploadCounter
# Reset the upload counter for marketplace shipping information uploads.
Source: https://developer.jtl-software.com/api-reference/v2.0/orderscommand/reset-the-upload-counter-for-marketplace-shipping-information-uploads
/openapi/2.0.json post /v2/Marketplace/Orders/ResetShippingInformationUploadCounter
# Query Payment Methods
Source: https://developer.jtl-software.com/api-reference/v2.0/paymentmethod/query-payment-methods
/openapi/2.0.json get /v2/paymentMethods
Query all payment methods
# Installed Printers
Source: https://developer.jtl-software.com/api-reference/v2.0/printer/installed-printers
/openapi/2.0.json get /v2/printers
Returns all Installed Printers
# Add new product groups.
Source: https://developer.jtl-software.com/api-reference/v2.0/productgroupscommand/add-new-product-groups
/openapi/2.0.json post /v2/ProductGroup/AddProductGroups
# Delete existing product groups.
Source: https://developer.jtl-software.com/api-reference/v2.0/productgroupscommand/delete-existing-product-groups
/openapi/2.0.json delete /v2/ProductGroup/DeleteProductGroups
# Update the properties of product groups.
Source: https://developer.jtl-software.com/api-reference/v2.0/productgroupscommand/update-the-properties-of-product-groups
/openapi/2.0.json patch /v2/ProductGroup/UpdateProductGroups
# Retrieves a production item by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/productionitemsquery/retrieves-a-production-item-by-its-id
/openapi/2.0.json get /v2/production-items/{id}
# Retrieves a production item by the ID of the underlying item.
Source: https://developer.jtl-software.com/api-reference/v2.0/productionitemsquery/retrieves-a-production-item-by-the-id-of-the-underlying-item
/openapi/2.0.json get /v2/production-items/by-item-id/{itemId}
# Creates a new production order.
Source: https://developer.jtl-software.com/api-reference/v2.0/productionorderscommand/creates-a-new-production-order
/openapi/2.0.json post /v2/production-orders/create
# Releases an existing production order.
Source: https://developer.jtl-software.com/api-reference/v2.0/productionorderscommand/releases-an-existing-production-order
/openapi/2.0.json post /v2/production-orders/{productionOrderId}/release
# Retrieves a production order by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/productionordersquery/retrieves-a-production-order-by-its-id
/openapi/2.0.json get /v2/production-orders/{id}
# Create Property
Source: https://developer.jtl-software.com/api-reference/v2.0/property/create-property
/openapi/2.0.json post /v2/properties
Create a new property
# Create Property Group
Source: https://developer.jtl-software.com/api-reference/v2.0/property/create-property-group
/openapi/2.0.json post /v2/properties/groups
Create a new property group
# Create Property Value
Source: https://developer.jtl-software.com/api-reference/v2.0/property/create-property-value
/openapi/2.0.json post /v2/properties/{propertyId}/values
Create a new value for a specific property
# Create Property Value Description
Source: https://developer.jtl-software.com/api-reference/v2.0/property/create-property-value-description
/openapi/2.0.json post /v2/properties/{propertyId}/values/{propertyValueId}/descriptions
Create a new description for a specific property value
# Delete Property Value
Source: https://developer.jtl-software.com/api-reference/v2.0/property/delete-property-value
/openapi/2.0.json delete /v2/properties/{propertyId}/values/{propertyValueId}
Delete a specific value for a given property
# Delete Property Value Description
Source: https://developer.jtl-software.com/api-reference/v2.0/property/delete-property-value-description
/openapi/2.0.json delete /v2/properties/{propertyId}/values/{propertyValueId}/descriptions/{languageIso}
Delete the description for a specific property value and language
# Query Properties
Source: https://developer.jtl-software.com/api-reference/v2.0/property/query-properties
/openapi/2.0.json get /v2/properties
Query all properties for items
# Query Property Groups
Source: https://developer.jtl-software.com/api-reference/v2.0/property/query-property-groups
/openapi/2.0.json get /v2/properties/groups
Query all groups for properties
# Query Property Value Descriptions
Source: https://developer.jtl-software.com/api-reference/v2.0/property/query-property-value-descriptions
/openapi/2.0.json get /v2/properties/{propertyId}/values/{propertyValueId}/descriptions
Query all descriptions for a specific property value
# Query Property Values
Source: https://developer.jtl-software.com/api-reference/v2.0/property/query-property-values
/openapi/2.0.json get /v2/properties/{propertyId}/values
Query all velues for a specific property
# Update Property Value
Source: https://developer.jtl-software.com/api-reference/v2.0/property/update-property-value
/openapi/2.0.json patch /v2/properties/{propertyId}/values/{propertyValueId}
Update the value of a specific property
# Update Property Value Description
Source: https://developer.jtl-software.com/api-reference/v2.0/property/update-property-value-description
/openapi/2.0.json patch /v2/properties/{propertyId}/values/{propertyValueId}/descriptions/{languageIso}
Update the description for a specific property value and language
# Create Return
Source: https://developer.jtl-software.com/api-reference/v2.0/return/create-return
/openapi/2.0.json post /v2/returns
Create a new return with associated items and packages.
# Get Return
Source: https://developer.jtl-software.com/api-reference/v2.0/return/get-return
/openapi/2.0.json get /v2/returns/{returnId}
Get a specific return
# Query Return Line Items
Source: https://developer.jtl-software.com/api-reference/v2.0/return/query-return-line-items
/openapi/2.0.json get /v2/returns/{returnId}/lineitems
Query all line items for a specific return
# Query Return Packages
Source: https://developer.jtl-software.com/api-reference/v2.0/return/query-return-packages
/openapi/2.0.json get /v2/returns/{returnId}/packages
Query all packages for a specific return
# Query Returns
Source: https://developer.jtl-software.com/api-reference/v2.0/return/query-returns
/openapi/2.0.json get /v2/returns
Query all returns
# Query Return Reasons
Source: https://developer.jtl-software.com/api-reference/v2.0/returnreason/query-return-reasons
/openapi/2.0.json get /v2/returnReasons
Query all return reasons
# Query Return States
Source: https://developer.jtl-software.com/api-reference/v2.0/returnstate/query-return-states
/openapi/2.0.json get /v2/returnStates
Query all return states
# Get Sales Channels
Source: https://developer.jtl-software.com/api-reference/v2.0/saleschannel/get-sales-channels
/openapi/2.0.json get /v2/salesChannels
Get all sales channels
# Cancel a sales invoice correction
Source: https://developer.jtl-software.com/api-reference/v2.0/salesinvoicecorrectiondomaincommand/cancel-a-sales-invoice-correction
/openapi/2.0.json post /v2/salesinvoicecorrection/cancel
# Create a new sales invoice correction from an existing invoice
Source: https://developer.jtl-software.com/api-reference/v2.0/salesinvoicecorrectiondomaincommand/create-a-new-sales-invoice-correction-from-an-existing-invoice
/openapi/2.0.json post /v2/salesinvoice/createsalesinvoicecorrection
# Cancel a sales invoice
Source: https://developer.jtl-software.com/api-reference/v2.0/salesinvoicedomaincommand/cancel-a-sales-invoice
/openapi/2.0.json post /v2/salesinvoice/cancel
# Create a new sales invoice for a salesorder
Source: https://developer.jtl-software.com/api-reference/v2.0/salesinvoicedomaincommand/create-a-new-sales-invoice-for-a-salesorder
/openapi/2.0.json post /v2/salesinvoice/createsalesinvoice
# Cancel Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/cancel-sales-order
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/cancel
Cancel a specific sales order
# Create Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/create-sales-order
/openapi/2.0.json post /v2/salesOrders
Create a new sales order
# Create Sales Order File
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/create-sales-order-file
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/files
Create a new file for a specific sales order
# Create Sales Order Line Item
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/create-sales-order-line-item
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/lineitems
Create a new line item for a specific sales order
# Create Sales Order Line Item File
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/create-sales-order-line-item-file
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}/files
Create a new file for a specific sales order line item
# Delete Sales Order Custom Field
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/delete-sales-order-custom-field
/openapi/2.0.json delete /v2/salesOrders/{salesOrderId}/customfields/{customfieldId}
Delete the value of a specific custom field of a given sales order
# Delete Sales Order File
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/delete-sales-order-file
/openapi/2.0.json delete /v2/salesOrders/{salesOrderId}/files/{salesOrderFileId}
Delete a specific file for a given sales order
# Delete Sales Order Line Item
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/delete-sales-order-line-item
/openapi/2.0.json delete /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}
Delete a specific line item for a given sales order
# Get Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/get-sales-order
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}
Get a specific sales order
# Query Sales Order Custom Field Values
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-custom-field-values
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/customfields
Query all custom fields and values for a specific sales order
# Query Sales Order File Data
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-file-data
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/files/{salesOrderFileId}
Query the data for a specific sales order file
# Query Sales Order Files
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-files
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/files
Query all files for a specific sales order
# Query Sales Order Line Item File Data
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-line-item-file-data
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}/files/{salesOrderLineItemFileId}
Query the data for a specific sales order file
# Query Sales Order Line Item Files
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-line-item-files
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}/files
Query files for line items of a specific sales order
# Query Sales Order Line Items
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-line-items
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/lineitems
Query all line items for a specific sales order
# Query Sales Orders
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-orders
/openapi/2.0.json get /v2/salesOrders
Query all sales orders
# Update Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/update-sales-order
/openapi/2.0.json patch /v2/salesOrders/{salesOrderId}
Update a specific sales order
# Update Sales Order Custom Field
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/update-sales-order-custom-field
/openapi/2.0.json patch /v2/salesOrders/{salesOrderId}/customfields/{customfieldId}
Update the value of a specific sales order custom field
# Update Sales Order File
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/update-sales-order-file
/openapi/2.0.json patch /v2/salesOrders/{salesOrderId}/files/{salesOrderFileId}
Update a file for a specific sales order
# Update Sales Order Line Item
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/update-sales-order-line-item
/openapi/2.0.json patch /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}
Update a line item for a specific sales order
# [Deprecated] Use salesorder/calculate instead.
Calculate prices, discounts, and taxes for a sales order without persisting it.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomaincommand/[deprecated]-use-salesordercalculate-insteadcalculate-prices-discounts-and-taxes-for-a-sales-order-without-persisting-it
/openapi/2.0.json post /v2/salesorder/calculatesalesorder
# Calculate prices, discounts, and taxes for a sales order without persisting it.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomaincommand/calculate-prices-discounts-and-taxes-for-a-sales-order-without-persisting-it
/openapi/2.0.json post /v2/salesorder/calculate
# Creates a new sales order.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomaincommand/creates-a-new-sales-order
/openapi/2.0.json post /v2/salesorder/create
# Modifies an existing sales order.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomaincommand/modifies-an-existing-sales-order
/openapi/2.0.json patch /v2/salesorder/update
# Delivers a single sales order by its id
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomainquery/delivers-a-single-sales-order-by-its-id
/openapi/2.0.json get /v2/salesorder/{Id}
# Returns a list of price details for the requested items.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomainquery/returns-a-list-of-price-details-for-the-requested-items
/openapi/2.0.json get /v2/salesorder/itempricedetails
# Returns an empty sales order with default values without persisting it. This is equivalent to opening a new sales order dialog in the UI.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorderdomainquery/returns-an-empty-sales-order-with-default-values-without-persisting-it-this-is-equivalent-to-opening-a-new-sales-order-dialog-in-the-ui
/openapi/2.0.json get /v2/salesorder/empty
# Delivers an existing Package
Source: https://developer.jtl-software.com/api-reference/v2.0/shipmentpackagescommand/delivers-an-existing-package
/openapi/2.0.json post /v2/package/deliver
# Modifies an existing Package Weight
Source: https://developer.jtl-software.com/api-reference/v2.0/shipmentpackagescommand/modifies-an-existing-package-weight
/openapi/2.0.json patch /v2/package/change
# Delivers order data for a specific package
Source: https://developer.jtl-software.com/api-reference/v2.0/shipmentpackagesquery/delivers-order-data-for-a-specific-package
/openapi/2.0.json get /v2/package/QueryOrderData/{packageId}
# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# Activates a bin location, making it available for operations.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/activates-a-bin-location-making-it-available-for-operations
/openapi/2.0.json post /v2/warehouseassistant/bin-locations/activate
# Creates a new bin location in a warehouse.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/creates-a-new-bin-location-in-a-warehouse
/openapi/2.0.json post /v2/warehouseassistant/bin-locations/create
# Deactivates a bin location, making it unavailable for operations.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/deactivates-a-bin-location-making-it-unavailable-for-operations
/openapi/2.0.json post /v2/warehouseassistant/bin-locations/deactivate
# Deletes a bin location from the warehouse.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/deletes-a-bin-location-from-the-warehouse
/openapi/2.0.json delete /v2/warehouseassistant/bin-locations/delete
# Locks a bin location for available stock, preventing it from being used for stock allocation.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/locks-a-bin-location-for-available-stock-preventing-it-from-being-used-for-stock-allocation
/openapi/2.0.json post /v2/warehouseassistant/bin-locations/lock-for-stock
# Locks a bin location, preventing stock movements.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/locks-a-bin-location-preventing-stock-movements
/openapi/2.0.json post /v2/warehouseassistant/bin-locations/lock
# Unlocks a bin location for available stock, allowing it to be used for stock allocation.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/unlocks-a-bin-location-for-available-stock-allowing-it-to-be-used-for-stock-allocation
/openapi/2.0.json post /v2/warehouseassistant/bin-locations/unlock-for-stock
# Updates metadata of an existing bin location (name, type, sort order).
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementcommand/updates-metadata-of-an-existing-bin-location-name-type-sort-order
/openapi/2.0.json patch /v2/warehouseassistant/bin-locations/update
# Returns a single bin location by its ID.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementquery/returns-a-single-bin-location-by-its-id
/openapi/2.0.json get /v2/warehouseassistant/bin-locations/{BinLocationId}
# Returns all available bin location statuses.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementquery/returns-all-available-bin-location-statuses
/openapi/2.0.json get /v2/warehouseassistant/bin-locations/statuses
# Returns all available bin location types.
Source: https://developer.jtl-software.com/api-reference/v2.0/binlocationmanagementquery/returns-all-available-bin-location-types
/openapi/2.0.json get /v2/warehouseassistant/bin-locations/types
# Updates the active sales channels for a set of items
Source: https://developer.jtl-software.com/api-reference/v2.0/saleschannelscommand/updates-the-active-sales-channels-for-a-set-of-items
/openapi/2.0.json post /v2/UpdateItemSalesChannels
# Create Sales Order Note
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/create-sales-order-note
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/notes
Create a new note for a specific sales order
# Delete Sales Order Line Item File
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/delete-sales-order-line-item-file
/openapi/2.0.json delete /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}/files/{salesOrderLineItemFileId}
Delete all line item files for a given sales order and line item
# Delete Sales Order Note
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/delete-sales-order-note
/openapi/2.0.json delete /v2/salesOrders/{salesOrderId}/notes/{noteId}
Delete a specific note for a given sales order
# Mail Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/mail-sales-order
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/output/mail
Execute the mailing of a SalesOrder
# Pdf Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/pdf-sales-order
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/output/pdf
Execute the pdf creation of a SalesOrder
# Print Sales Order
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/print-sales-order
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/output/print
Execute the printing of a SalesOrder
# Query Sales Order Custom Fields
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-custom-fields
/openapi/2.0.json get /v2/salesOrders/customfields
Query all custom fields for a sales order
# Query Sales Order Notes
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-notes
/openapi/2.0.json get /v2/salesOrders/{salesOrderId}/notes
Query all notes for a specific sales order
# Query Sales Order Workflow Events
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/query-sales-order-workflow-events
/openapi/2.0.json get /v2/salesOrders/workflowEvents
Query all available workflow events for sales orders
# Trigger Sales Order Workflow
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/trigger-sales-order-workflow
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/workflow/{workflowEventId}
Trigger a specific workflow event for a given sales order
# Trigger Sales Order Workflow Event
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/trigger-sales-order-workflow-event
/openapi/2.0.json post /v2/salesOrders/{salesOrderId}/workflowEvents
Trigger a specific workflow event for a given sales order
# Update Sales Order Line Item File
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/update-sales-order-line-item-file
/openapi/2.0.json patch /v2/salesOrders/{salesOrderId}/lineitems/{salesOrderLineItemId}/files/{salesOrderLineItemFileId}
Update a file for a specific sales order line item
# Update Sales Order Note
Source: https://developer.jtl-software.com/api-reference/v2.0/salesorder/update-sales-order-note
/openapi/2.0.json patch /v2/salesOrders/{salesOrderId}/notes/{noteId}
Update a specific note for a given sales order
# Cancel a sales quotation
Source: https://developer.jtl-software.com/api-reference/v2.0/salesquotationdomaincommand/cancel-a-sales-quotation
/openapi/2.0.json post /v2/salesquotation/cancel
# Create a new sales order for a sales quotation
Source: https://developer.jtl-software.com/api-reference/v2.0/salesquotationdomaincommand/create-a-new-sales-order-for-a-sales-quotation
/openapi/2.0.json post /v2/salesquotation/createsalesorder
# Creates a new sales quotation.
Source: https://developer.jtl-software.com/api-reference/v2.0/salesquotationdomaincommand/creates-a-new-sales-quotation
/openapi/2.0.json post /v2/salesquotation/create
# Delivers a single sales quotation by its id
Source: https://developer.jtl-software.com/api-reference/v2.0/salesquotationdomainquery/delivers-a-single-sales-quotation-by-its-id
/openapi/2.0.json get /v2/salesquotation/{Id}
# Package Weight
Source: https://developer.jtl-software.com/api-reference/v2.0/shipment/package-weight
/openapi/2.0.json post /v2/shipment/wms/shippingLine/packages/{packageId}/packageWeight
Set the weight of a package by ID
# Shipping Label
Source: https://developer.jtl-software.com/api-reference/v2.0/shipment/shipping-label
/openapi/2.0.json get /v2/shipment/label/{packageId}
Download a PDF Shipping Label from database by ID
# Creates a new shipping class
Source: https://developer.jtl-software.com/api-reference/v2.0/shippingclasscommand/creates-a-new-shipping-class
/openapi/2.0.json post /v2/shippingclass/create
# Query Shipping Methods
Source: https://developer.jtl-software.com/api-reference/v2.0/shippingmethod/query-shipping-methods
/openapi/2.0.json get /v2/shippingMethods
Query all shipping methods
# Query Serial Number Per Warehouse
Source: https://developer.jtl-software.com/api-reference/v2.0/stock/query-serial-number-per-warehouse
/openapi/2.0.json get /v2/stocks/serialnumbers
Query the serial numbers for a specific item and warehouse
# Query Stock Changes
Source: https://developer.jtl-software.com/api-reference/v2.0/stock/query-stock-changes
/openapi/2.0.json get /v2/stocks/changes
Returns all stock changes for a specific item from a given start date
# Query Stocks Per Item
Source: https://developer.jtl-software.com/api-reference/v2.0/stock/query-stocks-per-item
/openapi/2.0.json get /v2/stocks
Query stocks for a specific item, warehouse or storage location
# Stock Adjustment
Source: https://developer.jtl-software.com/api-reference/v2.0/stock/stock-adjustment
/openapi/2.0.json post /v2/stocks
Adjust the stock of a specific item. Depending from the item and warehouse many more details must be given (f.e. storage location, batch,...).
# Query Suppliers
Source: https://developer.jtl-software.com/api-reference/v2.0/supplier/query-suppliers
/openapi/2.0.json get /v2/suppliers
Query all suppliers
# Get Tax For Item
Source: https://developer.jtl-software.com/api-reference/v2.0/tax/get-tax-for-item
/openapi/2.0.json get /v2/tax/item/{itemId}/{companyId}/{departureCountryISO}/{shipmentCountryISO}
Returns the Taxrate for the given Item
# Get Tax For Tax Class
Source: https://developer.jtl-software.com/api-reference/v2.0/tax/get-tax-for-tax-class
/openapi/2.0.json get /v2/tax/taxclass/{taxClassId}/{companyId}/{departureCountryISO}/{shipmentCountryISO}
Returns the Taxrate for the given Item
# Creates a new tax class in the system
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomaincommand/creates-a-new-tax-class-in-the-system
/openapi/2.0.json post /v2/taxclasses/create
# Creates a new tax code in the system
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomaincommand/creates-a-new-tax-code-in-the-system
/openapi/2.0.json post /v2/taxcodes/create
# Deletes an existing tax class
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomaincommand/deletes-an-existing-tax-class
/openapi/2.0.json delete /v2/taxclasses/delete
# Deletes an existing tax code
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomaincommand/deletes-an-existing-tax-code
/openapi/2.0.json delete /v2/taxcodes/delete
# Updates an existing tax class
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomaincommand/updates-an-existing-tax-class
/openapi/2.0.json patch /v2/taxclasses/update
# Updates an existing tax code
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomaincommand/updates-an-existing-tax-code
/openapi/2.0.json patch /v2/taxcodes/update
# Returns a list of all tax classes and their calculated tax rates for the given parameters.
Source: https://developer.jtl-software.com/api-reference/v2.0/taxdomainquery/returns-a-list-of-all-tax-classes-and-their-calculated-tax-rates-for-the-given-parameters
/openapi/2.0.json get /v2/taxclasses/taxclasseswithtaxrates
# Query Transaction Status
Source: https://developer.jtl-software.com/api-reference/v2.0/transactionstatus/query-transaction-status
/openapi/2.0.json get /v2/transactionStatuses
Query all transaction status for sales order
# Query Storage Location Type
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouse/query-storage-location-type
/openapi/2.0.json get /v2/warehouses/storagelocationtypes
Query all storage location types
# Query Storage Locations
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouse/query-storage-locations
/openapi/2.0.json get /v2/warehouses/{warehouseId}/storagelocations
Query all storage locations for a given warehouse
# Query Warehouse Types
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouse/query-warehouse-types
/openapi/2.0.json get /v2/warehouses/types
Query all warehouse types
# Query Warehouses
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouse/query-warehouses
/openapi/2.0.json get /v2/warehouses
Query all warehouses
# Creates a new shipping box within a warehouse.
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouseassistantcommand/creates-a-new-shipping-box-within-a-warehouse
/openapi/2.0.json post /v2/warehouseassistant/shipping-boxes/create
# Permanently deletes a shipping box and all its attributes (Rule SB-8).
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouseassistantcommand/permanently-deletes-a-shipping-box-and-all-its-attributes-rule-sb-8
/openapi/2.0.json delete /v2/warehouseassistant/shipping-boxes/delete
# Reassigns a shipping box to a different bin location (Rule SB-5).
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouseassistantcommand/reassigns-a-shipping-box-to-a-different-bin-location-rule-sb-5
/openapi/2.0.json post /v2/warehouseassistant/shipping-boxes/assign-location
# Updates mutable metadata of an existing shipping box. TypeId is immutable (Rule SB-3).
Source: https://developer.jtl-software.com/api-reference/v2.0/warehouseassistantcommand/updates-mutable-metadata-of-an-existing-shipping-box-typeid-is-immutable-rule-sb-3
/openapi/2.0.json patch /v2/warehouseassistant/shipping-boxes/update
# Adds bin locations to a warehouse zone.
Source: https://developer.jtl-software.com/api-reference/v2.0/warehousezonecommand/adds-bin-locations-to-a-warehouse-zone
/openapi/2.0.json post /v2/warehouseassistant/warehouse-zones/add-bin-locations
# Creates a new warehouse zone.
Source: https://developer.jtl-software.com/api-reference/v2.0/warehousezonecommand/creates-a-new-warehouse-zone
/openapi/2.0.json post /v2/warehouseassistant/warehouse-zones/create
# Deletes a warehouse zone.
Source: https://developer.jtl-software.com/api-reference/v2.0/warehousezonecommand/deletes-a-warehouse-zone
/openapi/2.0.json delete /v2/warehouseassistant/warehouse-zones/delete
# Removes bin locations from a warehouse zone.
Source: https://developer.jtl-software.com/api-reference/v2.0/warehousezonecommand/removes-bin-locations-from-a-warehouse-zone
/openapi/2.0.json post /v2/warehouseassistant/warehouse-zones/remove-bin-locations
# Updates mutable metadata (code, description, type) of an existing warehouse zone.
Source: https://developer.jtl-software.com/api-reference/v2.0/warehousezonecommand/updates-mutable-metadata-code-description-type-of-an-existing-warehouse-zone
/openapi/2.0.json patch /v2/warehouseassistant/warehouse-zones/update
# Create Pick List
Source: https://developer.jtl-software.com/api-reference/v2.0/wms/create-pick-list
/openapi/2.0.json post /v2/wms/{warehouseId}/picklists
Create a new pick list for a specific wms warehouse
# Query Pick List
Source: https://developer.jtl-software.com/api-reference/v2.0/wms/query-pick-list
/openapi/2.0.json get /v2/wms/{warehouseId}/picklists
Query all pick lists for a specific wms warehouse that are not completed.
# Query Pick List Position
Source: https://developer.jtl-software.com/api-reference/v2.0/wms/query-pick-list-position
/openapi/2.0.json get /v2/wms/{warehouseId}/picklists/{picklistId}
Query all positions for a given pick list
# Query Pick List Template
Source: https://developer.jtl-software.com/api-reference/v2.0/wms/query-pick-list-template
/openapi/2.0.json get /v2/wms/picklisttemplates
Query all pick list templates. A pick list template is used for creating a new pick list.
# Creates a new workbench resource
Source: https://developer.jtl-software.com/api-reference/v2.0/workbenchresourcescommand/creates-a-new-workbench-resource
/openapi/2.0.json post /v2/workbenchResources/create
# Retrieves a single workbench resource by its ID
Source: https://developer.jtl-software.com/api-reference/v2.0/workbenchresourcesquery/retrieves-a-single-workbench-resource-by-its-id
/openapi/2.0.json get /v2/workbenchResources/{Id}
# Creates a new workbench resource type
Source: https://developer.jtl-software.com/api-reference/v2.0/workbenchresourcetypescommand/creates-a-new-workbench-resource-type
/openapi/2.0.json post /v2/workbenchResourceTypes/create
# Queries a single workbench resource type by its ID
Source: https://developer.jtl-software.com/api-reference/v2.0/workbenchresourcetypesquery/queries-a-single-workbench-resource-type-by-its-id
/openapi/2.0.json get /v2/workbenchResourceTypes/{Id}
# Configure Sync
Source: https://developer.jtl-software.com/api-reference/v2.0/worker/configure-sync
/openapi/2.0.json post /v2/workers/{syncId}
Restart the Worker
# Get Worker Status
Source: https://developer.jtl-software.com/api-reference/v2.0/worker/get-worker-status
/openapi/2.0.json get /v2/workers/status
Returns the Status of the Worker
# Get Worker Syncs
Source: https://developer.jtl-software.com/api-reference/v2.0/worker/get-worker-syncs
/openapi/2.0.json get /v2/workers
Returns the Available Syncs of the Worker
# Sync Control
Source: https://developer.jtl-software.com/api-reference/v2.0/worker/sync-control
/openapi/2.0.json put /v2/workers/{syncId}
Control the Sync Processes
# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# ERP (JTL-Wawi)
Source: https://developer.jtl-software.com/api-reference/erp
REST and GraphQL access to JTL-Wawi business data
The ERP API lets you read and manipulate data in JTL-Wawi: orders, products, customers, invoices, inventory, and more. It is available as a REST API (all versions) and, starting with v2.0, as a GraphQL API.
Auth, headers, deployment variants, and how to make your first call.
Available in v2.0. Browse the schema and run queries interactively.
## OpenAPI Spec
Download the spec for any supported version. Import into Postman, Insomnia, or generate a client.
| Version | Status | Spec |
| ------- | ------------------- | ---------------------------------- |
| v2.1 | Pre-release | [Download JSON](/openapi/2.1.json) |
| v2.0 | Latest, recommended | [Download JSON](/openapi/2.0.json) |
| v1.4 | Supported | [Download JSON](/openapi/1.4.json) |
| v1.3 | Supported | [Download JSON](/openapi/1.3.json) |
| v1.2 | Supported | [Download JSON](/openapi/1.2.json) |
| v1.1 | Supported | [Download JSON](/openapi/1.1.json) |
| v1.0 | Supported | [Download JSON](/openapi/1.0.json) |
# Channel API
Source: https://developer.jtl-software.com/api-reference/scx/channel
Build a marketplace integration that connects merchants to a sales channel through SCX.
The Channel API is for marketplace integrators. Use it to register a sales channel with SCX, sync product data between Wawi and the marketplace, receive orders, and report fulfilment back.
## Documentation
For more information on how channels use the API, see the following guides:
Learn how channels use the API, the event flow, metadata model, and media handling.
Refresh tokens, access tokens, and Bearer headers for all SCX APIs.
Per-endpoint quotas, `X-RateLimit-*` headers, and 429 handling.
## OpenAPI Spec
Import into Postman, Insomnia, or generate a client: [Download JSON](/openapi/scx/channel.json).
# Category Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/category-attributes
/openapi/scx/channel.json put /v1/channel/attribute/category/{categoryId}
Create Attributes which are required for listings in specific category.
# Delete Category Attribute by ID
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/delete-category-attribute-by-id
/openapi/scx/channel.json delete /v1/channel/attribute/{attributeId}/category/{categoryId}
Delete channel attributes from all assigned categories.
# Delete Category Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/delete-category-attributes
/openapi/scx/channel.json delete /v1/channel/attribute/category
Delete category attributes by category ID.
# Delete Global Attribute
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/delete-global-attribute
/openapi/scx/channel.json delete /v1/channel/attribute/global/{attributeId}
Delete global attribute by attributeId.
# Delete Seller Attribute
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/delete-seller-attribute
/openapi/scx/channel.json delete /v1/channel/attribute/seller/{attributeId}
Delete a seller-specific attribute by attributeId.
# Get Category Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/get-category-attributes
/openapi/scx/channel.json get /v1/channel/attribute/category/{categoryId}
Get Attributes which are required for listings in specific category.
# Get Global Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/get-global-attributes
/openapi/scx/channel.json get /v1/channel/attribute/global
Get global attributes
# Get Seller Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/get-seller-attributes
/openapi/scx/channel.json get /v1/channel/attribute/seller/{sellerId}
Get Seller specific attributes
# Global Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/global-attributes
/openapi/scx/channel.json put /v1/channel/attribute/global
Create or update global attribute. Global attributes not depending on categories and are visible for offers in
a global scope. Use these kind of attributes to define channel specific needs.
# Seller Attributes
Source: https://developer.jtl-software.com/api-reference/scx/channel/attributes/seller-attributes
/openapi/scx/channel.json put /v1/channel/attribute/seller/{sellerId}
Create or update Seller specific attributes. These kind of attributes can be used to provide seller specific
attributes on global scope. Seller specific attributes not depending on categories and are visible for offers
in a global scope.
# Get Category Tree
Source: https://developer.jtl-software.com/api-reference/scx/channel/categories/get-category-tree
/openapi/scx/channel.json get /v1/channel/categories
# Update Category Tree
Source: https://developer.jtl-software.com/api-reference/scx/channel/categories/update-category-tree
/openapi/scx/channel.json put /v1/channel/categories
Update Channel Category tree.
# Generate MFA PIN
Source: https://developer.jtl-software.com/api-reference/scx/channel/channel/generate-mfa-pin
/openapi/scx/channel.json get /v1/channel/mfa-pin
Generates a Multi-Factor Authentication (MFA) PIN for channel updates.
The PIN is sent to the channel's mfaContact email address and must be used
when updating channel details via the PATCH /v1/channel endpoint.
The PIN is stored securely and never returned directly to the client.
It is deleted after successful validation or when it expires.
# List all SellerIds
Source: https://developer.jtl-software.com/api-reference/scx/channel/channel/list-all-sellerids
/openapi/scx/channel.json get /v1/channel/seller/list
The API Endpoint list all Seller IDs known by SCX-API with current status.
# Status
Source: https://developer.jtl-software.com/api-reference/scx/channel/channel/status
/openapi/scx/channel.json get /v1/channel
Read Channel information
# Update Channel
Source: https://developer.jtl-software.com/api-reference/scx/channel/channel/update-channel
/openapi/scx/channel.json patch /v1/channel
Update Channel information. This endpoint is protected by MFA (2FA).
A valid MFA PIN must be included in the request. The PIN can be generated
using the GET /v1/channel/mfa-pin endpoint and will be sent to the channel's
mfaContact email address.
# Payment Rules
Source: https://developer.jtl-software.com/api-reference/scx/channel/meta/payment-rules
/openapi/scx/channel.json put /v1/channel/payment-rules
Payment Rules
# Shipping Rules
Source: https://developer.jtl-software.com/api-reference/scx/channel/meta/shipping-rules
/openapi/scx/channel.json put /v1/channel/shipping-rules
Shipping Rules can be used to define a list of Carriers which are supported by the connected Marketplace
(supportedCarrierList). A connected Seller integration will provide the Id to the Carrier when the Shipping
Information is transmitted. (see Event Type: `Seller:Order.Shipping`)
# Notification
Source: https://developer.jtl-software.com/api-reference/scx/channel/notification/notification
/openapi/scx/channel.json post /v1/channel/notification
Send a Channel Notification to SCX
# Create Seller
Source: https://developer.jtl-software.com/api-reference/scx/channel/seller/create-seller
/openapi/scx/channel.json post /v1/channel/seller
Connect a new Seller to SCX Platform
# Update Seller
Source: https://developer.jtl-software.com/api-reference/scx/channel/seller/update-seller
/openapi/scx/channel.json patch /v1/channel/seller
Update a existing Seller
# Price Types
Source: https://developer.jtl-software.com/api-reference/scx/channel/supported-prices/price-types
/openapi/scx/channel.json post /v1/channel/price
Create a price type for different customer groups.
# Auth API
Source: https://developer.jtl-software.com/api-reference/scx/auth
Issue and manage tokens for SCX Channel and other APIs.
The Auth API exchanges a long-lived refresh token for a short-lived bearer token that you include in requests to the Channel and Seller APIs. Refresh tokens are issued during onboarding.
## Documentation
For more information on authentication, see the following guides:
Refresh tokens, access tokens, and Bearer headers for all SCX APIs.
Per-endpoint quotas, `X-RateLimit-*` headers, and 429 handling.
## OpenAPI Spec
Import into Postman, Insomnia, or generate a client: [Download JSON](/openapi/scx/auth.json).
# Create Access Token for Seller access.
Source: https://developer.jtl-software.com/api-reference/scx/auth/authentication/create-access-token-for-seller-access
/openapi/scx/auth.json post /v1/auth/create/seller-token
Create a new Access Token based on secret PIN.
# Session Token
Source: https://developer.jtl-software.com/api-reference/scx/auth/authentication/session-token
/openapi/scx/auth.json post /v1/auth
Create Session Token
# Acknowledge Events
Source: https://developer.jtl-software.com/api-reference/scx/channel/events/acknowledge-events
/openapi/scx/channel.json delete /v1/channel/event
Delete Events by eventId. If a event is deleted it will not redelivered with the next `GET /v1/channel/event` request
# Seller Events
Source: https://developer.jtl-software.com/api-reference/scx/channel/events/seller-events
/openapi/scx/channel.json get /v1/channel/event
API Endpoint to retrieve events from registered sellers. Events are various different actions which may occur when
sellers are processing channel data such as orders. After receiving a seller events response, each event in the response
needs to be acknowledged using `PATCH /v1/channel/event` request. Unacknowledged events will be delivered again after a
period of time.
# Mark Listing as failed
Source: https://developer.jtl-software.com/api-reference/scx/channel/offer/mark-listing-as-failed
/openapi/scx/channel.json post /v1/channel/offer/listing-failed
Mark a offer listing as failed
# Mark Listing in-progress
Source: https://developer.jtl-software.com/api-reference/scx/channel/offer/mark-listing-in-progress
/openapi/scx/channel.json post /v1/channel/offer/in-progress
Mark OfferId as in progress. Until a offer is marked as in progress it will
be redelivered on each GET /v1/channel/offer call.
# Offer successful listed
Source: https://developer.jtl-software.com/api-reference/scx/channel/offer/offer-successful-listed
/openapi/scx/channel.json post /v1/channel/offer/listed
Offer listed
# Stock Updates (All Sellers)
Source: https://developer.jtl-software.com/api-reference/scx/channel/offer/stock-updates-all-sellers
/openapi/scx/channel.json get /v1/channel/offer/stock-updates/all
This endpoint retrieves all stock updates across all sellers for a channel. It provides a comprehensive
view of inventory changes from all sellers associated with the authenticated channel.
This endpoint is ideal for:
- **Periodic synchronization**: Regularly poll for stock updates across all sellers to keep inventory in sync
- **Incremental updates**: Use the `updatedAfter` parameter with the previous `lastUpdatedAt` value to fetch only new changes
This API endpoint has a stricter rate limit.
# Stock Updates (by Seller)
Source: https://developer.jtl-software.com/api-reference/scx/channel/offer/stock-updates-by-seller
/openapi/scx/channel.json get /v1/channel/offer/stock-updates
This endpoint retrieves stock updates for offers from a specific seller within a channel.
It allows you to sync inventory changes for a particular seller's offers over time.
Returns a filtered list of stock changes that occurred after a specified timestamp for a specific seller.
# Accept Cancellation Request
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/accept-cancellation-request
/openapi/scx/channel.json put /v1/channel/order/cancellation-accept
Accept a cancellation Request for a Order or OrderItem
# Create Orders
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/create-orders
/openapi/scx/channel.json post /v1/channel/order
Create new Orders
# Deny Cancellation Request
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/deny-cancellation-request
/openapi/scx/channel.json put /v1/channel/order/cancellation-denied
Deny a cancellation Request for a Order or OrderItem
# Invoice
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/invoice
/openapi/scx/channel.json get /v1/channel/order/invoice/{documentId}
Download Invoice document
# Refund Processing Result
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/refund-processing-result
/openapi/scx/channel.json post /v1/channel/order/refund/processing-result
Send Refund processing result back to Seller.
# Request Order Cancellation
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/request-order-cancellation
/openapi/scx/channel.json post /v1/channel/order/cancellation
Request cancallation for a Order or OrderItem
# Status Update
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/status-update
/openapi/scx/channel.json put /v1/channel/order/status
Update status for an existing order
# Update Order Address List
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/update-order-address-list
/openapi/scx/channel.json put /v1/channel/order/address-update
Address update for existing orders
# Upload Invoice
Source: https://developer.jtl-software.com/api-reference/scx/channel/order/upload-invoice
/openapi/scx/channel.json post /v1/channel/order/invoice
Upload an invoice document for an order.
# Mark Report completed
Source: https://developer.jtl-software.com/api-reference/scx/channel/report/mark-report-completed
/openapi/scx/channel.json post /v1/channel/report/{reportId}/completed
Mark a reportId as completed. Once a reportId is marked as completed, it can not receive any additional data.
A report is only valid up to 48h after requesting it.
# Report
Source: https://developer.jtl-software.com/api-reference/scx/channel/report/report
/openapi/scx/channel.json post /v1/channel/report/{reportId}
This API route is deprecated and will be removed soon. Use `POST /v1/channel/report/{reportId}/data` instead.
Send processed report data to the Channel API. On this API route, the maximum allowed size of items is 25,000.
# Send Data
Source: https://developer.jtl-software.com/api-reference/scx/channel/report/send-data
/openapi/scx/channel.json post /v1/channel/report/{reportId}/data
Send partial report data to the Channel API.
Once all data is sent, the reportId must be marked as completed by
calling `POST /v1/channel/report/{reportId}/completed`.
A report is only valid up to 48h after requesting it.
# Return Announcement
Source: https://developer.jtl-software.com/api-reference/scx/channel/return/return-announcement
/openapi/scx/channel.json post /v1/channel/order/return
Create a Return Announcement
# Return Processing Result
Source: https://developer.jtl-software.com/api-reference/scx/channel/return/return-processing-result
/openapi/scx/channel.json post /v1/channel/order/return/processing-result
Send return Processing Result
# Read Signup Session
Source: https://developer.jtl-software.com/api-reference/scx/channel/seller/read-signup-session
/openapi/scx/channel.json get /v1/channel/seller/signup-session
# Read Update Session
Source: https://developer.jtl-software.com/api-reference/scx/channel/seller/read-update-session
/openapi/scx/channel.json get /v1/channel/seller/update-session
# Unlink Seller
Source: https://developer.jtl-software.com/api-reference/scx/channel/seller/unlink-seller
/openapi/scx/channel.json delete /v1/channel/seller/{sellerId}
Unlink a Seller from Channel. When doing this the Channel will no longer reveive data for
this Channel.
# Create Ticket
Source: https://developer.jtl-software.com/api-reference/scx/channel/ticket/create-ticket
/openapi/scx/channel.json post /v1/channel/ticket
Send a Ticket to Channel API
# Download Attachment
Source: https://developer.jtl-software.com/api-reference/scx/channel/ticket/download-attachment
/openapi/scx/channel.json get /v1/channel/ticket/attachment
Download Attachment
# Upload Attachment
Source: https://developer.jtl-software.com/api-reference/scx/channel/ticket/upload-attachment
/openapi/scx/channel.json post /v1/channel/ticket/attachment
Upload a attachment for a Ticket
# Public API
Source: https://developer.jtl-software.com/api-reference/scx/public
Publicly accessible SCX endpoints that do not require authentication
The Public API exposes the endpoints that do not require authentication, for example listing available channels. Useful for discovery before a seller or channel integration has onboarded.
For more information on how to use SCX public APIs, see the [Rate Limits](/guides/marketplace-channels/rate-limits) guide.
## OpenAPI Spec
Import into Postman, Insomnia, or generate a client: [Download JSON](/openapi/scx/public.json).
# Channel List
Source: https://developer.jtl-software.com/api-reference/scx/public/channel/channel-list
/openapi/scx/public.json get /v1/public/channel
List all channels available through SCX platform.
# Seller API
Source: https://developer.jtl-software.com/api-reference/scx/seller
Manage a seller's SCX configuration: channel connections, mappings, and account settings.
The Seller API is for tools that act on behalf of a merchant inside SCX. Use it to manage a seller's connected channels, attribute mappings, listing settings, and account configuration.
## Documentation
For more information on how sellers use the API, see the following guides:
Learn how to manage a seller's SCX configuration.
Refresh tokens, access tokens, and Bearer headers for all SCX APIs.
Per-endpoint quotas, `X-RateLimit-*` headers, and 429 handling.
## OpenAPI Spec
Import into Postman, Insomnia, or generate a client: [Download JSON](/openapi/scx/seller.json).
# Create Seller
Source: https://developer.jtl-software.com/api-reference/scx/seller/account/create-seller
/openapi/scx/seller.json post /v1/seller/channel/{Channel}
Create a seller signup session for a specific channel.
The Useragent is required and will be validated against the channel's
minimum Clients Version requirement (minimumClientsVersionRequired).
# Login SCX Account
Source: https://developer.jtl-software.com/api-reference/scx/seller/account/login-scx-account
/openapi/scx/seller.json post /v1/seller/login
Login SCX Account by creating a new refesh Token.
# Seller
Source: https://developer.jtl-software.com/api-reference/scx/seller/account/seller
/openapi/scx/seller.json get /v1/seller
List all created Seller
# Unlink Seller from Channel
Source: https://developer.jtl-software.com/api-reference/scx/seller/account/unlink-seller-from-channel
/openapi/scx/seller.json delete /v1/seller/channel/{channel}/{sellerId}
# Update Seller
Source: https://developer.jtl-software.com/api-reference/scx/seller/account/update-seller
/openapi/scx/seller.json patch /v1/seller/channel/{Channel}
# Acknowledge Events
Source: https://developer.jtl-software.com/api-reference/scx/seller/events/acknowledge-events
/openapi/scx/seller.json delete /v1/seller/event
Delete Events by eventId. If a event is deleted it will not redelivered with the next GET /channel/event call
# Channel Events
Source: https://developer.jtl-software.com/api-reference/scx/seller/events/channel-events
/openapi/scx/seller.json get /v2/seller/event
Retrieve ChannelEvents from all subscriped Channels. Channel Events are various different actions which occure
on the channel side.
**Such as**
* New Orders
* Order status changes
* Order Address changes
* Changes in listing process
These API route will deliver a list of unacknolaged events in a FIFO order. Each event is delivered At-Least-Once.
There is no garantee about uniquness. You may see Events with an identical payload multiply time.
After retrieving a list of Events by `GET /v2/seller/event` you have to acknowlage these Events using the `id`
property of each single event with `DELETE /v2/seller/event`. Unacknolaged events are getting invisible for 5
minutes. After these time a unacknowlaged event is getting visible again.
# Category Attributes
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/category-attributes
/openapi/scx/seller.json get /v1/seller/meta/{channel}/category/{categoryId}/attributes
# Category Tree
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/category-tree
/openapi/scx/seller.json get /v1/seller/meta/{channel}/categories
Returns JSON by default. Response can be gzipped if Accept header is set to "application/gzip".
# Category Tree Version List
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/category-tree-version-list
/openapi/scx/seller.json get /v1/seller/meta/category-tree-version
Deliver all category tree versions for Cannels where the currenty account has at least one active seller subscription
# Channel Attributes
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/channel-attributes
/openapi/scx/seller.json get /v1/seller/meta/{channel}/attributes
# Channel Payment
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/channel-payment
/openapi/scx/seller.json get /v1/seller/meta/{channel}/payment-rules
List all payment rules defined by channel
# Channel Price Types
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/channel-price-types
/openapi/scx/seller.json get /v1/seller/meta/{channel}/price-types
Provide channel supported price types
# Channel Seller Attributes
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/channel-seller-attributes
/openapi/scx/seller.json get /v1/seller/meta/{channel}/seller/attributes
# Channel Shipping
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/channel-shipping
/openapi/scx/seller.json get /v1/seller/meta/{channel}/shipping-rules
List all shipping rules defined by carrier
# Request Seller Attributes update
Source: https://developer.jtl-software.com/api-reference/scx/seller/meta/request-seller-attributes-update
/openapi/scx/seller.json post /v1/seller/meta/{channel}/seller/attributes
SCX will ask the Channel for a Seller Attribute update for all Sellers connected with this Chanel. Once the
update is prossed by Channel the Seller will receive a one Channel Event "Channel:MetaDataChanged" with
type=SELLER_ATTRIBUTES for each connected Seller.
# Create Offer
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/create-offer
/openapi/scx/seller.json post /v1/seller/offer
# End Offer
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/end-offer
/openapi/scx/seller.json delete /v1/seller/offer/end
# Update Offer
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/update-offer
/openapi/scx/seller.json put /v1/seller/offer
Update an existing Offer
# Update Price
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/update-price
/openapi/scx/seller.json put /v1/seller/offer/price
Lightweight request which update price informationonly for already listed offers. If a offer is not
yet listed on any Channel data will be be ignored.
# Update Stock
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/update-stock
/openapi/scx/seller.json put /v1/seller/offer/stock
Lightweight request which update stock amount only for already listed offers. If a offer is not yet listed
the requests will be ignored.
# Upload Files
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/upload-files
/openapi/scx/seller.json post /v1/seller/offer/file
Supported image formats are: GIF, JPEG, PNG, SVG
Supported document formats are: PDF, Plain text
# Upload Picture
Source: https://developer.jtl-software.com/api-reference/scx/seller/offer/upload-picture
/openapi/scx/seller.json post /v1/seller/offer/picture
(This API is deprecated by `POST /v1/seller/offer/file`)
Supported picture formats are: GIF JPEG PNG SVG
# Accept Cancellation Request
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/accept-cancellation-request
/openapi/scx/seller.json put /v1/channel/order/cancellation-accept
Accept a cancellation Request for a Order or OrderItem
# Deny Cancellation Request
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/deny-cancellation-request
/openapi/scx/seller.json put /v1/channel/order/cancellation-denied
Deny a cancellation Request for a Order or OrderItem
# Invoice
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/invoice
/openapi/scx/seller.json get /v1/seller/order/invoice/{documentId}
Download Invoice document
# Order Confirm
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/order-confirm
/openapi/scx/seller.json put /v1/seller/order/accept
Accept Order with Stauts `UNACKED`.
# Request Order Cancellation
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/request-order-cancellation
/openapi/scx/seller.json post /v1/seller/order/cancellation
Request cancallation for a Order or OrderItem
# Return
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/return
/openapi/scx/seller.json post /v1/seller/order/return
Send information about a received return.
# Send Refund
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/send-refund
/openapi/scx/seller.json post /v1/seller/order/refund
Send a refund for a list of Order Items to Channel
# Set Payment
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/set-payment
/openapi/scx/seller.json put /v1/seller/order/payment
Set payment information for orders.
# Shipping
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/shipping
/openapi/scx/seller.json put /v1/seller/order/shipping
Send shipping information for shipped orders
# Upload Invoice
Source: https://developer.jtl-software.com/api-reference/scx/seller/order/upload-invoice
/openapi/scx/seller.json post /v1/seller/order/invoice
Upload an invoice document for a previously created order. The returned `documentId` can later be used with `GetInvoiceDocument`.
# Report
Source: https://developer.jtl-software.com/api-reference/scx/seller/report/report
/openapi/scx/seller.json get /v1/seller/report/{reportId}
Download finsihed report as gzip compressed json
# Request Report
Source: https://developer.jtl-software.com/api-reference/scx/seller/report/request-report
/openapi/scx/seller.json post /v1/seller/report/request
Request a new report from channel.
Reports a valid for 48 hours after request indicated by expiresIn.
# Download Attachment
Source: https://developer.jtl-software.com/api-reference/scx/seller/ticket/download-attachment
/openapi/scx/seller.json get /v1/seller/ticket/attachment/{channel}
Download Attachment
# Reply to Ticket
Source: https://developer.jtl-software.com/api-reference/scx/seller/ticket/reply-to-ticket
/openapi/scx/seller.json post /v1/seller/ticket
Reply to a Ticket from Channel API
# Upload Attachment
Source: https://developer.jtl-software.com/api-reference/scx/seller/ticket/upload-attachment
/openapi/scx/seller.json post /v1/seller/ticket/attachment/{channel}
Upload a attachment for a Ticket
# GraphQL Schema Reference (v2.0)
Source: https://developer.jtl-software.com/api-reference/v2.0/graphql-schema
Complete GraphQL SDL schema for the JTL ERP API v2.0. Indexed for AI tools (MCP, llms.txt) to enable accurate query and mutation assistance.
# GraphQL Schema — JTL ERP API v2.0
This is the complete GraphQL schema (SDL) for the **JTL ERP API v2.0 (Cloud)**. It is
auto-generated from the official introspection output and kept in sync with
each API version.
**Use this schema to understand the available queries, mutations, input types, and
object types when building GraphQL requests against the JTL Platform API.**
* **Endpoint:** `https://api.jtl-cloud.com/erp/v2/graphql`
* **Authentication:** OAuth 2.0 Bearer token (see [Authentication guide](/guides/essentials/authentication/oauth2-flow))
* **Required header:** `x-tenant-id` — the tenant ID for the target ERP instance
* **Interactive playground:** [GraphQL Playground](/api-reference/graphql-playground)
## Schema (SDL)
```graphql theme={null}
schema {
query: Query
mutation: Mutation
}
"Reference data describing available employee tracking activity types."
type ActivityType {
"Activity type numeric value (kBuchungsart)."
value: Int!
"Display name of the activity type."
name: String!
}
"Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals. - Response"
type AddItemSupplierCommandResponse {
"Unique ID of the modified item."
itemId: ID!
}
"Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options. - Response"
type AddItemVariationCommandResponse {
"Unique ID of the newly added variation."
variationId: ID!
}
"Adds a new value to an existing item variation. - Response"
type AddItemVariationValueCommandResponse {
"Unique ID of the newly added variation value."
variationValueId: ID!
}
type AttributeSalesChannelValues {
"Identifies the saleschannel for this attributevalue"
salesChannelId: ID!
"Contains the values for a saleschannel"
values: [AttributeValue!]!
}
type AttributeValue {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Value of this attribute as string. Please consider the Attribute Type for correct formatting."
value: String!
}
type AttributeValues {
"Identifies the attribute"
attributeId: ID!
"Defines the default values for the attribute and item in different languages."
defaultValues: [AttributeValue!]!
"Contains all values for saleschannels for this attribute and item"
salesChannelValues: [AttributeSalesChannelValues!]!
}
"A list of batches for specific items and their quantities"
type BatchListItem {
"Id of the Item"
itemId: ID!
"The batch number"
batch: String!
"The quantity of the item in the batch"
quantity: Decimal!
"Id of the Warehouse"
warehouseId: ID!
}
"A list of best before dates (MHDs) for specific items and their quantities"
type BestBeforeListItem {
"Id of the Item"
itemId: ID!
"The best before date (MHD)"
bestBeforeDate: DateTime!
"The quantity of the item with this best before date"
quantity: Decimal!
"Id of the Warehouse"
warehouseId: ID!
}
"A bill of materials for a production item. It defines which operations must be performed and which components are required to produce the production item."
type BillOfMaterials {
"The ID of this bill of materials."
id: ID!
"The ID of the production item of this bill of materials."
productionItemId: ID!
"The version of this bill of materials."
version: Int!
"The name of this production bill of materials."
name: String!
"The description of this production bill of materials."
description: String!
"The status of this production bill of materials."
state: BillOfMaterialsState!
"The timestamp when this bill of materials was created."
createDate: DateTime!
"The timestamp when this bill of materials was last modified, or NULL if this bill of materials has not been modified yet."
updateDate: DateTime
"The ID of the user who last modified this bill of materials, or NULL if this bill of materials has not been modified yet."
updateUserId: ID
"The timestamp when this bill of materials was activated, or NULL if this bill of materials has not been activated yet."
activationDate: DateTime
"The last calculated producible stock."
producibleStock: Decimal!
"The timestamp when the producible stock was last calculated, or NULL if it has not been calculated yet."
producibleStockCalculationDate: DateTime
"Specifies requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsShelfLifeEndDateRequirements: OverallComponentPostingsInventoryAccountingDataRequirements!
"Specifies requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsBatchNumberRequirements: OverallComponentPostingsInventoryAccountingDataRequirements!
"Indicates how the shelf life end date of a product is calculated after completing a lot."
shelfLifeEndDateGenerationMode: ShelfLifeEndDateGenerationMode!
"A time span that is added when calculating the shelf life end date of a product after completing a lot."
additionalShelfLifeEndDateTime: TimeSpan
}
"Represents properties of a bill of materials child component."
type BillOfMaterialsChildComponentProperties {
"The ID of this bill of materials component's parent."
parentId: ID!
}
"Represents properties of a bill of materials component regardless of its type."
type BillOfMaterialsComponentProperties {
"The ID of this bill of materials component."
id: ID!
"The ID of the bill of materials this bill of materials component belongs to."
billOfMaterialsId: ID!
"The sort order of this bill of materials component within the bill of materials."
sort: Int!
}
"A bill of materials item."
type BillOfMaterialsItem {
"This bill of material item's properties common for all bill of materials components."
billOfMaterialsComponentProperties: BillOfMaterialsComponentProperties!
"This bill of material item's properties common for all bill of materials child components."
billOfMaterialsChildComponentProperties: BillOfMaterialsChildComponentProperties!
"This bill of material item's properties."
billOfMaterialsItemProperties: BillOfMaterialsItemProperties!
}
"Represents properties of a bill of materials item."
type BillOfMaterialsItemProperties {
"The ID of the item underlying this bill of materials item."
itemId: ID!
"The required quantity of this item for the production of the production item."
quantity: Decimal!
"The ID of the measurement unit in which the quantity is managed, or NULL if the quantity is managed in the sales unit of the underlying item."
measurementUnitId: ID
"The ID of the operation step to which the item is assigned, or NULL if the item is not assigned to any operation step."
operationStepId: ID
"Specifies requirements for the production input of this bill of materials component regarding the shelf life end dates of the stock accounts to be debited."
componentPostingsShelfLifeEndDateRequirements: ComponentPostingsInventoryAccountingDataRequirements!
"Specifies requirements for the production input of this bill of materials component regarding the batch numbers of the stock accounts to be debited."
componentPostingsBatchNumberRequirements: ComponentPostingsInventoryAccountingDataRequirements!
}
"A bill of materials operation."
type BillOfMaterialsOperation {
"This bill of material operation's properties common for all bill of materials components."
billOfMaterialsComponentProperties: BillOfMaterialsComponentProperties!
"This bill of material operation's properties."
billOfMaterialsOperationProperties: BillOfMaterialsOperationProperties!
}
"Represents properties of a bill of materials operation."
type BillOfMaterialsOperationProperties {
"The ID of the operation underlying this bill of materials operation."
operationId: ID!
}
"Single row of the bin locations overview list."
type BinLocationListItem {
"Unique bin location identifier."
binLocationId: ID!
"Warehouse that owns this bin location."
warehouseId: ID!
"Bin location name (unique within the warehouse)."
name: String!
"Current status of the bin location (0=Active, 1=Deactivated, 2=Locked)."
status: Int!
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: Int!
"Optional sort order."
sort: Int
}
"Occupancy data (fill factors) for a single bin location in a warehouse."
type BinLocationOccupancyItem {
"Unique bin location identifier."
binLocationId: ID!
"Date of the last WMS inventory count for this bin location. Null if never inventoried."
lastInventoryDate: DateTime
"Volume fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
volumeFillFactor: Decimal!
"Weight fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
weightFillFactor: Decimal!
}
"Single row of the bin location pick heatmap query."
type BinLocationPickHeatmapItem {
"Id of the bin location."
binLocationId: ID!
"Warehouse that owns this bin location."
warehouseId: ID!
"Number of completed pick operations in the selected time period."
pickCount: Int!
"Total quantity picked in the selected time period."
pickQuantity: Decimal!
}
"DTO for bin location status reference data."
type BinLocationStatusDto {
"Status identifier."
value: Int!
"Status name."
name: String!
}
"DTO for bin location type reference data."
type BinLocationTypeDto {
"Type identifier."
value: Int!
"Type name."
name: String!
}
"Calculate prices, discounts, and taxes for a sales order without persisting it. - Response"
type CalculateSalesOrderCommandResponse {
"The list of calculated sales order line items."
lineItems: [CalculateSalesOrderLineItemResponse!]!
"The total net amount for the sales order."
totalNetAmount: Decimal!
"The total gross amount for the sales order."
totalGrossAmount: Decimal!
"The VAT ID of the company for the departure country."
companyVatId: String!
"The ISO code of the currency used for the calculated prices."
currencyIso: String!
"The currency factor used for the price conversion."
currencyFactor: Decimal!
"The net shipping cost."
shippingCostNet: Decimal!
"The VAT amounts grouped by tax rate."
vatAmounts: [CalculateSalesOrderVatAmount!]!
"The gross shipping cost."
shippingCostGross: Decimal!
}
"Response model for a calculated sales order line item."
type CalculateSalesOrderLineItemResponse {
"The synchronization identifier for the line item."
syncNumber: Int!
"Type of the sales order line item."
type: LineItemType!
"The article\/item ID for the line item. Not set for shipping positions and free-text positions."
itemId: ID
"The quantity for the line item."
quantity: Decimal!
"The calculated net sales price for the line item."
salesPriceNet: Decimal!
"The calculated gross sales price for the line item."
salesPriceGross: Decimal!
"The discount percentage applied to the line item."
discountPercent: Decimal!
"The tax rate applied to the line item."
taxRate: Decimal!
"The tax class applied to the line item."
taxClassId: ID!
"The SyncNumber of the parent line item. Set for BOM components (negative SyncNumbers) and configuration components."
parentSyncNumber: Int
}
"VAT amount for a specific tax rate."
type CalculateSalesOrderVatAmount {
"The tax rate in percent (e.g. 19.0 for 19% VAT)."
taxRate: Decimal!
"The VAT amount for this tax rate."
vatAmount: Decimal!
}
"Category details"
type CategoryDetails {
"Id of the category."
id: ID!
"Id of the parent category."
parentId: ID
"Sortnumber of the category."
sortNumber: Int!
"Category descriptions"
descriptions: [CategoryDetailsDescription!]!
}
"Category description details"
type CategoryDetailsDescription {
"Associated category"
categoryId: ID!
"Category description saleschannel key"
salesChannelId: ID!
"Category description language key"
languageId: ID!
"Category name"
name: String
"Category description"
description: String
"Category metadescription"
metaDescription: String
"Category metakeywords"
metaKeywords: String
"Category meta title tag"
titleTag: String
"Category meta url path"
urlPath: String
}
"Single Row of the category overview"
type CategoryListItem {
"Id of the category."
id: ID!
"Id of the parent category."
parentId: ID
"Sortnumber of the category."
sortNumber: Int
"Default Category Name"
name: String
}
"Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information. - Response"
type ChangeItemCommandResponse {
"The changed item."
item: ItemdetailsItem!
}
"Represents a company address"
type CompanyAddress {
"Company ID"
id: ID!
"Company name"
name: String!
"Entrepreneur"
entrepreneur: String!
"Street"
street: String!
"Zip code"
zipCode: String!
"City"
city: String!
"Country"
country: String!
"Phone"
phone: String!
"Mail"
mail: String!
"ISO code"
iso: String!
}
"Single row of the company table"
type CompanyDetailsItem {
"Unique ID to identify a company (kFirma)."
id: ID!
"Name of the company."
companyName: String
"Owner of the company."
owner: String
"Street address of the company."
street: String
"Postal code of the company."
postalCode: String
"City of the company."
city: String
"Country of the company."
country: String
"Country ISO code."
countryIsoCode: String
"Phone number of the company."
phone: String
"Fax number of the company."
fax: String
"Email address of the company."
emailAddress: String
"Website of the company."
website: String
"Bank code."
bankCode: String
"Bank account number."
accountNumber: String
"Name of the bank."
bankName: String
"Tax identification number."
taxId: String
"International Bank Account Number."
iban: String
"Bank Identifier Code."
bic: String
"Bank account holder name."
accountHolder: String
"Creditor identification number."
creditorId: String
"PayPal email address of the company."
payPalEmailAddress: String
"Indicates if the company is a small business owner."
isSmallBusinessOwner: Boolean!
"DHL Intraship customer Id for shipping."
dhlIntrashipCustomerId: String
"UPS customer Id for shipping."
upsCustomerId: String
"List of company vat ids."
companyVatIdentifiers: [CompanyVatIdDetailsItem!]!
}
"Single row of the company table"
type CompanyListItem {
"Unique ID to identify a company (kFirma)."
id: ID!
"Name of the company."
companyName: String
"Owner of the company."
owner: String
"Street address of the company."
street: String
"Postal code of the company."
postalCode: String
"City of the company."
city: String
"Country of the company."
country: String
"Country ISO code."
countryIsoCode: String
"Phone number of the company."
phone: String
"Fax number of the company."
fax: String
"Email address of the company."
emailAddress: String
"Website of the company."
website: String
"Bank code."
bankCode: String
"Bank account number."
accountNumber: String
"Name of the bank."
bankName: String
"Tax identification number."
taxId: String
"International Bank Account Number."
iban: String
"Bank Identifier Code."
bic: String
"Bank account holder name."
accountHolder: String
"Creditor identification number."
creditorId: String
"PayPal email address of the company."
payPalEmailAddress: String
"Indicates if the company is a small business owner."
isSmallBusinessOwner: Boolean!
"DHL Intraship customer Id for shipping."
dhlIntrashipCustomerId: String
"UPS customer Id for shipping."
upsCustomerId: String
"List of company vat ids."
companyVatIdentifiers: [CompanyVatIdItem!]!
}
"Single row of the company VAT id table"
type CompanyVatIdDetailsItem {
"Unique VAT ID."
id: ID!
"The company id."
companyId: ID!
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"Single row of the company VAT id table"
type CompanyVatIdItem {
"Unique VAT ID."
id: ID!
"The company id."
companyId: ID!
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"- Response"
type CopyItemdetailsCommandResponse {
"Unique IDs of the items that received copied values."
itemId: [ID]!
}
"Definition of a country item"
type CountryItem {
"The ISO code of the country"
countryIso: String!
"The three Character ISO code of the country"
countryIso3: String!
"The name of the country"
name: String!
"The continent of the country"
continent: String!
"The ISO code of the currency used in the country"
currencyIso: String!
"The numeric ISO code of the country"
numericIso: Int!
"Indicates if the country is part of the European Union"
isEu: Boolean!
"The default culture associated with the country"
defaultCulture: String!
"The display name for states Name in the country"
displayNameState: String!
"List of known states in the country"
knownStates: [CountryStateItem!]!
}
"Definition of a country state item"
type CountryStateItem {
"The short region code of the state"
regionCode: String!
"The Full ISO code of the state in ISO 3166-2"
isoCode: String!
"The name of the state"
name: String!
}
"Creates a new bill of materials for a production item, including its components. - Response"
type CreateBillOfMaterialsCommandResponse {
"The ID of the newly created bill of materials."
id: ID!
}
"Creates a new bill of materials item for a bill of materials operation. - Response"
type CreateBillOfMaterialsItemCommandResponse {
"The ID of the newly created bill of materials item."
id: ID!
}
"Creates a new bill of materials operation for a bill of materials, including its items. - Response"
type CreateBillOfMaterialsOperationCommandResponse {
"The ID of the newly created bill of materials operation."
id: ID!
}
"Creates a new bin location in a warehouse. - Response"
type CreateBinLocationCommandResponse {
"The ID of the newly created bin location."
binLocationId: ID!
}
"Creates a new Category. - Response"
type CreateCategoryCommandResponse {
"Unique ID of the newly created category."
categoryId: ID!
}
"Creates a customer - Response"
type CreateCustomerCommandResponse {
"Unique ID of the newly created customer."
customerId: ID!
}
"Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements. - Response"
type CreateItemCommandResponse {
"Unique ID of the newly created item - this key is used for all further operations with the item."
itemId: ID!
}
"Creates a new lot size for a production item. - Response"
type CreateLotSizeCommandResponse {
"The ID of the newly created lot size."
id: ID!
}
"Creates a new production item, including its bills of materials with their components. - Response"
type CreateProductionItemCommandResponse {
"The ID of the newly created production item."
id: ID!
}
"Creates a new production order. - Response"
type CreateProductionOrderCommandResponse {
"The ID of the newly created production order."
id: ID!
}
"Create a new sales invoice for a salesorder - Response"
type CreateSalesInvoiceCommandResponse {
"The Id of the created sales invoice"
salesInvoiceId: ID!
}
"Create a new sales invoice correction from an existing invoice - Response"
type CreateSalesInvoiceCorrectionCommandResponse {
"The Id of the created sales invoice correction"
salesInvoiceCorrectionId: ID!
}
"Creates a new sales order. - Response"
type CreateSalesOrderCommandResponse {
"Unique ID of the newly created sales order."
salesOrderId: ID!
}
"Create a new sales order for a sales quotation - Response"
type CreateSalesOrderFromSalesQuotationCommandResponse {
"The ID of the created sales order"
salesOrderId: ID!
}
"Creates a new sales quotation. - Response"
type CreateSalesQuotationCommandResponse {
"Unique ID of the newly created sales quotation."
salesQuotationId: ID!
}
"Creates a new shipping box within a warehouse. - Response"
type CreateShippingBoxCommandResponse {
"The ID of the newly created shipping box."
shippingBoxId: ID!
}
"Creates a new shipping class - Response"
type CreateShippingClassCommandResponse {
"Id of the new ShippingClass"
id: ID!
}
"Creates a new warehouse zone. - Response"
type CreateWarehouseZoneCommandResponse {
"The ID of the newly created warehouse zone."
zoneId: ID!
}
"Creates a new workbench resource - Response"
type CreateWorkbenchResourceCommandResponse {
"The new workbench resource's ID."
id: ID!
}
"Creates a new workbench resource type - Response"
type CreateWorkbenchResourceTypeCommandResponse {
"The new workbench resource type's ID"
id: ID!
}
"Single row of the currencies overview table"
type Currency {
"Currency id"
id: ID!
"Currency factor"
factor: Decimal!
"Is default currency"
isDefault: Boolean!
"ISO code of the currency"
iso: String!
"Name of the currency"
name: String
"Date and time of the last update"
updated: DateTime
}
"Metadata definition of custom fields (Eigene Felder)"
type CustomFieldListItem {
"Unique identifier of the custom field."
customFieldKey: ID!
"Name of the custom field in the specified language."
name: String!
"Group name where the custom field belongs to."
group: String
"Data type of the custom field. Possible values: Kein = No specific type, Ganzzahl = Integer number, FliesskommaZahl = Floating point number, Text = Free text, Checkbox = Boolean checkbox, Liste = Selection list, Url = Website URL, EMail = Email address, TelNr = Phone number, LandIso = Country ISO code, Preis = Price\/Currency, Datum = Date, KurzText = Short text"
customFieldType: CustomFieldType!
"The underlying .NET data type of the CustomFieldType: 'int' for Ganzzahl and Checkbox, 'string' for Text, KurzText, Url, EMail, TelNr, LandIso, Liste, and Kein, 'decimal' for FliesskommaZahl and Preis, 'DateTime' for Datum"
dataType: String!
"Indicates whether the field is mandatory."
isRequired: Boolean!
"Entity type the custom field belongs to (e.g., Artikel, Kategorie, Kunde)."
referenceType: CustomFieldReferenceType!
"Sort order within the group."
sort: Int!
"Indicates whether the field value is readonly."
isReadonly: Boolean!
"Indicates whether the field is hidden in UI."
isInvisible: Boolean!
"Description of the custom field."
description: String
}
"A single customer by its id"
type Customer {
"Customer id"
customerId: ID!
"Id of the customer group"
customerGroupId: ID!
"Customer number"
customerNumber: String
"Date when the customer was created"
createdDate: DateTime!
"List of addresses of the customer"
customerAddresses: [CustomerAddress!]!
"The customer group of the customer"
customerGroup: CustomerGroup!
"The language iso code of the customer"
languageIso: String
}
type CustomerAddress {
"Unique ID of the address."
customerAddressId: ID!
"Unique ID of the customer."
customerId: ID!
"Indicates whether this is the default address of the customer."
isDefault: Boolean!
"Type of the address (shipment, billing, etc.)."
addressType: CustomerAddressType!
"Company name of the customer"
companyName: String
"Additional company information line."
additionalCompanyLine: String
"Salutation of the customer (e.g. Mr., Mrs., etc.)"
salutation: String
"Title of the customer (e.g. Dr., Prof., etc.)"
title: String
"First name of the customer"
firstName: String
"Last name of the customer"
lastName: String
"Name of the street (including number)."
street: String
"Additional address information."
additionalAddressLine: String
"Postal code of the customer."
postalCode: String
"City name of the customer."
city: String
"ISO code of the country"
countryIso: String
"Name of the state."
state: String
"The customers email address."
emailAddress: String
"The customers fax number."
faxNumber: String
"The customers phone number."
phoneNumber: String
"The customers mobile phone number."
mobilePhoneNumber: String
"The customers VAT identification number."
vatId: String
}
type CustomerCategory {
"Unique internal ID of the customer category."
id: ID!
"The name of the customer category."
name: String!
}
type CustomerGroup {
"Unique internal ID of the customer group."
id: ID!
"The name of the customer group."
name: String!
"Indicates if the customer group is the default group. Only one group can be selected as the default group."
isDefault: Boolean!
"The discounted percentage for the customer group."
discount: Decimal!
"Indicates if the customer group sees the net price in the online shop."
isNetPrice: Boolean!
}
type CustomerGroupSurcharge {
"Id of the customergroup"
customerGroupId: ID!
"Surcharge for that customergroup"
surcharge: Decimal!
"Defines if the surcharges will be synchronized to online saleschannels. Does not apply for the default customer group surcharges, which are always synchronized when not overriden."
isActive: Boolean!
}
"Single row of the customers overview table"
type CustomerListItem {
"Customer id"
id: ID!
"Customer number"
customerNumber: String
"Customer's eBay user name."
ebayName: String
"Customer's date of birth."
birthday: String
"Customer's homepage URL."
homepage: String
"Last name of the customer"
lastName: String
"First name of the customer"
firstName: String
"Phone number."
phoneNumber: String
"Fax number."
faxNumber: String
"Email address."
emailAddress: String
"Company name (if applicable)."
companyName: String
"Postal code."
postalCode: String
"City."
city: String
"Country name."
countryName: String
"ISO-Code of the country."
countryIso: String
"Company extension."
additionalCompanyLine: String
"Formal salutation (e.g., Mr., Ms.)."
salutation: String
"Academic or professional title."
title: String
"Street and house number."
street: String
"Additional address information."
additionalAddressLine: String
"Date the customer record was created."
createdDate: DateTime
"Mobile phone number."
mobilePhoneNumber: String
"Customer-specific discount rate."
discountRate: Decimal
"VAT identification number."
vatId: String
"Subscription status for the newsletter."
hasNewsletter: Boolean!
"Customer's PostID (specific delivery identifier)."
postId: String
"Number of days for payment terms."
paymentDueDateInDays: Int
"Federal state or province."
state: String
"Source or origin of the customer."
initialContact: String
"Flag indicating if the customer is a cash register\/POS customer."
isCashRegisterBased: Boolean!
"Account lock status."
isLocked: Boolean!
"Commercial register number."
commercialRegisterNumber: String
"Accounts receivable number for accounting."
accountsReceivableNumber: Int
"Name of the customer category."
customerCategoryName: String
"Name of the customer group."
customerGroupName: String
"Key\/ID of the customer category."
customerCategoryId: ID
"Key\/ID of the customer group."
customerGroupId: ID
"Flag indicating participation in JTL Fulfillment."
isJtlFulfillment: Boolean!
"Comma-separated list of all assigned customer labels."
labels: String
"The language iso code of the customer"
languageIso: String
}
"Defines a default description of an item in a specific language. This description is used as a fallback when no more specific platform or sales channel descriptions are available."
type DefaultDescription {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the actual description data such as name, short and long description as well as SEO-relevant information."
descriptionData: DescriptionData!
}
"Removes an existing variation from an item. All associated variation values and combinations will also be removed. - Response"
type DeleteItemVariationCommandResponse {
"Unique ID of the deleted variation."
variationId: ID!
}
"Removes a specific value from an item variation. - Response"
type DeleteItemVariationValueCommandResponse {
"Unique ID of the deleted variation value."
variationValueId: ID!
}
"A delivery note item"
type DeliveryNoteItem {
"Unique ID to identify a delivery note."
id: ID!
"Created at timestamp"
createdAt: DateTime!
"Delivery note number"
number: String!
}
type Description {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Name of the Variation in the specific language"
name: String!
}
"Defines the actual description data of an item. This structure contains all textual information of an item including SEO-relevant metadata for online shops."
type DescriptionData {
"The name of the item as displayed in the user interface or shop."
itemName: String
"Short description of the item for overview displays and search results."
shortDescription: String
"Detailed description of the item with comprehensive product information and properties."
description: String
"Meta description for search engine optimization (SEO) that is displayed in search results."
metaDescription: String
"Meta keywords for search engine optimization to improve discoverability of the item."
metaKeywords: String
"HTML title tag for the item that is displayed in the browser tab and search results."
titleTag: String
"URL path for the item to create SEO-friendly and speaking URLs."
urlPath: String
}
"Creates one or more duplicates of an existing item with specified duplication options. - Response"
type DuplicateItemsCommandResponse {
"The list of unique identifiers (ArtikelKeys) for all successfully created duplicate items."
createdItems: [ID]!
}
type EbayImages {
"Unique ID to identify an ebay account."
ebayAccountId: ID!
"List of images assigned to the platform."
images: [ItemImage!]!
}
"Last tracked bin location activity per employee."
type EmployeeLocationItem {
"Employee user ID (kBenutzer)."
userIdentifier: Int!
"Employee display name."
userName: String!
"Timestamp of the last tracked activity."
lastActivityTimestamp: DateTime!
"Bin location where the last activity occurred."
binLocationId: ID!
"Activity type of the last activity."
activityTypeId: ID!
"Display name of the activity type."
activityTypeName: String!
"Article involved in the activity, if available."
articleId: ID
"Article display name or number, if available."
articleName: String
}
"An empty sales order with default values."
type EmptySalesOrder {
"The default sales order date (current date\/time)."
salesOrderDate: DateTime
"The default item description type from global settings."
itemDescriptionType: ItemDescriptionType!
"The default read-only type."
readOnlyType: ReadOnlyType!
"The company ID the sales order is initialized for."
companyId: ID!
"The default language ID."
languageId: ID!
"The default additional weight from global settings."
additionalWeight: Decimal!
"The VAT ID of the company."
vatId: String
"The special tax treatment setting."
specialTaxTreatment: SpecialTaxTreatment!
"The tax setting."
taxSetting: TaxSetting!
"The departure country information."
departureCountry: EmptySalesOrderDepartureCountry!
"The payment details."
paymentDetails: EmptySalesOrderPaymentDetails!
"The initialized empty billing address."
billingAddress: EmptySalesOrderAddress!
"The initialized empty shipment address."
shipmentAddress: EmptySalesOrderAddress!
}
"An empty initialized address for the sales order."
type EmptySalesOrderAddress {
"The address salutation."
salutation: String
"The address title."
title: String
"The first name."
firstName: String
"The last name."
lastName: String
"The company name."
company: String
"Additional company line."
additionalCompanyLine: String
"The street address."
street: String
"Additional address line."
additionalAddressLine: String
"The postal code."
postalCode: String
"The city."
city: String
"The state or region."
state: String
"The country ISO code."
countryIso: String
"The country name."
countryName: String
"The email address."
emailAddress: String
"The phone number."
phoneNumber: String
"The mobile phone number."
mobilePhoneNumber: String
"The fax number."
fax: String
}
"Departure country information for the empty sales order."
type EmptySalesOrderDepartureCountry {
"The ISO code of the departure country (default is company headquarters)."
countryIso: String!
"The currency ISO code of the departure country."
currencyIso: String!
"The currency factor."
currencyFactor: Decimal!
}
"Payment details for the empty sales order."
type EmptySalesOrderPaymentDetails {
"The default currency ISO code."
currencyIso: String!
"The default currency factor."
currencyFactor: Decimal!
"The default payment due date in days."
paymentDueDateInDays: Int!
"The default cash discount percentage."
cashDiscount: Decimal!
"The default cash discount days."
cashDiscountDays: Int!
}
"External document M&A"
type ExternalDocumentInternal {
"Primary key of document"
externalDocumentTransactionId: ID!
"Primary key of company"
companyId: ID
"Primary key of customer"
customerId: ID
"Primary key of platform"
platformId: ID
"Primary key of payment type document"
paymentMethodId: ID
"Primary key of invoice"
externalInvoiceDocumentId: ID
"Invoice number"
salesInvoiceNumber: String
"Credit note number"
externalDocumentNumber: String
"Document date"
externalDocumentDate: DateTime!
"External order number"
externalDocumentOrderNumber: String
"Currency factor"
currencyFactor: Decimal!
"Currency code"
currency: String
"Shipping currency code"
departureCountryCurrencyIso: String
"Shipping currency factor"
departureCountryCurrenyFactor: Decimal
"Service date"
serviceDate: DateTime!
"Payment date"
payDate: DateTime!
"Platform ID"
platformIdentifier: String
"Debtor number"
accountsReceivableNumber: Int
"Tax setting"
taxSetting: Byte!
"Document type"
externalDocumentType: Byte!
"Country VAT ID"
companyVatIdNumber: String
"Seller VAT ID"
customerVatIdNumber: String
"Shipping country ISO code"
departureCountryIso: String
"Payment information"
paymentMethodName: String
"Order date"
orderDate: DateTime!
"Shipping company name"
shipmentAddressCompany: String
"Shipping last name"
shipmentAddressLastName: String
"Shipping street address"
shipmentAddressStreet: String
"Shipping ZIP code"
shipmentAddressPostalCode: String
"Shipping city"
shipmentAddressCity: String
"Shipping phone number"
shipmentAddressPhoneNumber: String
"Shipping additional address information"
shipmentAddressAdditionalAddressLine: String
"Shipping country ISO code"
shipmentAddressCountryIso: String
"Shipping VAT ID"
shipmentAddressVatIdNumber: String
"Customer company name"
customerDefaultBillingAddressCompany: String
"Customer salutation"
customerDefaultBillingAddressSalutation: String
"Customer title"
customerDefaultBillingAddressTitle: String
"Customer first name"
customerDefaultBillingAddressFirstName: String
"Customer last name"
customerDefaultBillingAddressLastName: String
"Customer street address"
customerDefaultBillingAddressStreet: String
"Customer ZIP code"
customerDefaultBillingAddressPostalCode: String
"Customer city"
customerDefaultBillingAddressCity: String
"Customer country"
customerDefaultBillingAddressCountry: String
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: String
"Customer fax number"
customerDefaultBillingAddressFaxNumber: String
"Customer additional information"
customerDefaultBillingAddressForTheAttentionOf: String
"Customer country ISO code"
customerDefaultBillingAddressCountryIso: String
"Customer email address"
customerDefaultBillingAddressEmailAddress: String
"Customer VAT ID"
customerDefaultBillingAddressVatIdNumber: String
"Customer number from sales order"
salesOrderCustomerNumber: String
"Customer group"
customerGroupName: String
"Payment due date in days"
paymentDueDateInDays: Int!
"Customer number"
customerNumber: String
"Invoice company name"
billingAddressCompany: String
"Invoice last name"
billingAddressLastName: String
"Invoice street address"
billingAddressStreet: String
"Invoice ZIP code"
billingAddressPostalCode: String
"Invoice city"
billingAddressCity: String
"Invoice phone number"
billingAddressPhoneNumber: String
"Invoice additional address information"
billingAddressAdditionalAddressLine: String
"Invoice country ISO code"
billingAddressCountryIso: String
"Invoice VAT ID"
billingAddressVatIdNumber: String
"Document total gross value"
externalDocumentTotalGrossValue: Decimal!
"Document total net value"
externalDocumentTotalNetValue: Decimal!
"Shipping date"
shipmentDate: DateTime
"Order payment type"
orderPaymentMethodName: String
"Shipping country count"
shipmentCountryCount: Int!
}
"External document position for M&A system"
type ExternalDocumentLineItemInternal {
"External document line item ID"
externalDocumentLineItemId: ID!
"External document ID"
externalDocumentId: ID!
"Sales price gross"
externalDocumentSalesPriceGross: Decimal!
"External document sales price net"
externalDocumentSalesPriceNet: Decimal!
"External document purchase price net"
externalDocumentPurchasePriceNet: Decimal
"Quantity"
quantity: Decimal!
"Item name"
itemName: String
"SKU"
sku: String
"Tax rate"
taxRate: Decimal!
"Tax class ID"
taxClassId: ID
"Taric code"
taric: String
"Item weight"
itemWeight: Decimal
"Item volume"
itemVolume: Decimal
"Product group ID"
productGroupId: ID
"Purchase price net"
purchasePriceNet: Decimal
"Product group"
productGroup: String
"Warehouse ID"
warehouseId: ID
"External document invoice line item ID"
externalDocumentInvoiceLineItemId: ID!
}
"A connection to a list of items."
type GetItemSuppliersByIdConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [GetItemSuppliersByIdEdge!]
"A flattened list of the nodes."
nodes: [ItemSupplierListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type GetItemSuppliersByIdEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ItemSupplierListItem!
}
type ItemAttributes {
"Contains all attribute values assigned to the item"
values: [AttributeValues!]!
}
"Defines the category assignments of an item for creation. This structure manages all categories to which an item can be assigned and enables hierarchical classification for better organization and navigation."
type ItemCategories {
"Contains all categories to which the item is assigned. An item can be assigned to multiple categories simultaneously to enable flexible categorization and better discoverability."
categories: [ItemCategory!]!
}
"Defines a single category assignment for an item. This structure represents the link between an item and a specific category in the hierarchical category system of the ERP system."
type ItemCategory {
"Unique key of the category that identifies the specific category to which the item should be assigned. This key establishes the connection to the category data."
categoryId: ID!
}
"Defines a single custom field value for an item. This structure connects a custom field definition with its actual value for a specific item."
type ItemCustomFieldValue {
"Unique identifier of the custom field definition. References the custom field that was previously created in the system."
fieldId: ID!
"The actual value stored in this custom field. The format and content depend on the custom field type definition (text, number, date, etc.)."
value: String!
"The culture name (e.g., \"en-US\", \"de-DE\") associated with the custom field value. This is important for localized fields where the value may vary based on the user's language or region. When returning those values from the server side this Format is always InvariantCulture. When sending values to the server side the culture name is optional and if not provided, it will be treated as InvariantCulture. Otherwise this value initializes a CultureInfo Object."
valueCultureName: String!
}
"Defines custom fields for an item to store additional, user-defined information. Custom fields allow flexible extension of item data beyond standard properties and can be used for special business requirements, integrations, or custom workflows."
type ItemCustomFields {
"List of custom field values assigned to the item. Each entry represents a custom field with its corresponding value."
fieldValues: [ItemCustomFieldValue!]!
}
"Defines customer group-specific prices for an item. This structure enables differentiated pricing by customer groups, allowing different price levels for different customer segments."
type ItemCustomerGroupPrices {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers)."
customerGroupId: ID!
"List of prices for this customer group - can contain different tier prices or volume discounts."
prices: [ItemPrice!]!
}
"Defines a customer group-specific special price for an item. This structure represents a single promotional price for a specific customer group in a sales channel."
type ItemCustomerGroupSpecialPrice {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers) for which this special price applies."
customerGroupId: ID!
"Net special price for this customer group without taxes. Setting this to null will deactivate the special price for this customer group."
netPrice: Decimal
"Indicates whether this special price is active for this customer group. Automatically set to false when NetPrice is set to null."
isActive: Boolean!
}
"Defines customer-specific prices for an item. This structure enables individual price agreements for specific customers that can deviate from standard or customer group prices."
type ItemCustomerPrices {
"Key of the customer that identifies the specific customer for whom these individual prices apply."
customerId: ID!
"List of individual prices for this customer - can contain different tier prices or special conditions."
prices: [ItemPrice!]!
}
"Defines the collection of all descriptions of an item for creation. This structure manages default, platform, and sales channel-specific item descriptions for different languages and distribution channels."
type ItemDescriptions {
"Default descriptions of the item. This is used when no more specific platform or sales channel descriptions are available and serves as a fallback description."
defaultDescriptions: [DefaultDescription!]!
"List of sales channel-specific descriptions for sales platforms like JTL-Shop. Enables individual customization of item descriptions for specific sales channels."
salesChannelDescriptions: [SalesChannelDescription!]!
"List of platform-specific descriptions for non-sales platforms like print. Allows different descriptions for various output platforms."
platformDescriptions: [PlatformDescription!]!
}
"Defines a single feature assignment for an item. This structure represents the link between an item and a specific feature value from the feature system, allowing detailed product characterization."
type ItemFeature {
"Unique key of the feature value that identifies the specific feature characteristic to be assigned to the item. This key establishes the connection to a predefined feature value in the feature system."
featureId: ID!
}
"Defines the feature assignments of an item. This structure manages all features (characteristics\/attributes) that describe specific properties or attributes of an item, such as color, size, material, or other custom characteristics used for product differentiation and filtering."
type ItemFeatures {
"Contains all features assigned to the item. Each feature represents a specific characteristic or attribute that describes the item in more detail, enabling better product differentiation and advanced filtering capabilities."
features: [ItemFeature!]!
}
"Defines various identifiers of an item for creation. This structure includes all relevant markings and numbers used for unique identification of an item."
type ItemIdentifiers {
"Unique item number (Stock Keeping Unit) - the user-assigned main identification of the item."
sku: String!
"Amazon FNSKU (Fulfillment Network Stock Keeping Unit) - used by Amazon for inventory management."
amazonFnsku: String
"GTIN (Global Trade Item Number, formerly EAN) - internationally standardized product identification for global trade."
gtin: String
"Manufacturer's item number - the official product number assigned by the manufacturer."
manufacturerNumber: String
"ISBN (International Standard Book Number) - mainly used for books and other publications."
isbn: String
"Taric code - customs tariff number for international trade and customs processing."
tariccode: String
"UPC (Universal Product Code) - barcode standard mainly used in North America."
upc: String
"UN number - used for marking dangerous goods in transport."
unNumber: String
"Hazard number - identifies the type of danger for hazardous goods in transport."
hazardNumber: String
"Own identifier - user-defined internal identification for company-specific purposes."
ownIdentifier: String
"Default ASIN (Amazon Standard Identification Number) - primary Amazon product identification."
defaultAsin: String
"JTL-Fulfillment-SKU (JFSKU) - unique identifier in the JTL Fulfillment Network (FFN) for item identification."
jfsku: String
}
type ItemImage {
"Unique ID to identify an image."
blobIdentifier: UUID
"Download Url for the image."
url: String
"Download Url for the image."
previewUrl: String
"Sortnumber of the image."
sortNumber: Int!
"Declares the main image of the item. Typically it is the image with sortnumber 1."
isMainImage: Boolean!
}
type ItemImages {
"List of default images assigned to the item."
defaultImages: [ItemImage!]!
"List of images assigned to different platforms."
platformImages: [PlatformImages!]!
"List of images assigned to different saleschannels."
saleschannelImages: [SaleschannelImages!]!
"List of images assigned to different eBay accounts."
ebayImages: [EbayImages!]!
}
"Single row of the item overview"
type ItemListItem {
"Item id"
id: ID!
"Bill of materials ID"
billOfMaterialsId: Int
"Parent item ID (for variation children)"
parentItemId: ID
"Item id for category search"
itemIdForCategoryItemId: ID
"Item number"
sku: String!
"Sort number for display ordering"
sortNumber: Int!
"Name of the item in the requested language"
name: String
"Sales unit name"
unit: String
"Item description (first 255 chars)"
description: String
"Short description (first 255 chars)"
shortDescription: String
"Notes of the item"
notes: String
"Label names"
labels: String
"Series name"
series: String
"GTIN (former EAN) of the item"
gtin: String
"Manufacturer number of the item"
manufacturerNumber: String
"ISBN of the item"
isbn: String
"Default ASIN of the item"
defaultAsin: String
"TaricCode of the item"
taricCode: String
"UPC of the item"
upc: String
"UNNumber of the item"
unNumber: String
"HazardNumber of the item"
hazardNumber: String
"Amazon FNSKU"
amazonFnsku: String
"Identifier for JTL Fulfillment Network"
jfsku: String
"Country of origin"
countryOfOrigin: String
"Name of the manufacturer"
manufacturerName: String
"Delivery status name"
deliveryStatus: String
"Automatic delivery time calculation active"
isDeliveryTimeAutomatic: Boolean!
"Manual delivery time in days"
manualDeliveryTimeDays: Int
"Item width"
width: Decimal!
"Item height"
height: Decimal!
"Item length"
length: Decimal!
"Shipping weight"
shippingWeight: Decimal!
"Item weight (without packaging)"
weight: Decimal!
"Creation date of the item"
createdDate: DateTime
"Last modification date (date only)"
modifiedDate: DateTime
"Last modification timestamp (date and time)"
modifiedTimestamp: DateTime
"Release date of the item"
releaseDate: DateTime
"Date of last purchase"
lastPurchaseDate: DateTime
"Name of the last editor"
lastEditor: String
"Item Net Price"
salesPriceNet: Decimal!
"Sales price gross (including tax)"
salesPriceGross: Decimal!
"UVP"
suggestedRetailPrice: Decimal!
"Average purchase price net"
averagePurchasePriceNet: Decimal!
"Last Purchase Net Price"
lastPurchasePrice: Decimal!
"AmazonPrice Net Price"
amazonPrice: Decimal!
"EbayPrice Net Price"
ebayPrice: Decimal!
"Profit of this item"
profit: Decimal
"Profit in percent"
profitPercent: Decimal!
"Special price status (0 = no special price, 1 = expired, 2 = active)"
specialPriceStatus: Int!
"Base price value"
basePriceValue: Decimal
"Base price unit display code"
basePriceUnit: String
"Measurement unit name"
measurementUnit: String
"Total stock in all warehouses"
stockTotal: Decimal!
"Own Stock (without children\/variations)"
stockOwn: Decimal!
"Stock incoming"
stockIncoming: Decimal!
"Stock on purchase list"
stockOnPurchaseList: Decimal!
"Total stock in orders"
stockInOrders: Decimal!
"Available stock"
stockAvailable: Decimal!
"Total stock reserved"
stockReservedTotal: Decimal!
"Stock in Amazon offers"
stockInAmazonOffers: Int!
"Stock in eBay listings"
ebayStock: Decimal!
"Minimum order quantity"
minimumOrderQuantity: Decimal!
"Purchase interval"
purchaseInterval: Decimal!
"The item buffer"
buffer: Int!
"The Item minimum stock level"
minimumStock: Decimal!
"Determines if negative stock is allowed for this item"
allowNegativeStock: Boolean!
"Determines if the item is working with inventory management"
isInventoryManagementActive: Boolean!
"Determines if the item is working with split quantities in stock"
isDivisible: Boolean!
"The Item HasBatch"
hasBatch: Boolean!
"Determines if the item is working with best before date (MHD)"
hasBestBeforeDate: Boolean!
"If the item uses serial number management."
isSerialNumberManaged: Boolean!
"Serial number tracking flag"
serialNumberTrackingMode: SerialNumberTrackingMode!
"Indicates if the item is active"
isActive: Boolean!
"Is on price list flag"
isOnPriceList: Boolean!
"Is top item flag"
isTopItem: Boolean!
"Is new item flag"
isNew: Boolean!
"Is bill of materials"
isBillOfMaterials: Boolean!
"Is bill of materials component"
isBillOfMaterialsComponent: Boolean!
"Is variation parent"
isVariationParent: Boolean!
"Is variation child"
isVariationChild: Boolean!
"Has minimum stock level"
hasMinimumStock: Boolean!
"Is blocked for order suggestions"
isBlockedForOrderSuggestions: Boolean!
"Is active in at least one shop"
isShopActive: Boolean!
"No order process flag"
isOrderProcessProhibited: Boolean!
"Sales packaging unit (VPE)"
salesPackagingUnit: Byte
"Condition ID"
conditionId: ID
"Condition name"
conditionName: String
"Determines if the item is being shared in the JTL Fulfillment Network"
isFulfillmentActive: Boolean!
"Determines if the item is managed by this client"
isFulfillmentOwn: Boolean!
"Tax class ID"
taxClassId: ID
"Name of the tax class"
taxClassName: String
"Manufacturer ID"
manufacturerId: ID
"Product group ID"
productGroupId: ID
"Name of the ProductGroup"
productGroupName: String
"Default supplier ID"
defaultSupplierId: ID
"Name of the Default Supplier"
defaultSupplier: String
"Shipping class ID"
shippingClassId: ID
"Shipping class name"
shippingClassName: String
"The id of the default image."
defaultImageId: ID
"Additional processing time in days"
additionalProcessingTime: Int
"Meta description for SEO (first 255 chars)"
metaDescription: String
"Title tag for SEO (first 255 chars)"
titleTag: String
"Meta keywords for SEO (first 255 chars)"
metaKeywords: String
"Language ID for descriptions"
languageId: ID
"Company ID"
companyId: ID
}
"Defines the physical dimensions and weight specifications of an item for creation. This structure includes all relevant measurements for storage, shipping and product presentation and is used for shipping cost calculations and storage space optimizations."
type ItemMeasurements {
"Height of the item in the configured unit of measurement (usually centimeters or millimeters)."
height: Decimal!
"Length of the item in the configured unit of measurement (usually centimeters or millimeters)."
length: Decimal!
"Shipping weight of the item for shipping cost calculation in the configured weight unit (usually kilograms or grams). May differ from the actual item weight."
shippingWeight: Decimal!
"Actual weight of the item without packaging in the configured weight unit (usually kilograms or grams)."
weight: Decimal!
"Width of the item in the configured unit of measurement (usually centimeters or millimeters)."
width: Decimal!
}
"Defines a single price with tiering options and discount possibilities. This structure forms the basis for complex price structures with volume discounts and percentage price reductions from the standard price."
type ItemPrice {
"Minimum quantity from which this price applies - enables tier prices based on order quantity (e.g., from 10 pieces)."
fromQuantity: Int!
"Net price for this price tier without taxes - the actual selling price for the specified quantity tier."
netPrice: Decimal!
"Percentage discount on the standard price - indicates by what percentage the standard price is reduced for this price tier. Used as an alternative to NetPrice."
reduceStandardPriceByPercent: Decimal!
}
"Price details for an item."
type ItemPriceDetails {
"Unique ID to identify an item."
itemId: ID!
"The default net sales price of the item."
defaultSalesPriceNet: Decimal
"The latest net sales price of the item."
latestSalesPriceNet: Decimal
"The latest net sales price of the item for a specific customer."
customersLatestSalesPriceNet: Decimal
"The purchase price of the item."
purchasePriceNet: Decimal
"The latest purchase price of the item."
latestPurchasePriceNet: Decimal
}
"Defines the complete price structure of an item for creation. This structure includes all price information for different sales channels, customer groups and individual customer prices as well as basic price information."
type ItemPrices {
"Indicates whether discounts should be ignored for this item. When set to true, no automatic discounts will be applied to the item prices."
ignoreDiscounts: Boolean!
"Net sales price of the item without taxes and discounts - the basic selling price of the item."
salesPriceNet: Decimal!
"Manufacturer's suggested retail price (MSRP) - the selling price recommended by the manufacturer."
suggestedRetailPrice: Decimal!
"Net purchase price without taxes - the price at which the item was purchased."
purchasePriceNet: Decimal!
"eBay-specific selling price - special price for eBay sales."
ebayPrice: Decimal!
"Amazon-specific selling price - special price for Amazon sales."
amazonPrice: Decimal!
"List of sales channel-specific prices - enables different pricing for various sales channels or shops."
salesChannelPrices: [ItemSaleschannelPrices!]!
"List of customer-specific prices - allows individual price agreements for specific customers."
customerPrices: [ItemCustomerPrices!]!
"List of default prices for different customer groups - these prices serve as fallback when no more specific prices are defined."
defaultPrices: [ItemCustomerGroupPrices!]!
}
"Defines sales channel-specific special prices for an item. This structure enables different promotional pricing for a specific sales channel or shop with customer group-related special price structures."
type ItemSalesChannelSpecialPrices {
"Key of the sales channel that identifies the specific sales channel or shop for which this special price structure applies."
salesChannelId: ID!
"List of special prices for different customer groups within this sales channel - enables differentiated promotional pricing by customer groups."
specialPrices: [ItemCustomerGroupSpecialPrice!]!
}
"Defines sales channel-specific prices for an item. This structure enables different pricing for various sales channels or shops with customer group-related price structures."
type ItemSaleschannelPrices {
"Key of the sales channel that identifies the specific sales channel or shop for which this price structure applies."
saleschannelId: ID!
"List of prices for different customer groups within this sales channel - enables differentiated pricing by customer groups."
customerGroupPrices: [ItemCustomerGroupPrices!]!
"Indicates whether this sales channel is active for the item - determines whether the item can be sold in this sales channel."
isActive: Boolean!
}
"Defines the special prices (promotional prices) structure of an item. This structure includes time-based and stock-based special pricing for different sales channels and customer groups, as well as Amazon-specific special prices."
type ItemSpecialPrices {
"Indicates whether special prices are active for this item. When set to true, the special price rules defined below will be applied according to their conditions."
isActive: Boolean!
"Date from which the special price becomes active. The special price will only be valid from this date onwards."
startDate: DateTime
"Date until which the special price remains active. The special price will expire after this date. Only evaluated if IsEndDateActive is true."
endDate: DateTime
"Indicates whether the end date should be considered. If false, the special price has no expiration date."
isEndDateActive: Boolean!
"Minimum stock quantity that must be available for the special price to remain active. Only evaluated if IsStockRestrictionActive is true."
minimumStockQuantity: Int
"Indicates whether the stock restriction should be applied. When true, the special price is only active if the stock level is greater than or equal to MinimumStockQuantity. Can only be activated for items that use stock management."
isStockRestrictionActive: Boolean!
"List of sales channel-specific special prices - enables different promotional pricing for various sales channels or shops with customer group differentiation."
salesChannelSpecialPrices: [ItemSalesChannelSpecialPrices!]!
}
"Defines the storage and inventory management constraints of an item. This structure includes settings for negative stock handling, inventory management, serial numbers, batch tracking, and best-before date management."
type ItemStorageConstraints {
"Allows selling a higher quantity of the item than is actually in stock. This global setting must be activated first before platform-specific or sales channel-specific negative stock settings can be enabled."
allowNegativeStock: Boolean!
"List of platform-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific platforms (e.g., eBay, Amazon). AllowNegativeStock must be activated as well for these settings to take effect."
itemPlatformNegativeStocks: [NegativeStockPlatform!]!
"List of sales channel-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific sales channels or shops. AllowNegativeStock must be activated as well for these settings to take effect."
itemSalesChannelNegativeStocks: [NegativeStockSalesChannel!]!
"Item buffer quantity - defines a safety stock buffer that is reserved and not available for sale. This helps prevent overselling and ensures availability for important orders."
buffer: Int
"Global minimum stock level across all warehouses. When the total stock falls below this value, the item is flagged for reordering. Used for automatic order suggestions and low-stock warnings."
globalMinimumStockLevel: Decimal!
"Indicates whether the item uses batch management. When enabled, the item requires batch numbers to be assigned for each stock movement to enable tracking and traceability."
hasBatch: Boolean!
"Determines if the item is working with inventory management. When active, stock levels are tracked and managed; when inactive, the item is treated as always available regardless of stock levels."
isInventoryManagementActive: Boolean!
"Determines if the item is working with best-before date (MHD - Mindesthaltbarkeitsdatum) management. When enabled, stock items must have an assigned best-before date for tracking perishable goods."
isBestBeforeManaged: Boolean!
"Determines if the item can be sold in split quantities (fractional units). When enabled, stock can be managed in decimal quantities (e.g., 2.5 pieces) instead of only whole numbers."
isStockDivisible: Boolean!
"Determines the type of serial number processing. Defines whether serial numbers are inactive, active, or tracked for this item."
serialNumberType: SerialNumberType!
}
type ItemSupplier {
"Id of the supplier"
supplierId: ID!
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Stock level of the item at the supplier."
stockLevel: Decimal!
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal!
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean!
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"VAT rate of the item at the supplier."
vatRate: Decimal!
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean!
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean!
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal!
"Scale prices defined by the supplier for this item."
scalePrices: [SupplierPrice!]!
}
type ItemSupplierListItem {
"Id of the item supplier"
id: ID!
"Id of the item"
itemId: ID!
"Id of the supplier"
supplierId: ID!
"Name of the supplier"
supplierName: String
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Delivery period as text (max 255 characters)."
deliveryPeriod: String
"Currency used by the supplier"
supplierCurrency: String
"Indicates if the supplier supports dropshipping."
isDropshippingSupported: Boolean!
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean!
"Indicates if this supplier is the default supplier for the item."
isDefaultSupplier: Boolean!
"Indicates if this supplier is the default dropshipping supplier for the item."
isDefaultDropshippingSupplier: Boolean!
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Stock level of the item at the supplier."
stockLevel: Decimal!
"Average delivery time based on historical data."
averageDeliveryTime: Decimal!
"Date when the stock level was last updated."
stockLevelLastModified: DateTime
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean!
"The delivery time of the supplier."
supplierDeliveryTimeInDays: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean!
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal!
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal!
"VAT rate of the item at the supplier."
vatRate: Decimal!
"Scale prices defined by the supplier for this item."
scalePrices: [ItemSupplierPriceListItem!]!
}
type ItemSupplierPriceListItem {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal!
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal!
}
type ItemSuppliers {
"Sets the default supplier for the item."
defaultSupplier: ID
"Sets the default supplier for dropshipping for the item."
defaultDropshippingSupplier: ID
"Assigned suppliers for the item"
suppliers: [ItemSupplier!]!
}
"Single row of the item type information"
type ItemTypeListItem {
"Item id"
id: ID!
"Indicates whether the item is managed as a stock item."
isStockItem: Boolean!
"Indicates whether the item currently has a positive stock quantity."
hasStock: Boolean!
"Indicates whether the item requires serial number tracking."
isSerialNumberItem: Boolean!
"Indicates whether the item can be divided into partial quantities."
isDivisibleStock: Boolean!
"Indicates whether the item has an expiration or best-before date (MHD)."
stockHasExpirationDate: Boolean!
"Indicates whether the item is managed as a batch or lot item."
stockIsBatch: Boolean!
"Indicates whether the item is a bill of materials (BOM \/ Stückliste)."
isBillOfMaterials: Boolean!
"Indicates whether the item is used as a component within a bill of materials."
isBillOfMaterialsComponent: Boolean!
"Indicates whether the item is a parent of a variation combination."
isVariationCombinationParent: Boolean!
"Indicates whether the item is a child (variant) of a variation combination."
isVariationCombinationChild: Boolean!
"Indicates whether the item has variations defined."
hasVariations: Boolean!
"Indicates whether the item represents a voucher."
isVoucher: Boolean!
"Indicates whether the item is a packaging item."
isPackaging: Boolean!
"Indicates whether the item has a configuration attached."
hasConfigurationGroup: Boolean!
"Indicates whether the item is a configuration component."
isConfigurationComponent: Boolean!
}
"Defines the item unit pricing settings for creation and modification. This structure includes all relevant information about the sales unit, packaging unit, inner quantity and base price details for an item."
type ItemUnitPricing {
"Id of the sales unit in which the item is sold (e.g. piece or box)."
salesUnitId: ID
"Id of the packaging unit of the item."
packagingUnitId: ID
"The amount of content for one piece of the sales unit, relative to the inner quantity unit."
innerQuantity: Decimal!
"The measurement unit for the inner quantity (e.g. kg or liter)."
innerQuantityUnitId: ID
"Indicates whether the base price should be automatically calculated and displayed."
isBasePriceDeclared: Boolean!
"The measurement unit to which the base price refers (e.g. per liter or per 100 grams)."
basePriceReferenceUnitId: ID
"The reference amount used when calculating the base price (e.g. 1 for per liter, 100 for per 100 grams)."
basePriceReferenceAmount: Decimal!
}
type ItemVariations {
"Contains all Variations"
variations: [Variation!]!
}
"Complete item details including all sub-elements"
type ItemdetailsItem {
"Item id"
id: ID!
"The ID of the product group to which the item should be assigned. Product groups serve for categorical classification of items for reports and analyses."
productGroupId: ID
"The ID of the shipping class to which the item should be assigned."
shippingClassId: ID
"The ID of the manufacturer to which the item should be assigned."
manufacturerId: ID
"Various identifiers of the item for unique identification (SKU, GTIN, ISBN, etc.)"
identifiers: ItemIdentifiers!
"Categories to which the item is assigned"
categories: ItemCategories!
"List of item descriptions in different languages"
descriptions: ItemDescriptions!
"Price structures of the item for different sales channels, customer groups and individual customers. Includes sales prices, purchase prices and tier prices."
prices: ItemPrices!
"Images associated with the item"
images: ItemImages!
"Physical dimensions and weight specifications of the item for storage, shipping and product presentation. Important for shipping cost calculations and storage space optimization."
measurements: ItemMeasurements!
"Custom fields defined for the item to store additional information. Useful for special requirements or integrations."
customFields: ItemCustomFields!
"Suppliers associated with the item including supplier-specific information such as purchase prices, delivery times and order intervals."
suppliers: ItemSuppliers!
"Indicates whether the item can be included in exported price lists. From Tab 'Sonstiges'."
includeInPriceList: Boolean!
"Indicates whether order suggestions should be ignored for this item. If true, the item will not appear in automatic order suggestions. From Tab 'Sonstiges'."
ignoreOrderSuggestions: Boolean!
"Indicates whether the item is not eligible for discounts (Rabatte ignorieren \/ Nicht Rabattfähig). From Tab 'Sonstiges'."
ignoreDiscounts: Boolean!
"Country of origin (Herkunftsland) - ISO code or country name. Max length 64. From Tab 'Sonstiges'."
countryOfOrigin: String
"Additional notes (Anmerkung) for the item - unlimited length. From Tab 'Sonstiges'."
notes: String
"Variations of an item"
variations: ItemVariations!
"Features of an item"
features: ItemFeatures!
"Attributes of an item"
attributes: ItemAttributes!
"UnitPricing information of an item"
unitPricing: ItemUnitPricing!
"SpecialPrices information of an item"
specialPrices: ItemSpecialPrices!
"ItemStorageConstraints information of an item"
storageConstraints: ItemStorageConstraints!
}
"Represents a language item in the system"
type LanguageItem {
"The culture ISO code of the language"
cultureIso: String!
"The two-letter ISO code of the language"
languageIso2: String!
"The three-letter ISO code of the language"
languageIso3: String!
"The name of the language in the Accept-Language header"
name: String!
"Indicates if this language is the default language"
isDefault: Boolean!
}
"A lot size for a production item. It defines the quantity of a production item that is produced in one lot."
type LotSize {
"The ID of this lot size."
id: ID!
"The ID of the production item of this lot size."
productionItemId: ID!
"The quantity of the production item that is produced in one lot."
quantity: Int!
}
"Single Row of the manufacturer overview"
type ManufacturerListItem {
"Id of the manufacturer."
id: ID!
"Sortnumber of the manufacturer."
sortNumber: Int!
"Default manufacturer Name"
name: String!
}
"Single row of the external document overview list."
type MarketplaceExternalDocumentListItem {
"ID of the invoice."
invoiceId: ID
"ID of the credit note."
creditNoteId: ID
"ID of the sales order."
salesOrderId: ID
"Type of the external document."
documentType: MarketplaceExternalDocumentType!
"Origin of the external document."
origin: MarketplaceExternalDocumentOrigin!
"Name of the shop."
shopName: String
"Invoice date."
invoiceDate: DateTime
"External sales order number."
externalSalesOrderNumber: String
"Gross total amount."
grossTotal: Decimal!
"ID of the associated document file."
documentFileId: ID
"Document number."
documentNumber: String
"ID of the seller."
sellerId: ID!
"Currency code."
currency: String
}
"Single row of the notification detail overview list."
type MarketplaceNotificationDetailListItem {
"ID of the notification detail."
id: ID!
"ID of the notification."
notificationId: ID!
"Detail code of the notification."
code: String
"Detailed message of the notification."
message: String
}
"Single Row of the notification overview list."
type MarketplaceNotificationListItem {
"ID of the notification."
id: ID!
"Reference key associated with the notification."
referenceId: ID
"Event identifier that triggered this notification."
eventId: String!
"Creation timestamp."
creationDate: DateTime!
"Severity level of the notification."
severity: MarketplaceNotificationSeverity!
"Type of the notification."
notificationType: MarketplaceNotificationType!
"Optional reference string providing additional context."
reference: String
"Whether the notification has been read."
isRead: Boolean!
"ID of the shop."
shopId: ID!
"Optional order cancellation request identifier."
orderCancellationRequestId: String
"Optional short message summarizing the notification."
shortMessage: String
"Name of the marketplace channel."
channel: String!
"Optional display name of the shop."
shopName: String
"Optional title of the associated offer."
offerTitle: String
}
"Single row of the marketplace offer overview list."
type MarketplaceOfferListItem {
"ID of the offer."
offerId: ID!
"ID of the linked article."
itemId: ID!
"Stock keeping unit."
sku: String
"Product number of the article."
productNumber: String
"Title of the offer."
offerTitle: String
"Display name of the sales channel."
channelName: String
"ID of the channel."
channelId: ID!
"Internal channel identifier."
channel: String
"ID of the shop."
shopId: ID!
"ID of the seller."
shopScxId: ID!
"Current quantity."
quantity: Decimal!
"Expiration date of the offer."
expirationDate: DateTime
"ID of the channel category."
categoryId: ID!
"Channel-specific category identifier."
channelCategoryId: String
"Display name of the channel category."
channelCategoryName: String
"Net price of the offer."
netPrice: Decimal
"Percentage discount."
percent: Decimal
"ID of the price entry."
priceId: ID!
"ID of the customer group."
customerGroupId: ID!
"Net sale price from the article."
salePriceNet: Decimal
"ID of the tax class."
taxClassId: ID!
"ID of the company."
companyId: ID!
"Currency code of the channel."
currency: String
"Available stock quantity."
availableQuantity: Decimal
"Quantity reserved in orders."
quantityInOrders: Decimal
"Expected inbound quantity."
inboundQuantity: Decimal
"Global Trade Item Number."
gtin: String
"Product weight."
productWeight: Decimal
"Manufacturer Part Number."
mpn: String
"International Standard Book Number."
isbn: String
"Amazon Standard Identification Number."
asin: String
"Name of the manufacturer."
manufacturer: String
"Net purchase price."
purchasePriceNet: Decimal
"Timestamp since the offer is active."
activeSince: DateTime
"Processing time in days."
processingTime: Int
"Date when inbound stock becomes available."
inboundAvailableAt: DateTime
"Type of the offer."
offerType: MarketplaceOfferType!
"Combined lifecycle and action status of the offer."
offerStatus: MarketplaceOfferViewStatus!
"URL of the offer listing on the channel."
listingUrl: String
"Whether the offer is currently listed."
isListed: Boolean!
"ID of the sales channel article data."
salesChannelItemDataId: Int
"Minimum stock threshold."
minimumStock: Decimal
"Maximum stock threshold."
maximumStock: Decimal
"Timestamp of the last upload."
lastUpload: DateTime
"Number of days after which pending offers are deleted."
deletionIntervalPendingOffer: Int!
"Name of the shop."
shopName: String
"Whether the offer is external."
isExtern: Boolean!
"Timestamp when the quantity was last updated."
quantityUpdatedAt: DateTime
"Timestamp when the price was last updated. UTC."
priceUpdatedAt: DateTime
"Timestamp when the status was last received. UTC."
statusReceivedAt: DateTime
"Last uploaded price value."
lastUploadedPrice: Decimal
"Whether automatic stock updates are enabled for this seller."
stockUpdateEnabled: Boolean!
"Channel-specific offer identifier."
channelOfferId: String
}
"Single row of the order cancellation request upload overview list."
type MarketplaceOrderCancellationRequestUploadListItem {
"ID of the cancellation event."
id: ID!
"ID of the order."
orderId: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Sales order number."
salesOrderNumber: String!
"Display name of the sales channel."
salesChannelDisplayName: String!
"External sales order number."
externalSalesOrderNumber: String
"ID of the sales order."
salesOrderId: ID!
"Creation timestamp."
createdAt: DateTime!
"Remaining upload attempt count."
uploadCountRemaining: Int
"Status of the cancellation request upload."
status: MarketplaceOrderCancellationRequestUploadStatus!
"Upload attempt count."
uploadCount: Byte!
}
"Single Row of the order cancellation upload overview list."
type MarketplaceOrderCancellationUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Indicates whether cancellation upload is required for the order."
cancellationUploadRequired: Boolean!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Gross sales order amount."
salesOrderGrossAmount: Decimal!
"Creation timestamp."
createdAt: DateTime!
"ID of the sales order."
salesOrderId: ID!
"Number of cancellation upload attempts."
cancellationUploadCount: Int!
"Timestamp of the last failed cancellation upload in UTC."
cancellationUploadFailedAt: DateTime
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the cancellation upload."
status: MarketplaceOrderCancellationUploadStatus!
}
"Single Row of the payment upload overview list."
type MarketplacePaymentUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Indicates whether payment upload is required for the order."
paymentUploadRequired: Boolean!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Gross sales order amount."
salesOrderGrossAmount: Decimal!
"Gross paid amount of the sales order."
salesOrderPaymentGrossAmount: Decimal!
"Creation timestamp."
createdAt: DateTime!
"ID of the sales order."
salesOrderId: ID!
"Number of payment upload attempts."
paymentUploadCount: Int!
"Timestamp of the last failed payment upload in UTC."
paymentUploadFailedAt: DateTime
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the payment upload."
status: MarketplacePaymentUploadStatus!
}
"Single row of the return upload line item overview list."
type MarketplaceReturnUploadLineItemListItem {
"ID of the return line item."
id: ID!
"ID of the order."
orderId: ID!
"ID of the return."
returnId: ID!
"Quantity of the return line item."
quantity: Decimal!
"Indicates whether the line item is credited in the credit note."
creditNoteRequired: Boolean!
"SKU of the item."
sku: String
"Name of the return line item."
name: String
}
"Single Row of the return upload overview list."
type MarketplaceReturnUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Indicates whether return upload is required for the order."
returnUploadRequired: Boolean!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Return number."
returnNumber: String!
"Display name of the sales channel."
salesChannelDisplayName: String!
"Gross sales order amount."
salesOrderGrossAmount: Decimal!
"Creation timestamp."
createdAt: DateTime!
"ID of the sales order."
salesOrderId: ID!
"Number of return upload attempts."
returnUploadCount: Int!
"Timestamp of the last failed return upload in UTC."
returnUploadFailedAt: DateTime
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the return upload."
status: MarketplaceReturnUploadStatus!
"Gross amount of the linked credit note."
creditNoteGrossAmount: Decimal!
"ID of the return."
returnId: ID!
}
"Single row of the shipping information upload overview list."
type MarketplaceShippingInformationUploadListItem {
"ID of the shipping information upload entry."
id: ID!
"ID of the delivery note."
deliveryNoteId: ID!
"ID of the order."
orderId: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"ID of the sales order."
salesOrderId: ID!
"Name of the shop."
shopName: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Delivery note number."
deliveryNoteNumber: String
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Creation timestamp."
createdAt: DateTime!
"Timestamp of the last failed upload in UTC."
uploadFailedAt: DateTime
"Upload attempt count."
uploadCount: Byte!
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the shipping information upload."
status: MarketplaceShippingInformationUploadStatus!
}
"Mutation collection of the BillOfMaterialsComponents domain"
type Mutation {
"Deletes a bill of materials item from a bill of materials."
DeleteBillOfMaterialsItem(request: DeleteBillOfMaterialsItemCommandRequestInput!): Boolean! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Deletes a bill of materials operation from a bill of materials."
DeleteBillOfMaterialsOperation(request: DeleteBillOfMaterialsOperationCommandRequestInput!): Boolean! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Deletes a bill of materials."
DeleteBillOfMaterials(request: DeleteBillOfMaterialsCommandRequestInput!): Boolean! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new bill of materials for a production item, including its components."
CreateBillOfMaterials(request: CreateBillOfMaterialsCommandRequestInput!): CreateBillOfMaterialsCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new bill of materials item for a bill of materials operation."
CreateBillOfMaterialsItem(request: CreateBillOfMaterialsItemCommandRequestInput!): CreateBillOfMaterialsItemCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new bill of materials operation for a bill of materials, including its items."
CreateBillOfMaterialsOperation(request: CreateBillOfMaterialsOperationCommandRequestInput!): CreateBillOfMaterialsOperationCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new lot size for a production item."
CreateLotSize(request: CreateLotSizeCommandRequestInput!): CreateLotSizeCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new production item, including its bills of materials with their components."
CreateProductionItem(request: CreateProductionItemCommandRequestInput!): CreateProductionItemCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new production order."
CreateProductionOrder(request: CreateProductionOrderCommandRequestInput!): CreateProductionOrderCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Releases an existing production order."
ReleaseProductionOrder(request: ReleaseProductionOrderCommandRequestInput!): ReleaseProductionOrderCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new workbench resource type"
CreateWorkbenchResourceType(request: CreateWorkbenchResourceTypeCommandRequestInput!): CreateWorkbenchResourceTypeCommandResponse! @authorize(roles: [ "resources.write", "system.all" ]) @cost(weight: "10")
"Creates a new workbench resource"
CreateWorkbenchResource(request: CreateWorkbenchResourceCommandRequestInput!): CreateWorkbenchResourceCommandResponse! @authorize(roles: [ "resources.write", "system.all" ]) @cost(weight: "10")
"Creates a new Category."
CreateCategory(request: CreateCategoryCommandRequestInput!): CreateCategoryCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Delete a Category"
DeleteCategory(request: DeleteCategoryCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Updates a new Category"
UpdateCategory(request: UpdateCategoryCommandRequestInput!): UpdateCategoryCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
CopyItemdetails(request: CopyItemdetailsCommandRequestInput!): CopyItemdetailsCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates one or more duplicates of an existing item with specified duplication options."
DuplicateItems(request: DuplicateItemsCommandRequestInput!): DuplicateItemsCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals."
AddItemSupplier(request: AddItemSupplierCommandRequestInput!): AddItemSupplierCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options."
AddItemVariation(request: AddItemVariationCommandRequestInput!): AddItemVariationCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Adds a new value to an existing item variation."
AddItemVariationValue(request: AddItemVariationValueCommandRequestInput!): AddItemVariationValueCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information."
ChangeItem(request: ChangeItemCommandRequestInput!): ChangeItemCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements."
CreateItem(request: CreateItemCommandRequestInput!): CreateItemCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Removes an existing variation from an item. All associated variation values and combinations will also be removed."
DeleteItemVariation(request: DeleteItemVariationCommandRequestInput!): DeleteItemVariationCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Removes a specific value from an item variation."
DeleteItemVariationValue(request: DeleteItemVariationValueCommandRequestInput!): DeleteItemVariationValueCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Add new product groups."
AddProductGroups(request: AddProductGroupsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Delete existing product groups."
DeleteProductGroups(request: DeleteProductGroupsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Update the properties of product groups."
UpdateProductGroups(request: UpdateProductGroupsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Updates the active sales channels for a set of items"
UpdateItemSalesChannels(request: UpdateItemSalesChannelsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates a new shipping class"
CreateShippingClass(request: CreateShippingClassCommandRequestInput!): CreateShippingClassCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates a customer"
CreateCustomer(request: CreateCustomerCommandRequestInput!): CreateCustomerCommandResponse! @authorize(roles: [ "customers.write", "system.all" ]) @cost(weight: "10")
"Updates a customer"
UpdateCustomer(request: UpdateCustomerCommandRequestInput!): UpdateCustomerCommandResponse! @authorize(roles: [ "customers.write", "system.all" ]) @cost(weight: "10")
"Exclude marketplace invoice corrections from upload."
ExcludeMarketplaceInvoiceCorrectionFromUpload(request: ExcludeMarketplaceInvoiceCorrectionFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace invoice correction PDFs from upload."
ExcludeMarketplaceInvoiceCorrectionPdfFromUpload(request: ExcludeMarketplaceInvoiceCorrectionPdfFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace invoice PDFs from upload."
ExcludeMarketplaceInvoicePdfFromUpload(request: ExcludeMarketplaceInvoicePdfFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace invoice correction PDFs."
ResetMarketplaceInvoiceCorrectionPdfUploadCounter(request: ResetMarketplaceInvoiceCorrectionPdfUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace invoice corrections."
ResetMarketplaceInvoiceCorrectionUploadCounter(request: ResetMarketplaceInvoiceCorrectionUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Resets PDF generation for marketplace invoices\/invoice corrections so they can be reprinted and uploaded again."
ResetMarketplaceInvoicePdfPrinting(request: ResetMarketplaceInvoicePdfPrintingCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Deletes the specified marketplace offers."
DeleteMarketplaceOffer(request: DeleteMarketplaceOfferCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Removes the item assignment from the specified marketplace offers."
RemoveItemFromMarketplaceOffer(request: RemoveItemFromMarketplaceOfferCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Sets the maximum stock quantity for the specified marketplace offers."
SetMarketplaceOfferMaxQuantity(request: SetMarketplaceOfferMaxQuantityCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Sets the minimum stock quantity for the specified marketplace offers."
SetMarketplaceOfferMinQuantity(request: SetMarketplaceOfferMinQuantityCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Triggers stock synchronisation for the specified marketplace offers."
TriggerMarketplaceStockSynchronisation(request: TriggerMarketplaceStockSynchronisationCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Cancel marketplace order cancellation request uploads."
CancelMarketplaceOrderCancellationRequestUpload(request: CancelMarketplaceOrderCancellationRequestUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace order cancellation uploads from upload."
ExcludeMarketplaceOrderCancellationUploadFromUpload(request: ExcludeMarketplaceOrderCancellationUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace payment uploads from upload."
ExcludeMarketplacePaymentUploadFromUpload(request: ExcludeMarketplacePaymentUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace return uploads from upload."
ExcludeMarketplaceReturnUploadFromUpload(request: ExcludeMarketplaceReturnUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace shipping information uploads from upload."
ExcludeMarketplaceShippingInformationUploadFromUpload(request: ExcludeMarketplaceShippingInformationUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace order cancellation uploads."
ResetMarketplaceOrderCancellationUploadCounter(request: ResetMarketplaceOrderCancellationUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace payment uploads."
ResetMarketplacePaymentUploadCounter(request: ResetMarketplacePaymentUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace return uploads."
ResetMarketplaceReturnUploadCounter(request: ResetMarketplaceReturnUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace shipping information uploads."
ResetMarketplaceShippingInformationUploadCounter(request: ResetMarketplaceShippingInformationUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Activates a language in the system"
ActivateLanguage(request: ActivateLanguageCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "system.config.write" ]) @cost(weight: "10")
"Deactivates a language in the system"
DeactivateLanguage(request: DeactivateLanguageCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "system.config.write" ]) @cost(weight: "10")
"Creates a new tax class in the system"
CreateTaxClass(request: CreateTaxClassCommandRequestInput!): ID! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Creates a new tax code in the system"
CreateTaxCode(request: CreateTaxCodeCommandRequestInput!): ID! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Deletes an existing tax class"
DeleteTaxClass(request: DeleteTaxClassCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Deletes an existing tax code"
DeleteTaxCode(request: DeleteTaxCodeCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Updates an existing tax class"
UpdateTaxClass(request: UpdateTaxClassCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Updates an existing tax code"
UpdateTaxCode(request: UpdateTaxCodeCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Cancel a sales invoice correction"
CancelSalesInvoiceCorrection(request: CancelSalesInvoiceCorrectionCommandRequestInput!): Boolean! @authorize(roles: [ "salesinvoicecorrections.write", "system.all" ]) @cost(weight: "10")
"Create a new sales invoice correction from an existing invoice"
CreateSalesInvoiceCorrection(request: CreateSalesInvoiceCorrectionCommandRequestInput!): CreateSalesInvoiceCorrectionCommandResponse! @authorize(roles: [ "salesinvoicecorrections.write", "system.all" ]) @cost(weight: "10")
"Cancel a sales invoice"
CancelSalesInvoice(request: CancelSalesInvoiceCommandRequestInput!): Boolean! @authorize(roles: [ "salesinvoices.write", "system.all" ]) @cost(weight: "10")
"Create a new sales invoice for a salesorder"
CreateSalesInvoice(request: CreateSalesInvoiceCommandRequestInput!): CreateSalesInvoiceCommandResponse! @authorize(roles: [ "salesinvoices.write", "system.all" ]) @cost(weight: "10")
"Calculate prices, discounts, and taxes for a sales order without persisting it."
CalculateSalesOrder(request: CalculateSalesOrderCommandRequestInput!): CalculateSalesOrderCommandResponse! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Creates a new sales order."
CreateSalesOrder(request: CreateSalesOrderCommandRequestInput!): CreateSalesOrderCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing sales order."
UpdateSalesOrder(request: UpdateSalesOrderCommandRequestInput!): UpdateSalesOrderCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Cancel a sales quotation"
CancelSalesQuotation(request: CancelSalesQuotationCommandRequestInput!): Boolean! @authorize(roles: [ "salesquotations.write", "system.all" ]) @cost(weight: "10")
"Create a new sales order for a sales quotation"
CreateSalesOrderFromSalesQuotation(request: CreateSalesOrderFromSalesQuotationCommandRequestInput!): CreateSalesOrderFromSalesQuotationCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Creates a new sales quotation."
CreateSalesQuotation(request: CreateSalesQuotationCommandRequestInput!): CreateSalesQuotationCommandResponse! @authorize(roles: [ "salesquotations.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing Package Weight"
ChangePackageWeight(request: ChangePackageWeightCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Delivers an existing Package"
CreateDeliverPackage(request: CreateDeliverPackageCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Activates a bin location, making it available for operations."
ActivateBinLocation(request: ActivateBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Creates a new bin location in a warehouse."
CreateBinLocation(request: CreateBinLocationCommandRequestInput!): CreateBinLocationCommandResponse! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Deactivates a bin location, making it unavailable for operations."
DeactivateBinLocation(request: DeactivateBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Deletes a bin location from the warehouse."
DeleteBinLocation(request: DeleteBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Locks a bin location, preventing stock movements."
LockBinLocation(request: LockBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Locks a bin location for available stock, preventing it from being used for stock allocation."
LockBinLocationForAvailableStock(request: LockBinLocationForAvailableStockCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Unlocks a bin location for available stock, allowing it to be used for stock allocation."
UnlockBinLocationForAvailableStock(request: UnlockBinLocationForAvailableStockCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Updates metadata of an existing bin location (name, type, sort order)."
UpdateBinLocationMetadata(request: UpdateBinLocationMetadataCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Adds bin locations to a warehouse zone."
AddBinLocationsToZone(request: AddBinLocationsToZoneCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Creates a new warehouse zone."
CreateWarehouseZone(request: CreateWarehouseZoneCommandRequestInput!): CreateWarehouseZoneCommandResponse! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Deletes a warehouse zone."
DeleteWarehouseZone(request: DeleteWarehouseZoneCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Removes bin locations from a warehouse zone."
RemoveBinLocationsFromZone(request: RemoveBinLocationsFromZoneCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Updates mutable metadata (code, description, type) of an existing warehouse zone."
UpdateWarehouseZoneMetadata(request: UpdateWarehouseZoneMetadataCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Reassigns a shipping box to a different bin location (Rule SB-5)."
AssignShippingBoxToLocation(request: AssignShippingBoxToLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Creates a new shipping box within a warehouse."
CreateShippingBox(request: CreateShippingBoxCommandRequestInput!): CreateShippingBoxCommandResponse! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Permanently deletes a shipping box and all its attributes (Rule SB-8)."
DeleteShippingBox(request: DeleteShippingBoxCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Updates mutable metadata of an existing shipping box. TypeId is immutable (Rule SB-3)."
UpdateShippingBoxMetadata(request: UpdateShippingBoxMetadataCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
}
"Defines negative stock settings for a specific platform. This structure enables individual configuration of negative stock handling per platform (e.g., eBay, Amazon), allowing overselling for specific marketplaces when the global AllowNegativeStock is enabled."
type NegativeStockPlatform {
"Key of the platform that identifies the specific marketplace or platform (e.g., eBay, Amazon) for which this negative stock setting applies."
platformId: ID!
"Determines if negative stock is allowed for this platform. When true, orders can be accepted even when the item is out of stock on this specific marketplace."
isNegativeStockAllowed: Boolean!
}
"Defines negative stock settings for a specific sales channel. This structure enables individual configuration of negative stock handling per sales channel, allowing overselling for specific online shops when the global AllowNegativeStock is enabled."
type NegativeStockSalesChannel {
"Key of the sales channel that identifies the specific shop or sales channel for which this negative stock setting applies."
salesChannelId: ID!
"Determines if negative stock is allowed for this sales channel. When true, orders can be accepted even when the item is out of stock in this specific channel."
isNegativeStockAllowed: Boolean!
}
"Single Row of the order data query"
type OrderDataItem {
"The Package ID of the Order"
id: String!
"Total weight in kg (range 0-10000)"
totalWeight: Decimal
"Order ID"
orderId: ID!
"Customer ID"
customerId: ID!
"Company ID"
companyId: ID!
"Warehouse ID"
warehouseId: ID!
"Shipping address"
shippingAddress: ShippingAddress!
"Company address"
companyAddress: CompanyAddress!
"Warehouse address"
warehouseAddress: WarehouseAddress!
"List of delivery notes"
deliveryNotes: [DeliveryNoteItem!]!
"List of package content items"
content: [PackageContent!]!
}
"Represents a package content item"
type PackageContent {
"Item ID"
id: ID!
"Item number"
number: String!
"Content type (e.g. item, carton, openPosition)"
contentType: String!
"Amount of the item in the package"
amount: Decimal!
"Shipping Weight in kg (range: 0-10000)"
weight: Decimal
}
"Information about pagination in a connection."
type PageInfo {
"Indicates whether more edges exist following the set defined by the clients arguments."
hasNextPage: Int!
"Indicates whether more edges exist prior the set defined by the clients arguments."
hasPreviousPage: Int!
"When paginating backwards, the cursor to continue."
startCursor: String
"When paginating forwards, the cursor to continue."
endCursor: String
}
"Single row of the payment methods overview table"
type PaymentMethod {
"Unique identifier of the payment method"
id: ID!
"Name of the payment method"
name: String!
"G\/L account associated with the payment method"
generalLedgerAccount: String!
"Indicates whether the payment method is active"
isActive: Boolean!
"Indicates whether this is the default payment method"
isDefault: Boolean!
"Indicates whether the payment method is a debit type"
isDebit: Boolean!
"Indicates whether dunning is active for this payment method"
isDunningActive: Boolean!
"Indicates whether shipping is allowed before payment is received"
canShipBeforePayment: Boolean!
"Number of days for cash discount"
cashDiscountDays: Int!
"Value of the cash discount"
cashDiscountValue: Decimal!
"Payment option associated with the payment method"
paymentOption: String!
}
"A pick list with its positions"
type PickList {
"Pick list ID"
id: ID!
"Pick list number"
pickListNumber: String!
"Pick list status value"
status: Int!
"Id of the Warehouse"
warehouseId: ID!
"All positions sorted in pick order"
positions: [PickListPosition!]!
}
"A pick list position"
type PickListPosition {
"Position ID"
positionId: ID!
"Item ID"
itemId: ID!
"Item number (cArtNr)"
itemNumber: String!
"Target quantity"
quantity: Decimal!
"Bin location ID"
binLocationId: ID!
"Bin location name"
binLocationName: String!
"Position status value"
positionStatus: Int!
"Last status change timestamp"
processingTimestamp: DateTime
}
"Defines a platform-specific description of an item. This enables different descriptions for various output platforms like print or other non-sales platforms."
type PlatformDescription {
"Unique key of the platform for which this description is intended (e.g., print, labels)."
platformId: ID!
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the platform-specific description data with all relevant texts and SEO information."
descriptionData: DescriptionData!
}
type PlatformImages {
"Unique ID to identify a platform."
platformId: ID!
"List of images assigned to the platform."
images: [ItemImage!]!
}
"Single row of product group information."
type ProductGroupsListItem {
"Product group id"
id: ID!
"The name of the product group"
name: String
}
"A production item."
type ProductionItem {
"The ID of this production item."
id: ID!
"The ID of the item underlying this production item."
itemId: ID!
"Defines the type of lot size configuration for this production item."
lotType: LotType!
"Defines the type of manufacturing of this production item."
productionType: ProductionType!
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateKey: ID
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no item label for each produced unit should be printed on completion."
singleItemLabelTemplateKey: ID
"The timestamp when this production item was created."
createDate: DateTime!
"The timestamp when this production item was last modified."
updateDate: DateTime!
"The ID of the user who last modified this production item, or NULL if this production item has not been modified yet."
updateUserId: ID
}
"A production order."
type ProductionOrder {
"The ID of the production order."
id: ID!
"The ID of the production item to be produced by this production order."
productionItemId: ID!
"The ID of the bill of material used to produce the production item."
billOfMaterialId: ID!
"The ID of the disposition from which the production order originates."
dispositionId: ID
"Planned number of lots to be produced."
lotCount: Int!
"Planned size of the lots to be produced."
lotSize: Decimal!
"Planned total quantity to be produced."
targetTotalQuantity: Decimal!
"Actual total quantity produced."
actualQuantity: Decimal!
"Indicates whether it is allowed for this order to have a total quantity below the lot size (true) or not (false)."
isTargetTotalQuantityBelowLotSizeAllowed: Boolean!
"Progress of the production order."
progress: Decimal!
"Planned start time of the production order."
targetStartTimestamp: DateTime
"Planned completion time of the production order."
targetCompletionTimestamp: DateTime
"Actual (reported) start time of the production order."
actualStartTimestamp: DateTime
"Actual (reported) completion time of the production order."
actualCompletionTimestamp: DateTime
"The project number associated with the production order."
projectNumber: String!
"The reference number associated with the underlying order for this production order."
referenceNumber: String!
"The issue number of the production order."
issueNumber: String!
"The date when the production order was issued."
issueDate: DateTime!
"Additional note on the order that will be displayed during production."
notice: String!
"The timestamp when the production order was released."
releaseTimestamp: DateTime
"Planned delivery date."
deliveryTimestamp: DateTime
"The ID of the user who created the production order."
creationUserId: ID!
"The ID of the user who released the production order."
releaseUserId: ID
"The ID of the user who last modified the production order."
lastModificationUserId: ID!
"The timestamp of the last modification of the production order."
lastModificationTimestamp: DateTime!
"The ID type of the resource (workbench-types only) which is allowed to produce this production order."
resourceTypeId: ID
"The ID of the workbench resource onto which the production order was assigned."
workbenchResourceId: ID
}
type Query {
"Retrieves a bill of materials item by its ID."
QueryBillOfMaterialsItemById(id: ID!): BillOfMaterialsItem! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bill of materials items for a given bill of materials."
QueryBillOfMaterialsItemsByBillOfMaterialsId(billOfMaterialsId: ID!): [BillOfMaterialsItem!]! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bill of materials items for a given bill of materials operation."
QueryBillOfMaterialsItemsByBillOfMaterialsOperationId(billOfMaterialsOperationId: ID!): [BillOfMaterialsItem!]! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves a bill of materials operation by its ID."
QueryBillOfMaterialsOperationById(id: ID!): BillOfMaterialsOperation! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bill of materials operations for a given bill of materials."
QueryBillOfMaterialsOperationsByBillOfMaterialsId(billOfMaterialsId: ID!): [BillOfMaterialsOperation!]! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves a bill of materials by its ID."
QueryBillOfMaterialsById(id: ID!): BillOfMaterials! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bills of materials for a given production item."
QueryBillsOfMaterialsByProductionItemId(productionItemId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BillOfMaterialsFilterInput @cost(weight: "10") order: [BillOfMaterialsSortInput!] @cost(weight: "10")): QueryBillsOfMaterialsByProductionItemIdConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a lot size by its ID."
QueryLotSizeById(id: ID!): LotSize! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all lot sizes for a given production item."
QueryLotSizesByProductionItemId(productionItemId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: LotSizeFilterInput @cost(weight: "10") order: [LotSizeSortInput!] @cost(weight: "10")): QueryLotSizesByProductionItemIdConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves all production items."
QueryProductionItems("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ProductionItemFilterInput @cost(weight: "10") order: [ProductionItemSortInput!] @cost(weight: "10")): QueryProductionItemsConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a production item by its ID."
QueryProductionItemById(id: ID!): ProductionItem! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves a production item by the ID of the underlying item."
QueryProductionItemByItemId(itemId: ID!): ProductionItem! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all production orders."
QueryProductionOrders("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ProductionOrderFilterInput @cost(weight: "10") order: [ProductionOrderSortInput!] @cost(weight: "10")): QueryProductionOrdersConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a production order by its ID."
QueryProductionOrderById(id: ID!): ProductionOrder! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Queries all resource categories"
QueryResourceCategories("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ResourceCategoryFilterInput @cost(weight: "10") order: [ResourceCategorySortInput!] @cost(weight: "10")): QueryResourceCategoriesConnection @authorize(roles: [ "resources.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Queries all workbench resource types"
QueryWorkbenchResourceTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WorkbenchResourceTypeFilterInput @cost(weight: "10") order: [WorkbenchResourceTypeSortInput!] @cost(weight: "10")): QueryWorkbenchResourceTypesConnection @authorize(roles: [ "resources.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Queries a single workbench resource type by its ID"
QueryWorkbenchResourceTypeById(id: ID!): WorkbenchResourceType! @authorize(roles: [ "resources.read", "system.all" ]) @cost(weight: "10")
"Queries all workbench resources."
QueryWorkbenchResources("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WorkbenchResourceFilterInput @cost(weight: "10") order: [WorkbenchResourceSortInput!] @cost(weight: "10")): QueryWorkbenchResourcesConnection @authorize(roles: [ "resources.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a single workbench resource by its ID"
QueryWorkbenchResourceById(id: ID!): WorkbenchResource! @authorize(roles: [ "resources.read", "system.all" ]) @cost(weight: "10")
"Delivers a single category"
GetCategoryById(categoryId: ID!): CategoryDetails! @authorize(roles: [ "items.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable overview list all categories"
QueryCategories("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CategoryListItemFilterInput @cost(weight: "10") order: [CategoryListItemSortInput!] @cost(weight: "10")): QueryCategoriesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all company settings"
QueryCompanies("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CompanyListItemFilterInput @cost(weight: "10") order: [CompanyListItemSortInput!] @cost(weight: "10")): QueryCompaniesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a single company"
GetCompanyById(companyId: ID!): CompanyDetailsItem! @authorize(roles: [ "items.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable list of all custom fields metadata for a specific entity type"
QueryCustomFields("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomFieldListItemFilterInput @cost(weight: "10") order: [CustomFieldListItemSortInput!] @cost(weight: "10")): QueryCustomFieldsConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list all items with optional search"
QueryItems(searchTerm: String searchOperator: SearchOperator searchField: [ItemSearchField!] extendedFilter: String "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ItemListItemFilterInput @cost(weight: "10") order: [ItemListItemSortInput!] @cost(weight: "10")): QueryItemsConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves item suppliers for a specific item"
GetItemSuppliersById(id: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ItemSupplierListItemFilterInput @cost(weight: "10") order: [ItemSupplierListItemSortInput!] @cost(weight: "10")): GetItemSuppliersByIdConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list all items with optional search"
QueryItemTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ItemTypeListItemFilterInput @cost(weight: "10") order: [ItemTypeListItemSortInput!] @cost(weight: "10")): QueryItemTypesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a single article by its ID including all sub-elements"
GetItemById(id: ID!): ItemdetailsItem! @authorize(roles: [ "items.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable overview list all manufacturers"
QueryManufacturers("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ManufacturerListItemFilterInput @cost(weight: "10") order: [ManufacturerListItemSortInput!] @cost(weight: "10")): QueryManufacturersConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of all product groups"
QueryProductGroups("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ProductGroupsListItemFilterInput @cost(weight: "10") order: [ProductGroupsListItemSortInput!] @cost(weight: "10")): QueryProductGroupsConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of all shipping classes"
QueryShippingClasses("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingClassListItemFilterInput @cost(weight: "10") order: [ShippingClassListItemSortInput!] @cost(weight: "10")): QueryShippingClassesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a single customer by its id"
GetCustomerById(customerId: ID!): Customer! @authorize(roles: [ "customers.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable overview list of all customer categories"
QueryCustomerCategories("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomerCategoryFilterInput @cost(weight: "10") order: [CustomerCategorySortInput!] @cost(weight: "10")): QueryCustomerCategoriesConnection @authorize(roles: [ "customers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a querable overview list of all customer groups"
QueryCustomerGroups("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomerGroupFilterInput @cost(weight: "10") order: [CustomerGroupSortInput!] @cost(weight: "10")): QueryCustomerGroupsConnection @authorize(roles: [ "customers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all customers with optional search"
QueryCustomers(searchTerm: String searchOperator: CustomerSearchOperator searchField: [CustomerSearchField!] "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomerListItemFilterInput @cost(weight: "10") order: [CustomerListItemSortInput!] @cost(weight: "10")): QueryCustomersConnection @authorize(roles: [ "customers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of notification details for the given notification."
QueryMarketplaceNotificationDetail(notificationId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String order: [MarketplaceNotificationDetailListItemSortInput!] @cost(weight: "10")): QueryMarketplaceNotificationDetailConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceNotificationListItem"
QueryMarketplaceNotification("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceNotificationListItemFilterInput @cost(weight: "10") order: [MarketplaceNotificationListItemSortInput!] @cost(weight: "10")): QueryMarketplaceNotificationConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceOfferListItem"
QueryMarketplaceOffer("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceOfferListItemFilterInput @cost(weight: "10") order: [MarketplaceOfferListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOfferConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceExternalDocumentListItem"
QueryMarketplaceExternalDocument("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceExternalDocumentListItemFilterInput @cost(weight: "10") order: [MarketplaceExternalDocumentListItemSortInput!] @cost(weight: "10")): QueryMarketplaceExternalDocumentConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceOrderCancellationRequestUploadListItem"
QueryMarketplaceOrderCancellationRequestUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceOrderCancellationRequestUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceOrderCancellationRequestUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOrderCancellationRequestUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceOrderCancellationUploadListItem"
QueryMarketplaceOrderCancellationUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceOrderCancellationUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceOrderCancellationUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOrderCancellationUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplacePaymentUploadListItem"
QueryMarketplacePaymentUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplacePaymentUploadListItemFilterInput @cost(weight: "10") order: [MarketplacePaymentUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplacePaymentUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of return upload line items for the given order."
QueryMarketplaceReturnUploadLineItem(orderId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String order: [MarketplaceReturnUploadLineItemListItemSortInput!] @cost(weight: "10")): QueryMarketplaceReturnUploadLineItemConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceReturnUploadListItem"
QueryMarketplaceReturnUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceReturnUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceReturnUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceReturnUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceShippingInformationUploadListItem"
QueryMarketplaceShippingInformationUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceShippingInformationUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceShippingInformationUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceShippingInformationUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup shipping methods"
QueryShippingMethods("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingMethodLookupItemFilterInput @cost(weight: "10") order: [ShippingMethodLookupItemSortInput!] @cost(weight: "10")): QueryShippingMethodsConnection @authorize(roles: [ "system.all", "system.config.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Definition to query countries"
QueryCountries("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String): QueryCountriesConnection @authorize(roles: [ "system.all", "system.config.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Query for activated languages"
QueryLanguages("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String): QueryLanguagesConnection @authorize(roles: [ "system.all", "system.config.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Query for tax classes"
QueryTaxClasses("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: TaxClassFilterInput @cost(weight: "10") order: [TaxClassSortInput!] @cost(weight: "10")): QueryTaxClassesConnection @authorize(roles: [ "system.all", "taxes.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns a list of all tax classes and their calculated tax rates for the given parameters."
ListTaxClassesWithTaxRates(companyId: ID! departureCountryIso: String! taxReference: TaxDomainTaxReference shipmentAddressVatId: String shipmentAddressCountryIso: String shipmentAddressState: String billingAddressVatId: String billingAddressCountryIso: String billingAddressState: String specialTaxTreatment: TaxDomainSpecialTaxTreatment taxClasses: [ID]): [TaxClassWithTaxRate!]! @authorize(roles: [ "system.all", "taxes.read" ]) @cost(weight: "10")
"Query for tax codes"
QueryTaxCodes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: TaxCodeFilterInput @cost(weight: "10") order: [TaxCodeSortInput!] @cost(weight: "10")): QueryTaxCodesConnection @authorize(roles: [ "system.all", "taxes.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a querable overview list all currencies"
QueryCurrencies("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CurrencyFilterInput @cost(weight: "10") order: [CurrencySortInput!] @cost(weight: "10")): QueryCurrenciesConnection @authorize(roles: [ "currencies.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all external documents"
QueryExternalDocumentsInternal(fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ExternalDocumentInternalFilterInput @cost(weight: "10") order: [ExternalDocumentInternalSortInput!] @cost(weight: "10")): QueryExternalDocumentsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
QueryExternalDocumentLineItemsInternal(externalDocumentTransactionId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ExternalDocumentLineItemInternalFilterInput @cost(weight: "10") order: [ExternalDocumentLineItemInternalSortInput!] @cost(weight: "10")): QueryExternalDocumentLineItemsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice corrections"
QuerySalesInvoiceCorrectionsInternal(depositAttributeName: String! fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCorrectionInternalFilterInput @cost(weight: "10") order: [SalesInvoiceCorrectionInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceCorrectionsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice correction line items"
QuerySalesInvoiceCorrectionLineItemsInternal(salesInvoiceCorrectionId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCorrectionLineItemInternalFilterInput @cost(weight: "10") order: [SalesInvoiceCorrectionLineItemInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceCorrectionLineItemsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales invoices"
QuerySalesInvoicesInternal(depositAttributeName: String! fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceInternalFilterInput @cost(weight: "10") order: [SalesInvoiceInternalSortInput!] @cost(weight: "10")): QuerySalesInvoicesInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice positions"
QuerySalesInvoiceLineItemsInternal(salesInvoiceId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceLineItemInternalFilterInput @cost(weight: "10") order: [SalesInvoiceLineItemInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceLineItemsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice cancellations"
QuerySalesInvoiceCancellationsInternal(depositAttributeName: String! fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCancellationInternalFilterInput @cost(weight: "10") order: [SalesInvoiceCancellationInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceCancellationsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all payment methods"
QueryPaymentMethods("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: PaymentMethodFilterInput @cost(weight: "10") order: [PaymentMethodSortInput!] @cost(weight: "10")): QueryPaymentMethodsConnection @authorize(roles: [ "paymentmethods.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales channels."
QuerySalesChannels("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesChannelFilterInput @cost(weight: "10") order: [SalesChannelSortInput!] @cost(weight: "10")): QuerySalesChannelsConnection @authorize(roles: [ "saleschannels.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice corrections."
QuerySalesInvoiceCorrections("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCorrectionListItemFilterInput @cost(weight: "10") order: [SalesInvoiceCorrectionListItemSortInput!] @cost(weight: "10")): QuerySalesInvoiceCorrectionsConnection @authorize(roles: [ "salesinvoicecorrections.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales invoice cancellation reasons"
QuerySalesInvoiceCancellationReasons("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCancellationReasonFilterInput @cost(weight: "10") order: [SalesInvoiceCancellationReasonSortInput!] @cost(weight: "10")): QuerySalesInvoiceCancellationReasonsConnection @authorize(roles: [ "salesinvoices.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales invoices."
QuerySalesInvoices("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceListItemFilterInput @cost(weight: "10") order: [SalesInvoiceListItemSortInput!] @cost(weight: "10")): QuerySalesInvoicesConnection @authorize(roles: [ "salesinvoices.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns an empty sales order with default values without persisting it. This is equivalent to opening a new sales order dialog in the UI."
GetEmptySalesOrder: EmptySalesOrder! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Returns a list of price details for the requested items."
ListItemPriceDetails(itemIds: [ID]! customerId: ID! currencyFactor: Decimal!): [ItemPriceDetails!]! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Delivers a single sales order by its id"
GetSalesOrderById(id: ID!): SalesOrder! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Delivers a querable overview list all sales orders"
QuerySalesOrders("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesOrderListItemFilterInput @cost(weight: "10") order: [SalesOrderListItemSortInput!] @cost(weight: "10")): QuerySalesOrdersConnection @authorize(roles: [ "salesorders.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a single sales quotation by its id"
GetSalesQuotationById(id: ID!): SalesQuotation! @authorize(roles: [ "salesquotations.read", "system.all" ]) @cost(weight: "10")
"Delivers a querable overview list all sales quotations"
QuerySalesQuotations("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesQuotationListItemFilterInput @cost(weight: "10") order: [SalesQuotationListItemSortInput!] @cost(weight: "10")): QuerySalesQuotationsConnection @authorize(roles: [ "salesquotations.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all suppliers."
QuerySuppliers("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SupplierFilterInput @cost(weight: "10") order: [SupplierSortInput!] @cost(weight: "10")): QuerySuppliersConnection @authorize(roles: [ "suppliers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves pick lists with positions for a warehouse"
QueryPicklists("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: PickListFilterInput @cost(weight: "10") order: [PickListSortInput!] @cost(weight: "10")): QueryPicklistsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers order data for a specific package"
QueryOrderData(packageId: String!): OrderDataItem! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable to lookup batch"
QueryBatches("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BatchListItemFilterInput @cost(weight: "10") order: [BatchListItemSortInput!] @cost(weight: "10")): QueryBatchesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup best before dates (MHDs)"
QueryBestBeforeDates("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BestBeforeListItemFilterInput @cost(weight: "10") order: [BestBeforeListItemSortInput!] @cost(weight: "10")): QueryBestBeforeDatesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup stock reservations"
QueryStockReservations("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: StockReservationListItemFilterInput @cost(weight: "10") order: [StockReservationListItemSortInput!] @cost(weight: "10")): QueryStockReservationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup serial numbers"
QuerySerialNumbers("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SerialNumberListItemFilterInput @cost(weight: "10") order: [SerialNumberListItemSortInput!] @cost(weight: "10")): QuerySerialNumbersConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable for stock items"
QueryStockItem("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: QueryStockItemFilterInput @cost(weight: "10") order: [QueryStockItemSortInput!] @cost(weight: "10")): QueryStockItemConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns stock entries for a warehouse filtered by bin location\/article with optional batch, serial, and MHD filters."
QueryStock(warehouseId: ID! binLocationId: ID articleId: ID batchNumber: String serialNumber: String bestBeforeDateFrom: DateTime bestBeforeDateTo: DateTime "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: QueryStockFilterInput @cost(weight: "10") order: [QueryStockSortInput!] @cost(weight: "10")): QueryStockConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns all valid employee tracking activity types excluding inventory types."
QueryActivityTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ActivityTypeFilterInput @cost(weight: "10") order: [ActivityTypeSortInput!] @cost(weight: "10")): QueryActivityTypesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns pick activity per bin location, filterable by time period."
QueryBinLocationPickHeatmap(startDate: DateTime endDate: DateTime "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BinLocationPickHeatmapItemFilterInput @cost(weight: "10") order: [BinLocationPickHeatmapItemSortInput!] @cost(weight: "10")): QueryBinLocationPickHeatmapConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns employee tracking rows for a warehouse, optionally filtered by activity type IDs."
QueryEmployeeLocations(warehouseId: ID! activityTypeIds: [Int!]! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: EmployeeLocationItemFilterInput @cost(weight: "10") order: [EmployeeLocationItemSortInput!] @cost(weight: "10")): QueryEmployeeLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns tracking data for a specific employee in a warehouse."
QueryEmployeeLocation(warehouseId: ID! userId: Int! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String): QueryEmployeeLocationConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns shipping boxes for a given warehouse with paging, sorting, and filtering support."
QueryShippingBoxes(warehouseId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingBoxListItemFilterInput @cost(weight: "10") order: [ShippingBoxListItemSortInput!] @cost(weight: "10")): QueryShippingBoxesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns the list of available shipping box types."
QueryShippingBoxTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingBoxTypeFilterInput @cost(weight: "10") order: [ShippingBoxTypeSortInput!] @cost(weight: "10")): QueryShippingBoxTypesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns bin locations for a given warehouse with paging, sorting, and filtering support."
QueryBinLocations(warehouseId: ID! nameFilter: String statusFilter: Int typeFilter: Int "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BinLocationListItemFilterInput @cost(weight: "10") order: [BinLocationListItemSortInput!] @cost(weight: "10")): QueryBinLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns a single bin location by its ID."
GetBinLocationById(binLocationId: ID!): BinLocationListItem! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Returns occupancy fill factors for all bin locations in a warehouse."
QueryBinLocationOccupancy(warehouseId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BinLocationOccupancyItemFilterInput @cost(weight: "10") order: [BinLocationOccupancyItemSortInput!] @cost(weight: "10")): QueryBinLocationOccupancyConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns all available bin location statuses."
GetBinLocationStatuses: [BinLocationStatusDto!]! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Returns all available bin location types."
GetBinLocationTypes: [BinLocationTypeDto!]! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Returns stock movement history for a warehouse with optional time, article, and bin location filters."
QueryStockMovementHistory(warehouseId: ID! startTime: DateTime endTime: DateTime article: String sourceBinLocation: String targetBinLocation: String "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: StockMovementHistoryItemFilterInput @cost(weight: "10") order: [StockMovementHistoryItemSortInput!] @cost(weight: "10")): QueryStockMovementHistoryConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns warehouse zones for a given warehouse with paging, sorting, and filtering support."
QueryWarehouseZones(warehouseId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WarehouseZoneListItemFilterInput @cost(weight: "10") order: [WarehouseZoneListItemSortInput!] @cost(weight: "10")): QueryWarehouseZonesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns bin locations assigned to a specific warehouse zone."
QueryZoneBinLocations(zoneId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ZoneBinLocationItemFilterInput @cost(weight: "10") order: [ZoneBinLocationItemSortInput!] @cost(weight: "10")): QueryZoneBinLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns the static list of available warehouse zone types."
QueryZoneTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ZoneTypeFilterInput @cost(weight: "10") order: [ZoneTypeSortInput!] @cost(weight: "10")): QueryZoneTypesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup storage locations"
QueryStorageLocations("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: StorageLocationListItemFilterInput @cost(weight: "10") order: [StorageLocationListItemSortInput!] @cost(weight: "10")): QueryStorageLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup warehouses"
QueryWarehouses("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WarehouseListItemFilterInput @cost(weight: "10") order: [WarehouseListItemSortInput!] @cost(weight: "10")): QueryWarehousesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
}
"A connection to a list of items."
type QueryActivityTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryActivityTypesEdge!]
"A flattened list of the nodes."
nodes: [ActivityType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryActivityTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ActivityType!
}
"A connection to a list of items."
type QueryBatchesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBatchesEdge!]
"A flattened list of the nodes."
nodes: [BatchListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBatchesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BatchListItem!
}
"A connection to a list of items."
type QueryBestBeforeDatesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBestBeforeDatesEdge!]
"A flattened list of the nodes."
nodes: [BestBeforeListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBestBeforeDatesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BestBeforeListItem!
}
"A connection to a list of items."
type QueryBillsOfMaterialsByProductionItemIdConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBillsOfMaterialsByProductionItemIdEdge!]
"A flattened list of the nodes."
nodes: [BillOfMaterials!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBillsOfMaterialsByProductionItemIdEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BillOfMaterials!
}
"A connection to a list of items."
type QueryBinLocationOccupancyConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBinLocationOccupancyEdge!]
"A flattened list of the nodes."
nodes: [BinLocationOccupancyItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBinLocationOccupancyEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BinLocationOccupancyItem!
}
"A connection to a list of items."
type QueryBinLocationPickHeatmapConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBinLocationPickHeatmapEdge!]
"A flattened list of the nodes."
nodes: [BinLocationPickHeatmapItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBinLocationPickHeatmapEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BinLocationPickHeatmapItem!
}
"A connection to a list of items."
type QueryBinLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBinLocationsEdge!]
"A flattened list of the nodes."
nodes: [BinLocationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBinLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BinLocationListItem!
}
"A connection to a list of items."
type QueryCategoriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCategoriesEdge!]
"A flattened list of the nodes."
nodes: [CategoryListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCategoriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CategoryListItem!
}
"A connection to a list of items."
type QueryCompaniesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCompaniesEdge!]
"A flattened list of the nodes."
nodes: [CompanyListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCompaniesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CompanyListItem!
}
"A connection to a list of items."
type QueryCountriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCountriesEdge!]
"A flattened list of the nodes."
nodes: [CountryItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCountriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CountryItem!
}
"A connection to a list of items."
type QueryCurrenciesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCurrenciesEdge!]
"A flattened list of the nodes."
nodes: [Currency!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCurrenciesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: Currency!
}
"A connection to a list of items."
type QueryCustomFieldsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomFieldsEdge!]
"A flattened list of the nodes."
nodes: [CustomFieldListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomFieldsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomFieldListItem!
}
"A connection to a list of items."
type QueryCustomerCategoriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomerCategoriesEdge!]
"A flattened list of the nodes."
nodes: [CustomerCategory!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomerCategoriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomerCategory!
}
"A connection to a list of items."
type QueryCustomerGroupsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomerGroupsEdge!]
"A flattened list of the nodes."
nodes: [CustomerGroup!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomerGroupsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomerGroup!
}
"A connection to a list of items."
type QueryCustomersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomersEdge!]
"A flattened list of the nodes."
nodes: [CustomerListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomerListItem!
}
"A connection to a list of items."
type QueryEmployeeLocationConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryEmployeeLocationEdge!]
"A flattened list of the nodes."
nodes: [EmployeeLocationItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryEmployeeLocationEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: EmployeeLocationItem!
}
"A connection to a list of items."
type QueryEmployeeLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryEmployeeLocationsEdge!]
"A flattened list of the nodes."
nodes: [EmployeeLocationItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryEmployeeLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: EmployeeLocationItem!
}
"A connection to a list of items."
type QueryExternalDocumentLineItemsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryExternalDocumentLineItemsInternalEdge!]
"A flattened list of the nodes."
nodes: [ExternalDocumentLineItemInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryExternalDocumentLineItemsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ExternalDocumentLineItemInternal!
}
"A connection to a list of items."
type QueryExternalDocumentsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryExternalDocumentsInternalEdge!]
"A flattened list of the nodes."
nodes: [ExternalDocumentInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryExternalDocumentsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ExternalDocumentInternal!
}
"A connection to a list of items."
type QueryItemTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryItemTypesEdge!]
"A flattened list of the nodes."
nodes: [ItemTypeListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryItemTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ItemTypeListItem!
}
"A connection to a list of items."
type QueryItemsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryItemsEdge!]
"A flattened list of the nodes."
nodes: [ItemListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryItemsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ItemListItem!
}
"A connection to a list of items."
type QueryLanguagesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryLanguagesEdge!]
"A flattened list of the nodes."
nodes: [LanguageItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryLanguagesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: LanguageItem!
}
"A connection to a list of items."
type QueryLotSizesByProductionItemIdConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryLotSizesByProductionItemIdEdge!]
"A flattened list of the nodes."
nodes: [LotSize!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryLotSizesByProductionItemIdEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: LotSize!
}
"A connection to a list of items."
type QueryManufacturersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryManufacturersEdge!]
"A flattened list of the nodes."
nodes: [ManufacturerListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryManufacturersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ManufacturerListItem!
}
"A connection to a list of items."
type QueryMarketplaceExternalDocumentConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceExternalDocumentEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceExternalDocumentListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceExternalDocumentEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceExternalDocumentListItem!
}
"A connection to a list of items."
type QueryMarketplaceNotificationConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceNotificationEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceNotificationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"A connection to a list of items."
type QueryMarketplaceNotificationDetailConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceNotificationDetailEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceNotificationDetailListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceNotificationDetailEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceNotificationDetailListItem!
}
"An edge in a connection."
type QueryMarketplaceNotificationEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceNotificationListItem!
}
"A connection to a list of items."
type QueryMarketplaceOfferConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOfferEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOfferListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOfferEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOfferListItem!
}
"A connection to a list of items."
type QueryMarketplaceOrderCancellationRequestUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOrderCancellationRequestUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOrderCancellationRequestUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOrderCancellationRequestUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOrderCancellationRequestUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceOrderCancellationUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOrderCancellationUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOrderCancellationUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOrderCancellationUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOrderCancellationUploadListItem!
}
"A connection to a list of items."
type QueryMarketplacePaymentUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplacePaymentUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplacePaymentUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplacePaymentUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplacePaymentUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceReturnUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceReturnUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceReturnUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceReturnUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceReturnUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceReturnUploadLineItemConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceReturnUploadLineItemEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceReturnUploadLineItemListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceReturnUploadLineItemEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceReturnUploadLineItemListItem!
}
"A connection to a list of items."
type QueryMarketplaceShippingInformationUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceShippingInformationUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceShippingInformationUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceShippingInformationUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceShippingInformationUploadListItem!
}
"A connection to a list of items."
type QueryPaymentMethodsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryPaymentMethodsEdge!]
"A flattened list of the nodes."
nodes: [PaymentMethod!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryPaymentMethodsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: PaymentMethod!
}
"A connection to a list of items."
type QueryPicklistsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryPicklistsEdge!]
"A flattened list of the nodes."
nodes: [PickList!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryPicklistsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: PickList!
}
"A connection to a list of items."
type QueryProductGroupsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryProductGroupsEdge!]
"A flattened list of the nodes."
nodes: [ProductGroupsListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryProductGroupsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ProductGroupsListItem!
}
"A connection to a list of items."
type QueryProductionItemsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryProductionItemsEdge!]
"A flattened list of the nodes."
nodes: [ProductionItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryProductionItemsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ProductionItem!
}
"A connection to a list of items."
type QueryProductionOrdersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryProductionOrdersEdge!]
"A flattened list of the nodes."
nodes: [ProductionOrder!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryProductionOrdersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ProductionOrder!
}
"A connection to a list of items."
type QueryResourceCategoriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryResourceCategoriesEdge!]
"A flattened list of the nodes."
nodes: [ResourceCategory!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryResourceCategoriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ResourceCategory!
}
"A connection to a list of items."
type QuerySalesChannelsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesChannelsEdge!]
"A flattened list of the nodes."
nodes: [SalesChannel!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesChannelsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesChannel!
}
"A connection to a list of items."
type QuerySalesInvoiceCancellationReasonsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCancellationReasonsEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCancellationReason!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCancellationReasonsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCancellationReason!
}
"A connection to a list of items."
type QuerySalesInvoiceCancellationsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCancellationsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCancellationInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCancellationsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCancellationInternal!
}
"A connection to a list of items."
type QuerySalesInvoiceCorrectionLineItemsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCorrectionLineItemsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCorrectionLineItemInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCorrectionLineItemsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCorrectionLineItemInternal!
}
"A connection to a list of items."
type QuerySalesInvoiceCorrectionsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCorrectionsEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCorrectionListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCorrectionsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCorrectionListItem!
}
"A connection to a list of items."
type QuerySalesInvoiceCorrectionsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCorrectionsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCorrectionInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCorrectionsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCorrectionInternal!
}
"A connection to a list of items."
type QuerySalesInvoiceLineItemsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceLineItemsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceLineItemInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceLineItemsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceLineItemInternal!
}
"A connection to a list of items."
type QuerySalesInvoicesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoicesEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoicesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceListItem!
}
"A connection to a list of items."
type QuerySalesInvoicesInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoicesInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoicesInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceInternal!
}
"A connection to a list of items."
type QuerySalesOrdersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesOrdersEdge!]
"A flattened list of the nodes."
nodes: [SalesOrderListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesOrdersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesOrderListItem!
}
"A connection to a list of items."
type QuerySalesQuotationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesQuotationsEdge!]
"A flattened list of the nodes."
nodes: [SalesQuotationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesQuotationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesQuotationListItem!
}
"A connection to a list of items."
type QuerySerialNumbersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySerialNumbersEdge!]
"A flattened list of the nodes."
nodes: [SerialNumberListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySerialNumbersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SerialNumberListItem!
}
"A connection to a list of items."
type QueryShippingBoxTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingBoxTypesEdge!]
"A flattened list of the nodes."
nodes: [ShippingBoxType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingBoxTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingBoxType!
}
"A connection to a list of items."
type QueryShippingBoxesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingBoxesEdge!]
"A flattened list of the nodes."
nodes: [ShippingBoxListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingBoxesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingBoxListItem!
}
"A connection to a list of items."
type QueryShippingClassesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingClassesEdge!]
"A flattened list of the nodes."
nodes: [ShippingClassListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingClassesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingClassListItem!
}
"A connection to a list of items."
type QueryShippingMethodsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingMethodsEdge!]
"A flattened list of the nodes."
nodes: [ShippingMethodLookupItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingMethodsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingMethodLookupItem!
}
"Provides paged access to stock entries filtered by warehouse, bin location, or article."
type QueryStock {
"Unique identifier of the stock entry."
stockEntryId: ID!
"Warehouse that owns the stock entry."
warehouseId: ID!
"Bin location containing the stock entry."
binLocationId: ID!
"Article stored in the stock entry."
articleId: ID!
"Available quantity (fAnzahlAktuell)."
availableQuantity: Decimal!
"Quantity reserved for pick positions (fAnzahlReserviertPickpos)."
reservedQuantity: Decimal!
"Batch\/charge number, empty when not tracked."
batchNumber: String!
"Best-before date (MHD) if tracked."
bestBeforeDate: DateTime
"Serial number associated with the stock entry."
serialNumber: String!
}
"A connection to a list of items."
type QueryStockConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockEdge!]
"A flattened list of the nodes."
nodes: [QueryStock!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: QueryStock!
}
"Single Row of the serial number query"
type QueryStockItem {
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ID!
"Id of the item."
itemId: ID!
"Total quantity of this item at this storage location."
quantityTotal: Decimal!
"Comment1"
comment1: String!
"Comment2"
comment2: String!
}
"A connection to a list of items."
type QueryStockItemConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockItemEdge!]
"A flattened list of the nodes."
nodes: [QueryStockItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockItemEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: QueryStockItem!
}
"A connection to a list of items."
type QueryStockMovementHistoryConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockMovementHistoryEdge!]
"A flattened list of the nodes."
nodes: [StockMovementHistoryItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockMovementHistoryEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: StockMovementHistoryItem!
}
"A connection to a list of items."
type QueryStockReservationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockReservationsEdge!]
"A flattened list of the nodes."
nodes: [StockReservationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockReservationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: StockReservationListItem!
}
"A connection to a list of items."
type QueryStorageLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStorageLocationsEdge!]
"A flattened list of the nodes."
nodes: [StorageLocationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStorageLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: StorageLocationListItem!
}
"A connection to a list of items."
type QuerySuppliersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySuppliersEdge!]
"A flattened list of the nodes."
nodes: [Supplier!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySuppliersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: Supplier!
}
"A connection to a list of items."
type QueryTaxClassesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryTaxClassesEdge!]
"A flattened list of the nodes."
nodes: [TaxClass!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryTaxClassesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: TaxClass!
}
"A connection to a list of items."
type QueryTaxCodesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryTaxCodesEdge!]
"A flattened list of the nodes."
nodes: [TaxCode!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryTaxCodesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: TaxCode!
}
"A connection to a list of items."
type QueryWarehouseZonesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWarehouseZonesEdge!]
"A flattened list of the nodes."
nodes: [WarehouseZoneListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWarehouseZonesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WarehouseZoneListItem!
}
"A connection to a list of items."
type QueryWarehousesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWarehousesEdge!]
"A flattened list of the nodes."
nodes: [WarehouseListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWarehousesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WarehouseListItem!
}
"A connection to a list of items."
type QueryWorkbenchResourceTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWorkbenchResourceTypesEdge!]
"A flattened list of the nodes."
nodes: [WorkbenchResourceType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWorkbenchResourceTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WorkbenchResourceType!
}
"A connection to a list of items."
type QueryWorkbenchResourcesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWorkbenchResourcesEdge!]
"A flattened list of the nodes."
nodes: [WorkbenchResource!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWorkbenchResourcesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WorkbenchResource!
}
"A connection to a list of items."
type QueryZoneBinLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryZoneBinLocationsEdge!]
"A flattened list of the nodes."
nodes: [ZoneBinLocationItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryZoneBinLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ZoneBinLocationItem!
}
"A connection to a list of items."
type QueryZoneTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryZoneTypesEdge!]
"A flattened list of the nodes."
nodes: [ZoneType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryZoneTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ZoneType!
}
"Releases an existing production order. - Response"
type ReleaseProductionOrderCommandResponse {
"The result of the command, including the exact timestamp and the user who released the production order."
result: ReleaseProductionOrderCommandResult!
}
"Represents the result of releasing a production order."
type ReleaseProductionOrderCommandResult {
"The exact timestamp when the production order was released."
releaseTimestamp: DateTime!
"The ID of the user who released the production order."
releaseUserId: ID
}
"Represents a resource category"
type ResourceCategory {
"This resource category's unqiue ID."
id: ID!
"The resource category's name."
name: String!
"Specifies whether this resource category is visible to users."
isVisible: Boolean!
"Specifies whether this resource category is enabled for use."
isEnabled: Boolean!
}
"Single row of the sales channels overview table"
type SalesChannel {
"Unique identifier of the sales channel"
id: ID!
"Name of the sales channel"
name: String!
}
"Defines a sales channel-specific description of an item. This enables individual customization of item descriptions for specific sales channels or shops."
type SalesChannelDescription {
"Unique key of the sales channel or shop for which this description is intended."
salesChannelId: ID!
"ISO2 language code that determines the language for this sales channel-specific description."
languageIso: String!
"Contains the sales channel-specific description data with all relevant texts and SEO information."
descriptionData: DescriptionData!
}
type SalesChannelSurcharge {
"Id of the saleschannel"
salesChannelId: ID!
"Contains the surcharges for that saleschannel and customergroup"
surcharges: [CustomerGroupSurcharge!]!
}
"Invoice cancellation for M&A system"
type SalesInvoiceCancellationInternal {
"Sales order identifier"
salesOrderId: ID
"Sales invoice identifier"
salesInvoiceId: ID!
"Company identifier"
companyId: ID
"Customer identifier"
customerId: ID!
"Platform identifier"
platformId: ID
"Sales invoice number"
salesInvoiceNumber: String
"Sales invoice cancellation date"
salesInvoiceCancellationDate: DateTime
"External order number"
externalOrderNumber: String
"Sales order number"
salesOrderNumber: String
"Date when the order was created in the ERP system"
createdInErpDate: DateTime
"Tax setting"
taxSetting: Int!
"Currency ISO code"
currencyIso: String
"Currency conversion factor"
currencyFactor: Decimal!
"Departure country currency ISO code"
departureCountryCurrencyIso: String
"Departure country currency conversion factor"
departureCountryCurrencyFactor: Decimal!
"Service date"
serviceDate: DateTime
"Last shipping date"
lastShippingDate: DateTime
"Platform identifier"
platformName: String
"Shipment method identifier"
shippingMethodId: ID
"Value date"
valueDate: DateTime
"Customer VAT identifier"
customerVatIdNumber: String
"Sales invoice VAT identifier"
salesInvoiceVatIdNumber: String
"Departure country ISO code"
departureCountryIso: String
"Total gross amount"
totalGrossAmount: Decimal
"Total net amount"
totalNetAmount: Decimal
"Customer number"
salesInvoiceCustomerNumber: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Payment due date in days"
paymentDueDateInDays: Int!
"Payment status"
paymentStatus: Int
"Invoice payment method identifier"
invoicePaymentMethodId: ID
"Payment method identifier"
paymentMethodId: ID
"Payment method"
paymentMethodName: String
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: String
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: Decimal
"Shipment company name"
shipmentAddressCompany: String
"Shipment salutation"
shipmentAddressSalutation: String
"Shipment title"
shipmentAddressTitle: String
"Shipment first name"
shipmentAddressFirstName: String
"Shipment last name"
shipmentAddressLastName: String
"Shipment street address"
shipmentAddressStreet: String
"Shipment postal code"
shipmentAddressPostalCode: String
"Shipment city"
shipmentAddressCity: String
"Shipment country"
shipmentAddressCountry: String
"Shipment phone number"
shipmentAddressPhoneNumber: String
"Shipment fax number"
shipmentAddressFaxNumber: String
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment country ISO code"
shipmentAddressCountryIso: String
"Shipment VAT identifier"
shipmentAddressVatIdNumber: String
"Sales invoice company name"
billingAddressCompany: String
"Sales invoice salutation"
billingAddressSalutation: String
"Sales invoice title"
billingAddressTitle: String
"Sales invoice first name"
billingAddressFirstName: String
"Sales invoice last name"
billingAddressLastName: String
"Sales invoice street address"
billingAddressStreet: String
"Sales invoice postal code"
billingAddressPostalCode: String
"Sales invoice city"
billingAddressCity: String
"Sales invoice country"
billingAddressCountry: String
"Sales invoice phone number"
billingAddressPhoneNumber: String
"Sales invoice fax number"
billingAddressFaxNumber: String
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: String
"Sales invoice country ISO code"
billingAddressCountryIso: String
"Customer company name"
customerDefaultBillingAddressCompany: String
"Customer salutation"
customerDefaultBillingAddressSalutation: String
"Customer title"
customerDefaultBillingAddressTitle: String
"Customer first name"
customerDefaultBillingAddressFirstName: String
"Customer last name"
customerDefaultBillingAddressLastName: String
"Customer street address"
customerDefaultBillingAddressStreet: String
"Customer postal code"
customerDefaultBillingAddressPostalCode: String
"Customer city"
customerDefaultBillingAddressCity: String
"Customer country"
customerDefaultBillingAddressCountry: String
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: String
"Customer fax number"
customerDefaultBillingAddressFaxNumber: String
"Customer address country ISO code"
customerDefaultBillingAddressCountryIso: String
"Customer email address"
customerDefaultBillingAddressEmailAddress: String
"Customer address VAT identifier"
customerDefaultBillingAddressVatIdNumber: String
"Customer number"
customerNumber: String
"Customer group identifier"
customerGroupId: ID
"Customer payment due date in days"
customerPaymentDueDateInDays: Int
"Deposit information"
deposit: String
"Delivery note count for drop shipping"
dropShippingDeliveryNoteCount: Int!
}
"Single sales invoice cancellation reason"
type SalesInvoiceCancellationReason {
"Unique identifier of the sales invoice cancellation reason"
id: ID!
"Name of the cancellation reason"
name: String!
"Indicates whether a comment is required when using this cancellation reason"
isCommentRequired: Boolean!
}
"Credit note for M&A system"
type SalesInvoiceCorrectionInternal {
"Sales order identifier"
salesOrderId: ID
"Sales invoice correction identifier"
salesInvoiceCorrectionId: ID!
"Customer identifier"
customerId: ID!
"Company identifier"
companyId: ID!
"Sales invoice identifier"
salesInvoiceId: ID
"Platform identifier"
platformId: ID
"Cancelled sales invoice identifier"
cancelledSalesInvoiceId: ID
"Sales invoice payment method identifier"
salesInvoicePaymentMethodId: ID
"Sales invoice correction payment method identifier"
salesInvoiceCorrectionPaymentMethodId: ID
"Sales invoice correction number"
salesInvoiceCorrectionNumber: String
"Sales invoice correction date"
salesInvoiceCorrectionDate: DateTime!
"Sales invoice number"
salesInvoiceNumber: String
"Sales invoice date"
salesInvoiceDate: DateTime
"External order number"
externalOrderNumber: String
"Sales order number"
salesOrderNumber: String
"Date when the order was created in the ERP system"
createdInErpDate: DateTime
"Currency ISO code"
currencyIso: String
"Currency conversion factor"
currencyFactor: Decimal!
"Departure country currency ISO code"
departureCountryCurrencyIso: String
"Departure country currency conversion factor"
departureCountryCurrencyFactor: Decimal
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: String
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: Decimal
"Shipment type"
salesOrderShippingMethodId: ID
"Shipment type"
salesInvoiceShippingMethodId: ID
"Service date"
serviceDate: DateTime
"Delivery date"
deliveryDate: DateTime
"Total gross amount"
totalGrossAmount: Decimal!
"Sales order total gross amount"
salesOrderTotalGrossAmount: Decimal
"Sales order total net amount"
salesOrderTotalNetAmount: Decimal
"Platform identifier"
platformIdentifier: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Shipment company name"
shipmentCompany: String
"Shipment salutation"
shipmentSalutation: String
"Shipment title"
shipmentTitle: String
"Shipment first name"
shipmentFirstName: String
"Shipment last name"
shipmentLastName: String
"Shipment street address"
shipmentStreet: String
"Shipment postal code"
shipmentPostalCode: String
"Shipment city"
shipmentCity: String
"Shipment country"
shipmentCountry: String
"Shipment phone number"
shipmentPhoneNumber: String
"Shipment fax number"
shipmentFaxNumber: String
"Shipment additional address line"
shipmentAdditionalAddressLine: String
"Shipment country ISO code"
shipmentCountryIso: String
"Shipment VAT identifier"
shipmentVatIdNumber: String
"Sales order customer VAT identifier"
salesOrderCustomerVatIdNumber: String
"Sales invoice company name"
salesInvoiceCompany: String
"Sales invoice salutation"
salesInvoiceSalutation: String
"Sales invoice title"
salesInvoiceTitle: String
"Sales invoice first name"
salesInvoiceFirstName: String
"Sales invoice last name"
salesInvoiceLastName: String
"Sales invoice street address"
salesInvoiceStreet: String
"Sales invoice postal code"
salesInvoicePostalCode: String
"Sales invoice city"
salesInvoiceCity: String
"Sales invoice country"
salesInvoiceCountry: String
"Sales invoice phone number"
salesInvoicePhoneNumber: String
"Sales invoice fax number"
salesInvoiceFaxNumber: String
"Sales invoice additional address line"
salesInvoiceAdditionalAddressLine: String
"Sales invoice country ISO code"
salesInvoiceIso: String
"Customer company name"
customerCompany: String
"Customer salutation"
customerSalutation: String
"Customer title"
customerTitle: String
"Customer first name"
customerFirstName: String
"Customer last name"
customerLastName: String
"Customer street address"
customerStreet: String
"Customer postal code"
customerPostalCode: String
"Customer city"
customerCity: String
"Customer country"
customerCountry: String
"Customer phone number"
customerPhoneNumber: String
"Customer fax number"
customerFaxNumber: String
"Customer address country ISO code"
customerAddressIso: String
"Customer email address"
customerAddressEmailAddress: String
"Customer address VAT identifier"
customerAddressVatIdNumber: String
"Customer number"
customerNumber: String
"Customer group identifier"
customerGroupId: ID
"Customer payment due date in days"
customerPaymentDueDateInDays: Int
"Last shipping date"
lastShippingDate: DateTime
"Tax setting"
taxSetting: Int
"VAT identifier"
salesOrderVatIdNumber: String
"Departure country ISO code"
departureCountryIso: String
"Payment method"
paymentMethod: String
"Customer VAT identifier"
customerVatIdNumber: String
"VAT identifier"
salesInvoiceVatIdNumber: String
"Customer number"
salesInvoiceCustomerNumber: String
"Payment method name"
paymentMethodName: String
"Payment method"
paymentMethodId: ID
"Indicates if this is a storno (cancellation)"
isCancelled: String
"Deposit information"
deposit: String
"Sales invoice identifier"
salesInvoiceId2: ID
"Delivery note count"
dropShippingDeliveryNoteCount: Int!
}
"Invoice correction line item for M&A system"
type SalesInvoiceCorrectionLineItemInternal {
"Sales invoice correction line item identifier"
salesInvoiceCorrectionLineItemId: ID!
"Sales order line item identifier"
salesOrderLineItemId: ID
"Sales price gross"
salesPriceGross: Decimal!
"Discount amount"
discount: Decimal!
"Sales price net"
salesPriceNet: Decimal!
"Quantity"
quantity: Decimal!
"Sales invoice correction line item name"
lineItemName: String
"Stock keeping unit"
sku: String
"Value added tax rate"
taxRate: Decimal!
"Sales order item purchase price net"
salesOrderLineItemPurchasePriceNet: Decimal
"Item purchase price net"
itemPurchasePriceNet: Decimal
"Tax class identifier"
taxClassId: ID
"Line item type"
lineItemType: Byte
"Item identifier"
itemId: ID
"Sales order parts list identifier"
billOfMaterialsSalesOrderLineItemId: ID
"Parent item identifier"
parentItemId: ID
"Taric code"
taric: String
"Item weight"
itemWeight: Decimal
"Item volume"
itemVolume: Decimal
"Product group identifier"
productGroupId: ID
"Product group name"
productGroupName: String
"Warehouse identifier"
warehouseId: ID
"Sales invoice line item identifier"
salesInvoiceLineItemId: ID
}
"Single row of the invoice corrections overview table"
type SalesInvoiceCorrectionListItem {
"Unique identifier of the invoice correction"
id: ID!
"Entry number of the invoice correction"
salesInvoiceCorrectionNumber: String
"Entry number of the related invoice"
salesInvoiceNumber: String!
"Number of the related customer"
customerNumber: String
"Total gross amount of the invoice correction"
totalGrossAmount: Decimal!
"Total net amount of the invoice correction"
totalNetAmount: Decimal!
"The revenue account of the invoice correction"
revenueAccount: String
"Currency ISO code"
currencyIso: String
"Name of the customer group"
customerGroupName: String
"Date when the invoice correction was created"
salesInvoiceCorrectionDate: DateTime
"Date when the invoice correction was first printed"
printDate: DateTime
"Date when the invoice correction was first sent via e-mail"
mailDate: DateTime
"Comment of the related invoice"
salesInvoiceComment: String
"Date when the invoice correction was cancelled"
cancelledDate: DateTime
"Name of the user who cancelled the invoice correction"
cancellationUserName: String
"Cancellation reason"
cancellationReason: String
"Cancellation comment"
cancellationComment: String
"Short text of the invoice collection"
shortText: String
"Billing address company"
billingAddressCompany: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street"
billingAddressStreet: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address fax number"
billingAddressFax: String
"Billing address email address"
billingAddressEmailAddress: String
"Billing address additional company line"
billingAddressAdditionalCompanyLine: String
"Billing address additional address line"
billingAddressAdditionalAddressLine: String
"Billing address state"
billingAddressState: String
"Shipment address company"
shipmentAddressCompany: String
"Shipment address first name"
shipmentAddressFirstName: String
"Shipment address last name"
shipmentAddressLastName: String
"Shipment address street"
shipmentAddressStreet: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address fax number"
shipmentAddressFax: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: String
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment address state"
shipmentAddressState: String
"Created by user ID"
createdByUserId: ID
"Status text of the invoice correction"
status: String
"Sales channel of the invoice correction"
salesChannelId: ID @cost(weight: "10")
"DEPRECATED: do not use; use salesChannelId instead. Raw platform key (kPlattform); kept only as the source for salesChannelId."
platformId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"DEPRECATED: do not use; use salesChannelId instead. Raw shop key (kShop); kept only as the source for salesChannelId."
shopId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"CompanyId"
companyId: ID
"Comment of the sales invoice correction"
comment: String
"eBay user name"
ebayUsername: String
}
"Invoice for M&A system"
type SalesInvoiceInternal {
"Sales order ID"
salesOrderId: ID
"Sales invoice ID"
salesInvoiceId: ID!
"Customer ID"
customerId: ID!
"Platform ID"
platformId: ID
"Payment method ID"
salesInvoicePaymentMethodId: ID
"Company ID"
companyId: ID
"Payment due date in days"
paymentDueDateInDays: Int!
"Payment status"
paymentStatus: Byte
"Sales invoice number"
salesInvoiceNumber: String
"Sales invoice date"
salesInvoiceDate: DateTime
"External order number"
externalOrderNumber: String
"Shipment type"
shipmentType: Int
"Value date"
valueDate: DateTime
"Tax setting"
taxSetting: Int!
"Customer VAT ID"
customerVatIdNumber: String
"Sales invoice VAT ID"
salesInvoiceVatIdNumber: String
"Departure country ISO"
departureCountryIso: String
"Payment method ID"
paymentMethodId: ID
"Service date"
serviceDate: DateTime
"Customer number"
salesInvoiceCustomerNumber: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Currency ISO"
currencyIso: String
"Currency factor"
currencyFactor: Decimal!
"Departure country currency ISO"
departureCountryCurrencyIso: String
"Departure country currency factor"
departureCountryCurrencyFactor: Decimal!
"Total gross amount"
totalGrossAmount: Decimal
"Total net amount"
totalNetAmount: Decimal
"Last shipping"
lastShippingDate: DateTime
"Sales order number"
salesOrderNumber: String
"Created in ERP date"
createdInErpDate: DateTime
"Platform identifier"
platformIdentifier: String
"Payment method"
paymentMethod: String
"Payment method name"
paymentMethodName: String
"Shipment company"
shipmentAddressCompany: String
"Shipment salutation"
shipmentAddressSalutation: String
"Shipment title"
shipmentAddressTitle: String
"Shipment first name"
shipmentAddressFirstName: String
"Shipment last name"
shipmentAddressLastName: String
"Shipment street"
shipmentAddressStreet: String
"Shipment postal code"
shipmentAddressPostalCode: String
"Shipment city"
shipmentAddressCity: String
"Shipment country"
shipmentAddressCountry: String
"Shipment phone number"
shipmentAddressPhoneNumber: String
"Shipment fax number"
shipmentAddressFaxNumber: String
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment country ISO"
shipmentAddressCountryIso: String
"Shipment VAT ID"
shipmentAddressVatIdNumber: String
"Sales order shipment country ISO"
salesOrderShipmentCountryIso: String
"Sales invoice company"
billingAddressCompany: String
"Sales invoice salutation"
billingAddressSalutation: String
"Sales invoice title"
billingAddressTitle: String
"Sales invoice first name"
billingAddressFirstName: String
"Sales invoice last name"
billingAddressLastName: String
"Sales invoice street"
billingAddressStreet: String
"Sales invoice postal code"
billingAddressPostalCode: String
"Sales invoice city"
billingAddressCity: String
"Sales invoice country"
billingAddressCountry: String
"Sales invoice phone number"
billingAddressPhoneNumber: String
"Sales invoice fax number"
billingAddressFaxNumber: String
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: String
"Sales invoice ISO"
billingAddressCountryIso: String
"Customer company"
customerDefaultBillingAddressCompany: String
"Customer salutation"
customerDefaultBillingAddressSalutation: String
"Customer title"
customerDefaultBillingAddressTitle: String
"Customer first name"
customerDefaultBillingAddressFirstName: String
"Customer last name"
customerDefaultBillingAddressLastName: String
"Customer street"
customerDefaultBillingAddressStreet: String
"Customer postal code"
customerDefaultBillingAddressPostalCode: String
"Customer city"
customerDefaultBillingAddressCity: String
"Customer country"
customerDefaultBillingAddressCountry: String
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: String
"Customer fax number"
customerDefaultBillingAddressFaxNumber: String
"Customer address ISO"
customerDefaultBillingAddressCountryIso: String
"Customer address email address"
customerDefaultBillingAddressEmailAddress: String
"Customer address VAT ID"
customerDefaultBillingAddressVatIdNumber: String
"Customer number"
customerNumber: String
"Customer group ID"
customerGroupId: ID
"Customer payment due date in days"
customerPaymentDueDateInDays: Int
"Deposit"
deposit: String
"Cancelled sales invoice ID"
cancelledSalesInvoiceId: ID
"Delivery note count"
dropShippingDeliveryNoteCount: Int!
}
"Invoice line items for M&A system"
type SalesInvoiceLineItemInternal {
"Sales invoice identifier"
salesInvoiceId: ID!
"Sales invoice position identifier"
salesInvoicePositionId: ID!
"Sales order identifier"
salesOrderId: ID
"Item identifier"
itemId: ID
"Parts list line item identifier"
billOfMaterialsSalesInvoiceLineItemId: ID
"Sales invoice line item identifier"
salesInvoiceLineItemId: ID!
"Sales price gross"
salesPriceGross: Decimal!
"Sales price net"
salesPriceNet: Decimal!
"Invoice line item purchase price net"
purchasePriceNet: Decimal!
"Item purchase price net"
itemPurchasePriceNet: Decimal
"Invoice line item quantity"
quantity: Decimal!
"Invoice line item name"
name: String
"Stock keeping unit"
sku: String
"Invoice line item Tax rate"
taxRate: Decimal!
"Tax class identifier"
taxClassId: ID
"Invoice line item type"
invoiceLineItemType: Byte!
"Parent item identifier"
parentItemId: ID
"Taric code"
taric: String
"Item weight"
itemWeight: Decimal
"Item volume"
itemVolume: Decimal
"Product group identifier"
productGroupId: ID
"Product group name"
productGroupName: String
"Warehouse identifier"
warehouseId: ID
}
"Single row of the sales invoices overview table"
type SalesInvoiceListItem {
"Unique identifier of the sales invoice"
salesInvoiceId: ID!
"Created by user ID"
createdByUserId: ID
"Customer ID"
customerId: ID
"Currency ISO code"
currencyIso: String
"Company ID"
companyId: ID
"Company name"
companyName: String
"The VAT ID of the merchant’s company that is shown on the invoice"
vatIdNumber: String
"Payment method ID"
paymentMethodId: ID
"Payment method name"
paymentMethodName: String
"Indicates if dunning is blocked"
isDunningBlocked: Boolean!
"Date when the invoice was created"
salesInvoiceDate: DateTime!
"Value date of the invoice"
valueDate: DateTime!
"Sales invoice number"
salesInvoiceNumber: String
"Currency factor"
currencyFactor: Decimal!
"Shipping method ID"
shippingMethodId: ID
"Shipping method name"
shippingMethodName: String
"Indicates if the invoice is a draft"
isDraft: Boolean!
"Sales channel ID"
salesChannelId: ID @cost(weight: "10")
"DEPRECATED: do not use; use salesChannelId instead. Raw platform key (kPlattform); kept only as the source for salesChannelId."
platformId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"DEPRECATED: do not use; use salesChannelId instead. Raw shop key (kShop); kept only as the source for salesChannelId."
shopId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"Language ID"
languageId: ID
"Tax setting value"
taxSetting: SalesInvoiceTaxSetting!
"Indicates intra-community delivery"
isIntraCommunityDelivery: Boolean!
"Indicates VAT exemption"
isExemptFromVat: Boolean!
"Ebay username"
ebayUsername: String
"Sales channel name"
salesChannelName: String!
"Indicates if invoice is external"
isExternalSalesInvoice: Boolean!
"Indicates whether to print an existing invoice again"
printExistingSalesInvoice: Boolean!
"Date when the invoice was paid"
paymentDate: DateTime
"Date when the invoice was printed"
printDate: DateTime
"Date when the invoice was sent via e-mail"
mailDate: DateTime
"Indicates if the invoice has been dunned"
isDunned: Boolean!
"Open amount still to pay"
stillToPay: Decimal!
"Amount already paid"
alreadyPaidAmount: Decimal!
"Indicates if the invoice is completely paid"
isCompletelyPaid: Boolean!
"Internal comment"
comment: String
"Additional comment"
customerComment: String
"Total gross amount of credits related to this invoice"
salesInvoiceCorrectionTotalGrossAmount: Decimal!
"Indicates if a sales invoice correction exists"
hasSalesInvoiceCorrection: Boolean!
"Payment status of the invoice"
paymentStatus: InvoicePaymentStatus!
"Shipment address company"
shipmentAddressCompanyName: String
"Shipment address form of address"
shipmentAddressSalutation: String
"Shipment address title"
shipmentAddressTitle: String
"Shipment address first name"
shipmentAddressFirstName: String
"Shipment address last name"
shipmentAddressLastName: String
"Shipment address street"
shipmentAddressStreet: String
"The additional address line of the shipment address"
shipmentAddressAdditionalAddressLine: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: String
"Shipment address fax"
shipmentAddressFaxNumber: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"The additional company line of the shipment address"
shipmentAddressAdditionalCompanyLine: String
"Shipment address post ID"
shipmentAddressPostId: String
"Shipment address state"
shipmentAddressState: String
"Shipment address country ISO code"
shipmentAddressCountryIso: String
"Billing address company name"
billingAddressCompanyName: String
"The salutation of the billing address"
billingAddressSalutation: String
"Billing address title"
billingAddressTitle: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street"
billingAddressStreet: String
"The additional address line of the billing address"
billingAddressAdditionalAddressLine: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: String
"Billing address fax number"
billingAddressFaxNumber: String
"Billing address email address"
billingAddressEmailAddress: String
"The additional company line of the billing address"
billingAddressAdditionalCompanyLine: String
"Billing address post ID"
billingAddressPostId: String
"Billing address state"
billingAddressState: String
"Billing address country ISO code"
billingAddressCountryIso: String
"Total gross amount of the invoice"
totalGrossAmount: Decimal!
"Total gross amount in shipping country currency"
shippingCountryTotalGrossAmount: Decimal!
"Total net amount of the invoice"
totalNetAmount: Decimal!
"Total net amount in shipping country currency"
shippingCountryTotalNetAmount: Decimal!
"Name of the user who created the invoice"
createdByUserName: String
"Customer number"
customerNumber: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Customer group name"
customerGroupName: String
"Payment due date in days"
paymentDueDateInDays: Int
"Payment due date"
paymentDueDate: DateTime
"Dunning level"
dunningLevel: Int
"Date of last dunning"
dunningDate: DateTime
"Indicates if the invoice is archived"
isArchived: Boolean!
"Process colour code"
processColourCode: Int!
"Process colour name"
processColourName: String
"Platform type"
platformType: Int!
"Sales order number"
salesOrderNumber: String
"Indicates if the invoice has been corrected"
isCorrected: Boolean!
"Indicates if the invoice is cancelled"
isCancelled: Boolean!
"Date when the invoice was cancelled"
cancelledDate: DateTime
"Cancellation comment"
cancellationComment: String
"Name of the user who cancelled the invoice"
cancellationUserName: String
"Cancellation reason"
cancellationReason: String
"Related sales order ID"
salesOrderId: ID
"External sales order number"
externalSalesOrderNumber: String
"Service date from (Leistungsdatum von) of the invoice"
serviceDateFrom: DateTime
"Service date to (Leistungsdatum bis) of the invoice"
serviceDateTo: DateTime
"Date of last shipping related to the invoice"
lastShippingDate: DateTime
}
"A single salesorder by its id"
type SalesOrder {
"Unique ID to identify a sales order."
id: ID!
"Customer this SalesOrder belongs to."
customerId: ID
"SalesOrderPaymentInfo"
paymentInfo: SalesOrderPaymentInfo
"SalesOrderText"
text: SalesOrderText
"The SalesOrder Date"
salesOrderDate: DateTime
"Indicates if the order has been cancelled."
isCancelled: Boolean!
"The SalesOrder IsPending"
isPending: Boolean!
"The SalesOrder ItemDescriptionType"
itemDescriptionType: ItemDescriptionType!
"The SalesOrder ReadOnlyType"
readOnlyType: ReadOnlyType!
"The SalesOrder SalesOrderStatus"
salesOrderStatus: Byte!
"The SalesOrder SalesOrderNumber"
salesOrderNumber: String!
"DepartureCountry"
departureCountry: SalesOrderDepartureCountry!
"ExternalDetails"
externalDetails: SalesOrderExternalDetails!
"PaymentDetails"
paymentDetails: SalesOrderPaymentDetails!
"ShippingDetails"
shippingDetails: SalesOrderShippingDetails!
"TaxDetails"
taxDetails: SalesOrderTaxDetails!
"The SalesOrder Process colour id"
processColourId: ID
"The SalesOrder OnHold reason id"
onHoldReasonId: ID
"The SalesOrder Carton item id"
cartonItemId: ID
"The SalesOrder Payment method id"
paymentMethodId: ID
"The SalesOrder Shipping method id"
shippingMethodId: ID
"The SalesOrder Process status id"
processStatusId: ID
"The SalesOrder Language iso code"
languageIso: String
"The SalesOrder Customer sales order number"
customerSalesOrderNumber: String
"The SalesOrder Vat Id"
vatId: String
"The SalesOrder Company Id"
companyId: ID!
"SalesOrderShipmentAddress"
shipmentAddress: SalesOrderAddress
"SalesOrderBillingAddress"
billingAddress: SalesOrderAddress
"List of SalesOrderLineItem"
lineItems: [SalesOrderLineItem!]!
"Key figures of the sales order."
keyFigures: SalesOrderKeyFigures
}
"Address information for a sales order"
type SalesOrderAddress {
"The SalesOrder this address belongs to"
salesOrderId: ID!
"The purpose of this address"
type: AddressType!
"The customer this address belongs to"
customerId: ID
"The SalesOrderAddress Salutation"
salutation: String
"The SalesOrderAddress Title"
title: String
"The SalesOrderAddress FirstName"
firstName: String
"The SalesOrderAddress LastName"
lastName: String
"The SalesOrderAddress Company"
company: String
"The SalesOrderAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesOrderAddress Street"
street: String
"The SalesOrderAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesOrderAddress City"
city: String
"The SalesOrderAddress PostalCode"
postalCode: String
"The SalesOrderAddress State"
state: String
"The SalesOrderAddress CountryISO"
countryIso: String
"The SalesOrderAddress PostId"
postId: String
"The SalesOrderAddress EmailAddress"
emailAddress: String
"The SalesOrderAddress PhoneNumber"
phoneNumber: String
"The SalesOrderAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesOrderAddress Fax"
fax: String
"The SalesOrderAddress Countryname"
country: String
"Information about the need for additional documents"
customsDocumentsRequired: Boolean
"The SalesOrderAddress VAT ID"
vatId: String
}
"Departure country information for a sales order"
type SalesOrderDepartureCountry {
"The SalesOrder CountryISO"
countryIso: String
"The SalesOrder DepartureCountry CurrencyISO"
currencyIso: String
"The SalesOrder DepartureCountry CurrencyFactor"
currencyFactor: Decimal!
"The SalesOrder State"
state: String
}
"External details for a sales order"
type SalesOrderExternalDetails {
"The SalesOrder ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType!
"The SalesOrder ExternalSalesOrderNumber"
externalSalesOrderNumber: String
}
"Provides key figures and status information for a sales order."
type SalesOrderKeyFigures {
"The unique identifier for the sales order."
salesOrderId: ID!
"The total amount already paid by the customer."
alreadyPaidAmount: Decimal!
"The total gross amount of all related credit notes."
creditsTotalGrossAmount: Decimal!
"The date and time when the payment was received."
dateOfPayment: DateTime
"The current delivery status of the sales order."
deliveryStatus: DeliveryStatus!
"The date and time when the order was sent via email."
emailedDate: DateTime
"A comma-separated string of associated invoice numbers."
invoiceNumbers: String
"The overall status of the associated invoices."
invoiceStatus: InvoiceStatus!
"The total gross amount of all associated invoices."
invoicesTotalGrossAmount: Decimal!
"The total net amount of all associated invoices."
invoicesTotalNetAmount: Decimal!
"Whether the order is handled via cash on delivery."
isCashOnDelivery: Boolean!
"Whether all items in the order have been returned."
isFullyReturned: Boolean!
"Whether the order is currently blocked for shipping."
isLockedForDelivery: Boolean!
"The date and time of the last shipping activity."
lastShippingDate: DateTime
"The total number of packages associated with this order."
packageCount: Int!
"The date and time when the payment confirmation email was sent."
paymentMailDate: DateTime
"The current payment status of the sales order."
paymentStatus: InvoicePaymentStatus!
"The date and time when the order documents were printed."
printedDate: DateTime
"The number of packages that have already been shipped."
shippedPackageCount: Int!
"The date and time when the shipping notification email was sent."
shippingMailDate: DateTime
"The remaining amount to be paid for this order."
stillToPay: Decimal!
"The remaining amount to be paid, excluding any cancelled items."
stillToPayWithoutCancellation: Decimal!
"The total gross amount of the sales order."
totalGrossAmount: Decimal!
"The total net amount of the sales order."
totalNetAmount: Decimal!
}
"A single line item of a sales order"
type SalesOrderLineItem {
"Id of this position"
id: ID!
"Id of the SalesOrder this position belongs to"
salesOrderId: ID!
"Unique ID to identify an item."
itemId: ID
"Sku"
sku: String
"Reserved status of that position"
isReserved: Boolean!
"Name of the position."
name: String
"The SalesOrderLineItem FNSKU"
fnSku: String
"Type of the sales order line item."
type: LineItemType!
"The quantity of the line item."
quantity: Decimal!
"The sales unit of the line item."
salesUnit: String
"The net sales price of the item."
salesPriceNet: Decimal!
"The discount of the line item."
discountPercent: Decimal!
"The purchase price of the item."
purchasePriceNet: Decimal!
"The tax rate of the line item."
taxRate: Decimal!
"The SalesOrderLineItem TaxClassId"
taxClassId: ID
"The SalesOrderLineItem TaxCodeId"
taxCodeId: ID
"The SalesOrderLineItem Note"
note: String
"Total price net."
totalSalesPriceNet: Decimal!
"Total price gross."
totalSalesPriceGross: Decimal!
"Sort order."
sortOrder: Int!
"The default name."
standardName: String
"Information about an uploaded file."
hasUpload: Boolean!
"Id of the parent line item if this is a child line item."
parentSalesOrderLineItemId: ID
"Configuration item type."
configurationItemType: ConfigurationItemType!
"Bill of materials type."
billOfMaterialsType: BillOfMaterialsType!
}
"Single row of the salesorder overview table"
type SalesOrderListItem {
"Sales order id"
id: ID!
"The SalesOrder AccountsReceivableNumber"
accountsReceivableNumber: Int
"Assigned user ID"
assignedUserId: ID!
"Company name"
companyName: String
"Created by user ID"
createdByUserId: ID!
"Currency factor"
currencyFactor: Decimal!
"Currency ISO code"
currencyIso: String
"Customer ID"
customerId: ID
"The SalesOrder CustomerNumber"
customerNumber: String
"The SalesOrder DeliveryCompleteStatus"
deliveryCompleteStatus: DeliveryCompleteStatus!
"The SalesOrder CountryISO"
departureCountryIso: String
"The SalesOrder CurrencyFactor"
departureCountryCurrencyFactor: Decimal!
"The SalesOrder CurrencyISO"
departureCountryCurrencyIso: String!
"The SalesOrder EbayUsername"
ebayUsername: String
"The SalesOrder"
estimatedDeliveryDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalSalesInvoiceType: ExternalSalesInvoiceType!
"The SalesOrder"
externalSalesOrderNumber: String
"The SalesOrder ExtraWeight"
extraWeight: Decimal!
"SpacialTaxTreatment IntraCommunityDelivery"
isIntraCommunityDelivery: Boolean!
"Indicates if the order is cancelled"
isCancelled: Boolean!
"Indicates if the order is pending"
isPending: Boolean!
"Item description type"
itemDescriptionType: ItemDescriptionType!
"Language ISO code"
languageIso: String!
"The latest SalesOrder ShippingDate"
lastShippingDate: DateTime
"The SalesOrder NeedsOnlineSynchronization"
needsOnlineSynchronisation: Boolean!
"On hold reason ID"
onHoldReasonId: ID
"Payment method ID"
paymentMethodId: ID
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int
"Process colour code"
processColourCode: Int
"Process colour name"
processColourName: String
"Process status name"
processStatusName: String
"Read only type indicator"
readOnlyType: ReadOnlyType!
"Sales channel ID"
salesChannelId: ID @cost(weight: "10")
"DEPRECATED: do not use; use salesChannelId instead. Raw platform key (kPlattform); kept only as the source for salesChannelId."
platformId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"DEPRECATED: do not use; use salesChannelId instead. Raw shop key (kShop); kept only as the source for salesChannelId."
shopId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"The date when the order was created"
salesOrderDate: DateTime!
"The SalesOrder SalesOrderNumber"
salesOrderNumber: String!
"Sales order status"
salesOrderStatus: Byte!
"Shipping method ID"
shippingMethodId: ID
"The SalesOrder ShippingPriority"
shippingPriority: Int!
"The SalesOrder ShopPaymentModule"
shopPaymentModule: String
"The SalesOrder TaxSetting"
taxSetting: TaxSetting
"The total gross amount of the order"
totalGrossAmount: Decimal
"SpacialTaxTreatment VATFree"
isExemptFromVat: Boolean!
"The company ID"
companyId: ID!
"The internet order ID"
onlineSalesOrderId: Int
"Comment\/Annotation"
comment: String
"Print date"
printDate: DateTime
"Mail date"
mailDate: DateTime
"Payment mail date"
paymentMailDate: DateTime
"Date of payment"
dateOfPayment: DateTime
"Payment date"
paymentDate: DateTime
"On hold reason name"
onHoldReasonName: String
"Sales invoice status"
salesInvoiceStatus: InvoiceStatus!
"Billing address company"
billingAddressCompany: String
"Billing address additional company line"
billingAddressAdditionalCompanyLine: String
"Billing address salutation"
billingAddressSalutation: String
"Billing address title"
billingAddressTitle: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street"
billingAddressStreet: String
"Billing address additional address line"
billingAddressAdditionalAddressLine: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: String
"Billing address fax"
billingAddressFax: String
"Billing address email address"
billingAddressEmailAddress: String
"Billing address post ID"
billingAddressPostId: String
"Billing address state"
billingAddressState: String
"Billing address country ISO"
billingAddressCountryIso: String
"Shipment address company"
shipmentAddressCompany: String
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: String
"Shipment address salutation"
shipmentAddressSalutation: String
"Shipment address title"
shipmentAddressTitle: String
"Shipment address first name"
shipmentAddressFirstName: String
"Shipment address last name"
shipmentAddressLastName: String
"Shipment address street"
shipmentAddressStreet: String
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: String
"Shipment address fax"
shipmentAddressFax: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"Shipment address post ID"
shipmentAddressPostId: String
"Shipment address state"
shipmentAddressState: String
"Shipment address country ISO"
shipmentAddressCountryIso: String
"Assigned user name"
assignedUserName: String
"Sales channel name"
salesChannelName: String
"Customer group name"
customerGroupName: String!
"Payment method name"
paymentMethodName: String
"Shipping method name"
shippingMethodName: String
"Shipping country total gross amount"
shippingCountryTotalGrossAmount: Decimal
"Customer comment"
customerComment: String
"Payment reference"
paymentReference: String
"Credits total gross amount"
salesInvoiceCorrectionTotalGrossAmount: Decimal!
"Already paid amount"
alreadyPaidAmount: Decimal!
"Still to pay amount"
stillToPay: Decimal
"Total net amount"
totalNetAmount: Decimal
"WMS locked"
wmsLocked: Byte
"WMS partial shipment"
wmsPartialShipment: Int
"WMS pre picking"
wmsPrePicking: Int
"Payment status"
paymentStatus: InvoicePaymentStatus!
"Delivery status"
deliveryStatus: DeliveryStatus!
"Platform type"
platformType: Int!
"Sales invoice numbers"
salesInvoiceNumbers: String
"Cancelled date"
cancelledDate: DateTime
"Cancellation comment"
cancellationComment: String
"Cancellation user name"
cancellationUserName: String
"Cancellation reason"
cancellationReason: String
"Amazon user ID"
amazonUserId: Int
"Created by user name"
createdByUserName: String
"Returns the sales invoices associated with this sales order."
salesInvoices: [SalesInvoiceListItem] @cost(weight: "10")
}
"Payment details for a sales order"
type SalesOrderPaymentDetails {
"The SalesOrder CashDiscount"
cashDiscount: Decimal!
"The SalesOrder CashDiscountDays"
cashDiscountDays: Int!
"The SalesOrder FinancingCosts"
financingCosts: Decimal!
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int!
"The currency ISO code"
currencyIso: String
"The currency factor"
currencyFactor: Decimal!
}
"Payment information and bank details for a sales order"
type SalesOrderPaymentInfo {
"The SalesOrderPaymentInfo AccountHolder"
accountHolder: String
"The SalesOrderPaymentInfo BankName"
bankName: String
"The SalesOrderPaymentInfo BIC"
bic: String
"The SalesOrderPaymentInfo CreditorId"
creditorId: String
"The SalesOrderPaymentInfo DueDate"
dueDate: DateTime
"The SalesOrderPaymentInfo EndToEndId"
endToEndId: String
"The SalesOrderPaymentInfo IBAN"
iban: String
"The SalesOrderPaymentInfo MandateReference"
mandateReference: String
"The SalesOrderPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesOrderPaymentInfo PaymentInfoType"
paymentInfoType: Byte!
"The SalesOrderPaymentInfo PaymentReference"
paymentReference: String
"The SalesOrderPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for a sales order"
type SalesOrderShippingDetails {
"The SalesOrder DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesOrder EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesOrder ExtraWeight"
extraWeight: Decimal!
"The SalesOrder MaxDeliveryDays"
maxDeliveryDays: Int!
"The SalesOrder ShippingDate"
shippingDate: DateTime
"The SalesOrder ShippingPriority"
shippingPriority: Int!
}
"Tax details for a sales order"
type SalesOrderTaxDetails {
"The SalesOrder TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference!
"The SalesOrder SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment!
"The SalesOrder TaxSetting"
taxSetting: TaxSetting!
}
"Text and comment information for a sales order"
type SalesOrderText {
"The SalesOrderText Comment"
comment: String
"The SalesOrderText CustomerComment"
customerComment: String
"The SalesOrderText PrintText"
printText: String
"The SalesOrderText ProcessStatus"
processStatus: String
}
"A single SalesQuotation by its id"
type SalesQuotation {
"Unique ID to identify a sales quoation."
id: ID!
"Customer this SalesQuotation belongs to."
customerId: ID
"SalesQuotationPaymentInfo"
paymentInfo: SalesQuotationPaymentInfo
"SalesQuotationText"
text: SalesQuotationText
"The SalesQuotation Date"
salesQuotationDate: DateTime
"Indicates if the quotation has been cancelled."
isCancelled: Boolean!
"The SalesQuotation IsPending"
isPending: Boolean!
"The SalesQuotation ItemDescriptionType"
itemDescriptionType: ItemDescriptionType!
"The SalesQuotation ReadOnlyType"
readOnlyType: ReadOnlyType!
"The SalesQuotation Status"
salesQuotationStatus: Byte!
"The SalesQuotation SalesQuotationNumber"
salesQuotationNumber: String!
"DepartureCountry"
departureCountry: SalesQuotationDepartureCountry!
"ExternalDetails"
externalDetails: SalesQuotationExternalDetails!
"PaymentDetails"
paymentDetails: SalesQuotationPaymentDetails!
"ShippingDetails"
shippingDetails: SalesQuotationShippingDetails!
"TaxDetails"
taxDetails: SalesQuotationTaxDetails!
"The SalesQuotation Process colour id"
processColourId: ID
"The SalesQuotation OnHold reason id"
onHoldReasonId: ID
"The SalesQuotation Carton item id"
cartonItemId: ID
"The SalesQuotation Payment method id"
paymentMethodId: ID
"The SalesQuotation Shipping method id"
shippingMethodId: ID
"The SalesQuotation Process status id"
processStatusId: ID
"The SalesQuotation Language iso code"
languageIso: String
"The SalesQuotation Customer sales quotation number"
customerSalesQuotationNumber: String
"The SalesQuotation Vat Id"
vatId: String
"The SalesQuotation Company Id"
companyId: ID!
"SalesQuotationShippingAddress"
shipmentAddress: SalesQuotationAddress
"SalesQuotationBillingAddress"
billingAddress: SalesQuotationAddress
"List of SalesQuotationLineItem"
lineItems: [SalesQuotationLineItem!]!
}
"Address information for a sales quotation"
type SalesQuotationAddress {
"The SalesQuotation this address belongs to"
salesQuotationId: ID!
"The purpose of this address"
type: AddressType!
"The customer this address belongs to"
customerId: ID
"The SalesQuotationAddress Salutation"
salutation: String
"The SalesQuotationAddress Title"
title: String
"The SalesQuotationAddress FirstName"
firstName: String
"The SalesQuotationAddress LastName"
lastName: String
"The SalesQuotationAddress Company"
company: String
"The SalesQuotationAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesQuotationAddress Street"
street: String
"The SalesQuotationAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesQuotationAddress City"
city: String
"The SalesQuotationAddress PostalCode"
postalCode: String
"The SalesQuotationAddress State"
state: String
"The SalesQuotationAddress CountryISO"
countryIso: String
"The SalesQuotationAddress PostId"
postId: String
"The SalesQuotationAddress EmailAddress"
emailAddress: String
"The SalesQuotationAddress PhoneNumber"
phoneNumber: String
"The SalesQuotationAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesQuotationAddress Fax"
fax: String
"The SalesQuotationAddress Countryname"
country: String
"Information about the need for additional documents"
customsDocumentsRequired: Boolean
"The SalesQuotationAddress VAT ID"
vatId: String
}
"Departure country information for a sales quotation"
type SalesQuotationDepartureCountry {
"The SalesQuotation CountryISO"
countryIso: String
"The SalesQuotation DepartureCountry CurrencyISO"
currencyIso: String
"The SalesQuotation DepartureCountry CurrencyFactor"
currencyFactor: Decimal!
"The SalesQuotation StateCode"
stateCode: String
}
"External details for a sales quotation"
type SalesQuotationExternalDetails {
"The SalesQuotation ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesQuotation ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType!
"The SalesQuotation ExternalSalesQuotationNumber"
externalSalesQuotationNumber: String
}
"A single line item of a sales quotation"
type SalesQuotationLineItem {
"Id of this position"
id: ID!
"Id of the SalesQuotation this position belongs to"
salesQuotationId: ID!
"Unique ID to identify an item."
itemId: ID
"Sku"
sku: String
"Reserved status of that position"
isReserved: Boolean!
"Name of the position."
name: String
"The SalesQuotationLineItem FNSKU"
fnSku: String
"Type of the sales quotation line item."
type: LineItemType!
"The quantity of the line item."
quantity: Decimal!
"The sales unit of the line item."
salesUnit: String
"The net sales price of the item."
salesPriceNet: Decimal!
"The discount of the line item."
discountPercent: Decimal!
"The purchase price of the item."
purchasePriceNet: Decimal!
"The tax rate of the line item."
taxRate: Decimal!
"The SalesQuotationLineItem TaxClassId"
taxClassId: ID
"The SalesQuotationLineItem TaxCodeId"
taxCodeId: ID
"The SalesQuotationLineItem Note"
note: String
"Total price net."
totalSalesPriceNet: Decimal!
"Total price gross."
totalSalesPriceGross: Decimal!
"Sort order."
sortOrder: Int!
"The default name."
standardName: String
"Information about an uploaded file."
hasUpload: Boolean!
"Id of the parent line item if this is a child line item."
parentSalesQuotationLineItemId: ID
"Configuration item type."
configurationItemType: ConfigurationItemType!
"Bill of materials type."
billOfMaterialsType: BillOfMaterialsType!
}
"Single row of the sales quotation overview table"
type SalesQuotationListItem {
"Sales quotation unique identifier"
id: ID!
"Assigned user ID"
assignedUserId: ID!
"Customer ID"
customerId: ID
"Shipping method ID"
shippingMethodId: ID
"Company (firm) ID"
companyId: ID
"Payment method ID"
paymentMethodId: ID
"Official sales quotation number"
salesQuotationNumber: String!
"External reference number for the quotation"
externalSalesQuotationNumber: String
"Name of the platform where the quotation originated"
platformName: String
"Internal comments or remarks"
comment: String
"ISO currency code used for the quotation"
currencyIso: String
"Exchange rate factor for the currency"
currencyFactor: Decimal!
"Date when the quotation was printed"
printDate: DateTime
"Date when the quotation was sent via email"
mailDate: DateTime
"Display text for the current process status"
processStatusName: String
"Additional weight calculated for the quotation"
extraWeight: Decimal!
"Total shipping weight"
shippingWeight: Decimal!
"Date and time when the quotation was created"
salesQuotationDate: DateTime!
"ISO code of the departure\/shipping country"
departureCountryIso: String
"Name of the departure\/shipping country"
departureCountryName: String
"Currency ISO code of the departure country"
departureCountryCurrencyIso: String!
"Currency exchange factor of the departure country"
departureCountryCurrencyFactor: Decimal!
"Billing address company"
billingAddressCompany: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street and house number"
billingAddressStreet: String
"Billing address additional address line (e.g., apartment, suite)"
billingAddressAdditionalAddressLine: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address fax number"
billingAddressFax: String
"Billing address email address"
billingAddressEmailAddress: String
"Billing address additional company information line"
billingAddressAdditionalCompanyLine: String
"Billing address state or province"
billingAddressState: String
"Shipment address company name"
shipmentAddressCompany: String
"Shipment address contact first name"
shipmentAddressFirstName: String
"Shipment address contact last name"
shipmentAddressLastName: String
"Shipment address street and house number"
shipmentAddressStreet: String
"Shipment address additional address line (e.g., apartment, suite)"
shipmentAddressAdditionalAddressLine: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address fax number"
shipmentAddressFax: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"Shipment address additional company information line"
shipmentAddressAdditionalCompanyLine: String
"Shipment address state or province"
shipmentAddressState: String
"Name of the user currently assigned to this quotation"
assignedUserName: String
"Name of the user who originally created the quotation"
createdByUserName: String
"Display name of the company"
companyName: String
"Name of the sales channel or shop"
salesChannelName: String
"Name of the assigned customer group"
customerGroupName: String
"Display name of the selected payment method"
paymentMethodName: String
"Display name of the selected shipping method"
shippingMethodName: String
"Unique customer business number"
customerNumber: String
"Total gross amount in the system's base currency"
totalGrossAmount: Decimal
"Total net amount in the system's base currency"
totalNetAmount: Decimal
"Total gross amount converted to the shipping country's currency"
shippingCountryTotalGrossAmount: Decimal
"Total net amount converted to the shipping country's currency"
shippingCountryTotalNetAmount: Decimal
"Additional customer-related notes or miscellaneous instructions"
customerComment: String
"ARGB or numeric color code for process highlighting"
processColourCode: Int
"Descriptive name of the assigned process color"
processColourName: String
}
"Payment details for a sales quotation"
type SalesQuotationPaymentDetails {
"The SalesQuotation CashDiscount"
cashDiscount: Decimal!
"The SalesQuotation CashDiscountDays"
cashDiscountDays: Int!
"The SalesQuotation FinancingCosts"
financingCosts: Decimal!
"The SalesQuotation PaymentDueDateInDays"
paymentDueDateInDays: Int!
"The currency ISO code"
currencyIso: String
"The currency factor"
currencyFactor: Decimal!
}
"Payment information and bank details for a sales quotation"
type SalesQuotationPaymentInfo {
"The SalesQuotationPaymentInfo AccountHolder"
accountHolder: String
"The SalesQuotationPaymentInfo BankName"
bankName: String
"The SalesQuotationPaymentInfo BIC"
bic: String
"The SalesQuotationPaymentInfo CreditorId"
creditorId: String
"The SalesQuotationPaymentInfo DueDate"
dueDate: DateTime
"The SalesQuotationPaymentInfo EndToEndId"
endToEndId: String
"The SalesQuotationPaymentInfo IBAN"
iban: String
"The SalesQuotationPaymentInfo MandateReference"
mandateReference: String
"The SalesQuotationPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesQuotationPaymentInfo PaymentInfoType"
paymentInfoType: Byte!
"The SalesQuotationPaymentInfo PaymentReference"
paymentReference: String
"The SalesQuotationPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for a sales quotation"
type SalesQuotationShippingDetails {
"The SalesQuotation DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesQuotation EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesQuotation ExtraWeight"
extraWeight: Decimal!
"The SalesQuotation MaxDeliveryDays"
maxDeliveryDays: Int!
"The SalesQuotation ShippingDate"
shippingDate: DateTime
"The SalesQuotation ShippingPriority"
shippingPriority: Int!
}
"Tax details for a sales quotation"
type SalesQuotationTaxDetails {
"The SalesQuotation TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference!
"The SalesQuotation SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment!
"The SalesQuotation TaxSetting"
taxSetting: TaxSetting!
}
"Text and comment information for a sales quotation"
type SalesQuotationText {
"The SalesQuotationText Comment"
comment: String
"The SalesQuotationText CustomerComment"
customerComment: String
"The SalesQuotationText PrintText"
printText: String
"The SalesQuotationText ProcessStatus"
processStatus: String
}
type SaleschannelImages {
"Unique ID to identify a saleschannel."
saleschannelId: ID!
"List of images assigned to the platform."
images: [ItemImage!]!
}
"Single Row of the serial number query"
type SerialNumberListItem {
"Id of the Warehouse."
warehouseId: ID!
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ID!
"Id of the item."
itemId: ID!
"Serial numbers of the item."
serialNumber: String!
"Indicates if the serial number is active."
isActive: Boolean!
}
"Represents a shipping address"
type ShippingAddress {
"Company name"
company: String!
"Salutation"
salutation: String!
"Title"
title: String!
"First name"
firstName: String!
"Last name"
lastName: String!
"Street"
street: String!
"Zip code"
zipCode: String!
"City"
city: String!
"Country"
country: String!
"Phone"
phone: String!
"Address supplement"
addressSupplement: String!
"Address supplement 2"
addressSupplement2: String!
"Post ID"
postId: String!
"Mobile"
mobile: String!
"Mail"
mail: String!
"Fax"
fax: String!
"State"
state: String!
"ISO code"
iso: String!
"Customs documents required"
customsDocumentsRequired: Boolean!
}
"Single row of the shipping boxes overview list."
type ShippingBoxListItem {
"Shipping box identifier."
id: ID!
"Display name of the shipping box."
displayId: String!
"Box type identifier (nullable in DB)."
typeId: ID
"Assigned bin location (can be 0 or null in DB)."
binLocationId: ID
"Parent warehouse."
warehouseId: ID!
"Lock status (false=unlocked, true=locked). Nullable in database."
locked: Boolean
}
"Reference data describing an available shipping box type."
type ShippingBoxType {
"Box type identifier."
value: ID!
"Display name for the box type."
name: String!
}
"Single row of the shipping class overview"
type ShippingClassListItem {
"ShippingClass id"
id: ID!
"The name of the shipping class"
name: String!
}
"Single Row of the shipping method lookup"
type ShippingMethodLookupItem {
"Id of the shipping method."
id: ID!
"Default Category Name"
name: String!
"Is the shipping method active"
isActive: Boolean!
}
"Provides paged access to stock movement history entries filtered by warehouse and optional criteria."
type StockMovementHistoryItem {
"Article number (cArtNr)."
articleNumber: String!
"Article display name."
articleName: String!
"Movement quantity."
quantity: Decimal!
"Best-before date (MHD), if tracked."
bestBeforeDate: DateTime
"Batch\/charge number."
batchNumber: String
"First serial number linked to the movement."
serialNumber: String
"Count of serial numbers linked to the movement."
serialNumberCount: Int!
"Source bin location name."
sourceBinLocation: String
"Target bin location name."
targetBinLocation: String
"Source shipping box display ID."
sourceBoxDisplayId: String
"Target shipping box display ID."
targetBoxDisplayId: String
"Transfer type key (kBuchungsArt)."
transferTypeId: Int
"Transfer type name."
transferTypeName: String
"User name."
userName: String
"Movement timestamp."
timestamp: DateTime!
"Movement comment."
comment: String
}
"Single Row of the stock reservations query"
type StockReservationListItem {
"Id of the item"
itemId: ID!
"Id of the sales order"
salesOrderId: ID!
"Id of the customer"
customerId: ID!
"Reserved amount"
amount: Decimal!
"Creation date of the reservation"
createdAt: DateTime!
"eBay item identifier"
ebayItemId: String!
"Sales platform"
platform: String!
}
"Single Row of the storage location query"
type StorageLocationListItem {
"Id of the storage location."
id: ID!
"Default storage location name"
name: String!
}
"Single row of the supplier overview table"
type Supplier {
"Unique identifier of the supplier"
id: ID!
"Name of the supplier"
name: String!
"Is drop shipping supplier"
canDropship: Boolean!
"Currency ISO code"
currencyIso: String!
}
type SupplierPrice {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal!
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal!
}
"Represents a tax class in the system"
type TaxClass {
"The unique identifier of the tax class"
id: ID!
"Indicates if this tax class is the standard tax class"
isStandard: Boolean!
"The name of the tax class"
name: String!
"The type of the tax class"
taxType: TaxType!
}
"Represents a tax class item in the system"
type TaxClassWithTaxRate {
"The unique identifier of the tax class."
id: ID!
"The name of the tax class"
name: String!
"Indicates if this tax class is the standard tax class"
isStandard: Boolean!
"The tax rate in percent calculated for this tax class with the given parameters."
rate: Decimal
}
"Represents a tax code in the system"
type TaxCode {
"The unique identifier of the tax code"
id: ID!
"The cash discount account of the tax code"
cashDiscountAccount: String!
"The general ledger account of the tax code"
generalLedgerAccount: String!
"Indicates if this tax code is automatic"
isAutomatic: Boolean!
"The name of the tax code"
name: String!
"The number of the tax code"
number: Int
}
"Updates a new Category - Response"
type UpdateCategoryCommandResponse {
"Unique ID of the modified category."
categoryId: ID!
}
"Updates a customer - Response"
type UpdateCustomerCommandResponse {
"Id of the changed customer"
customerId: ID!
}
"Modifies an existing sales order. - Response"
type UpdateSalesOrderCommandResponse {
"Unique ID of the modified sales order."
salesOrderId: ID!
}
type Variation {
"Id of the Variation"
variationId: ID!
"Position of this Variation in the List"
position: Int!
"Descriptions of this Variation in multiple Languages"
descriptions: [Description!]!
"Values for this Variation"
values: [VariationValue!]!
"Type of the Variation"
variationType: VariationType!
}
type VariationValue {
"Id of the VariationValue"
variationValueId: ID!
"Itemnumber for this variationvalue"
itemNumber: String
"GTIN for this variationvalue"
gtin: String
"Offset for the weight of this variationvalue"
weightOffset: Decimal!
"Descriptions of this VariationValue in multiple Languages"
descriptions: [Description!]!
"Surcharges of this VariationValue"
surcharges: VariationValueSurcharges!
"Position of this VariationValue in the List"
position: Int!
"Image for this variation value. This image will be used as the main image for the variation combination if this variation value is part of it and the variation combination doesn't have its own image."
image: ID
}
type VariationValueSurcharges {
"Default Surcharge if there is none specified for a specific saleschannel + customergroup"
defaultSurchargeNet: Decimal!
"Default Surcharges for specific customergroups in general, independent of saleschannel"
customerGroupSurcharges: [CustomerGroupSurcharge!]!
"Surcharge for specific saleschannels + customergroups"
salesChannelSurcharges: [SalesChannelSurcharge!]!
}
"Represents a warehouse address"
type WarehouseAddress {
"Warehouse ID"
id: ID!
"Warehouse name"
name: String!
"Shortcut"
shortcut: String!
"Description"
description: String!
"Street"
street: String!
"Zip code"
zipCode: String!
"City"
city: String!
"Country"
country: String!
"Phone"
phone: String!
"Mail"
mail: String!
"Address supplement"
addressSupplement: String!
}
"Single Row of the warehouse query"
type WarehouseListItem {
"Id of the warehouse."
id: ID!
"Default warehouse name"
name: String!
"Describes if the warehouse is active"
active: Boolean!
}
"Single row of the warehouse zones overview list."
type WarehouseZoneListItem {
"Unique zone identifier."
zoneId: ID!
"Zone short code."
code: String!
"Zone description (may be empty)."
description: String
"Warehouse that owns this zone."
warehouseId: ID!
"Zone type enum value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: Int!
}
"Represents a workbench resource."
type WorkbenchResource {
"This workbench resource's unique ID."
id: ID!
"This workbench resource's unique number."
number: String!
"This workbench resource's name."
name: String!
"This workbench resource's description."
description: String!
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ID!
"The name of the host assigned to this workbench resource."
hostName: String!
"The ID of the warehouse assigned to this workbench resource."
warehouseId: ID!
"The reservation mode of this workbench resource."
reservationMode: ReservationMode!
"Specifies whether the dialog for displaying and\/or capturing process parameter values in the context of production should be displayed automatically when process parameter values can\/must be displayed or captured."
autoShowProcessParameterValuesInProduction: Boolean!
"Specifies whether and to what extent the use of expired components is permitted."
expiredComponentsUsage: ExpiredComponentsUsage!
"Specifies wthether and how available stock should be reserved when creating a replenishment order."
replenishmentCreationStockReservationMode: ReplenishmentCreationAvailableStockReservationMode!
}
"Represents a workbench resource type"
type WorkbenchResourceType {
"This workbench resource type's unqiue ID."
id: ID!
"The workbench resource type's name."
name: String!
}
"Represents a bin location assigned to a warehouse zone."
type ZoneBinLocationItem {
"Zone identifier."
zoneId: ID!
"Bin location identifier."
binLocationId: ID!
}
"Reference data describing an available warehouse zone type."
type ZoneType {
"Zone type numeric value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
value: Int!
"Display name for the zone type."
name: String!
}
"Activates a bin location, making it available for operations. - Request"
input ActivateBinLocationCommandRequestInput {
"Unique identifier of the bin location to activate."
binLocationId: ID!
}
"Activates a language in the system - Request"
input ActivateLanguageCommandRequestInput {
"The culture or ISO code of the language to be activated."
cultureOrIso: String!
}
"Reference data describing available employee tracking activity types."
input ActivityTypeFilterInput {
and: [ActivityTypeFilterInput!]
or: [ActivityTypeFilterInput!]
"Activity type numeric value (kBuchungsart)."
value: ComparableInt32OperationFilterInput
"Display name of the activity type."
name: StringOperationFilterInput
}
"Reference data describing available employee tracking activity types."
input ActivityTypeSortInput {
"Activity type numeric value (kBuchungsart)."
value: SortEnumType @cost(weight: "10")
"Display name of the activity type."
name: SortEnumType @cost(weight: "10")
}
"Adds bin locations to a warehouse zone. - Request"
input AddBinLocationsToZoneCommandRequestInput {
"The zone to add bin locations to."
zoneId: ID!
"Bin locations to add to the zone."
binLocationIds: [ID]!
}
"Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals. - Request"
input AddItemSupplierCommandRequestInput {
"Unique ID of the item to be modified - this key is used for all further operations with the item."
itemId: ID!
"Supplier information to be added to the item."
itemSupplier: CreateItemSupplierInput!
}
"Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options. - Request"
input AddItemVariationCommandRequestInput {
"Unique ID of the item to be modified - this key is used for all further operations with the item."
itemId: ID!
"The variation to add including type (selectbox, radio, etc.), descriptions in multiple languages, and optional variation values."
variation: CreateVariationInput!
}
"Adds a new value to an existing item variation. - Request"
input AddItemVariationValueCommandRequestInput {
"Unique ID of the variation to which the value should be added."
variationId: ID!
"The variation value to add including descriptions in multiple languages, surcharges, GTIN, item number, and weight offset."
variationValue: CreateVariationValueInput!
}
"Add new product groups. - Request"
input AddProductGroupsCommandRequestInput {
"The names of the product groups."
names: [String!]!
}
input ArtikelKeySortInput {
kArtikel: SortEnumType @cost(weight: "10")
}
"Reassigns a shipping box to a different bin location (Rule SB-5). - Request"
input AssignShippingBoxToLocationCommandRequestInput {
"The shipping box to reassign."
shippingBoxId: ID!
"New bin location."
binLocationId: ID!
}
"A list of batches for specific items and their quantities"
input BatchListItemFilterInput {
and: [BatchListItemFilterInput!]
or: [BatchListItemFilterInput!]
"Id of the Item"
itemId: ComparableArtikelKeyOperationFilterInput
"The batch number"
batch: StringOperationFilterInput
"The quantity of the item in the batch"
quantity: ComparableDecimalOperationFilterInput
"Id of the Warehouse"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
"A list of batches for specific items and their quantities"
input BatchListItemSortInput {
"Id of the Item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"The batch number"
batch: SortEnumType @cost(weight: "10")
"The quantity of the item in the batch"
quantity: SortEnumType @cost(weight: "10")
"Id of the Warehouse"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
input BenutzerKeySortInput {
kBenutzer: SortEnumType @cost(weight: "10")
}
"A list of best before dates (MHDs) for specific items and their quantities"
input BestBeforeListItemFilterInput {
and: [BestBeforeListItemFilterInput!]
or: [BestBeforeListItemFilterInput!]
"Id of the Item"
itemId: ComparableArtikelKeyOperationFilterInput
"The best before date (MHD)"
bestBeforeDate: ComparableDateTimeOperationFilterInput
"The quantity of the item with this best before date"
quantity: ComparableDecimalOperationFilterInput
"Id of the Warehouse"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
"A list of best before dates (MHDs) for specific items and their quantities"
input BestBeforeListItemSortInput {
"Id of the Item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"The best before date (MHD)"
bestBeforeDate: SortEnumType @cost(weight: "10")
"The quantity of the item with this best before date"
quantity: SortEnumType @cost(weight: "10")
"Id of the Warehouse"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
input BildKeySortInput {
kBild: SortEnumType @cost(weight: "10")
}
input BillOfMaterialKeySortInput {
kBillOfMaterial: SortEnumType @cost(weight: "10")
}
"A bill of materials for a production item. It defines which operations must be performed and which components are required to produce the production item."
input BillOfMaterialsFilterInput {
and: [BillOfMaterialsFilterInput!]
or: [BillOfMaterialsFilterInput!]
"The ID of this bill of materials."
id: ComparableBillOfMaterialKeyOperationFilterInput
"The ID of the production item of this bill of materials."
productionItemId: ComparableProdItemKeyOperationFilterInput
"The version of this bill of materials."
version: ComparableInt32OperationFilterInput
"The name of this production bill of materials."
name: StringOperationFilterInput
"The description of this production bill of materials."
description: StringOperationFilterInput
"The status of this production bill of materials."
state: ComparableBillOfMaterialsStateOperationFilterInput
"The timestamp when this bill of materials was created."
createDate: ComparableDateTimeOffsetOperationFilterInput
"The timestamp when this bill of materials was last modified, or NULL if this bill of materials has not been modified yet."
updateDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The ID of the user who last modified this bill of materials, or NULL if this bill of materials has not been modified yet."
updateUserId: ComparableBenutzerKeyOperationFilterInput
"The timestamp when this bill of materials was activated, or NULL if this bill of materials has not been activated yet."
activationDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The last calculated producible stock."
producibleStock: ComparableDecimalOperationFilterInput
"The timestamp when the producible stock was last calculated, or NULL if it has not been calculated yet."
producibleStockCalculationDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Specifies requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsShelfLifeEndDateRequirements: ComparableOverallComponentPostingsInventoryAccountingDataRequirementsOperationFilterInput
"Specifies requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsBatchNumberRequirements: ComparableOverallComponentPostingsInventoryAccountingDataRequirementsOperationFilterInput
"Indicates how the shelf life end date of a product is calculated after completing a lot."
shelfLifeEndDateGenerationMode: ComparableShelfLifeEndDateGenerationModeOperationFilterInput
"A time span that is added when calculating the shelf life end date of a product after completing a lot."
additionalShelfLifeEndDateTime: ComparableNullableOfTimeSpanOperationFilterInput
}
"A bill of materials for a production item. It defines which operations must be performed and which components are required to produce the production item."
input BillOfMaterialsSortInput {
"The ID of this bill of materials."
id: BillOfMaterialKeySortInput @cost(weight: "10")
"The ID of the production item of this bill of materials."
productionItemId: ProdItemKeySortInput @cost(weight: "10")
"The version of this bill of materials."
version: SortEnumType @cost(weight: "10")
"The name of this production bill of materials."
name: SortEnumType @cost(weight: "10")
"The description of this production bill of materials."
description: SortEnumType @cost(weight: "10")
"The status of this production bill of materials."
state: SortEnumType @cost(weight: "10")
"The timestamp when this bill of materials was created."
createDate: SortEnumType @cost(weight: "10")
"The timestamp when this bill of materials was last modified, or NULL if this bill of materials has not been modified yet."
updateDate: SortEnumType @cost(weight: "10")
"The ID of the user who last modified this bill of materials, or NULL if this bill of materials has not been modified yet."
updateUserId: BenutzerKeySortInput @cost(weight: "10")
"The timestamp when this bill of materials was activated, or NULL if this bill of materials has not been activated yet."
activationDate: SortEnumType @cost(weight: "10")
"The last calculated producible stock."
producibleStock: SortEnumType @cost(weight: "10")
"The timestamp when the producible stock was last calculated, or NULL if it has not been calculated yet."
producibleStockCalculationDate: SortEnumType @cost(weight: "10")
"Specifies requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsShelfLifeEndDateRequirements: SortEnumType @cost(weight: "10")
"Specifies requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsBatchNumberRequirements: SortEnumType @cost(weight: "10")
"Indicates how the shelf life end date of a product is calculated after completing a lot."
shelfLifeEndDateGenerationMode: SortEnumType @cost(weight: "10")
"A time span that is added when calculating the shelf life end date of a product after completing a lot."
additionalShelfLifeEndDateTime: SortEnumType @cost(weight: "10")
}
"Single row of the bin locations overview list."
input BinLocationListItemFilterInput {
and: [BinLocationListItemFilterInput!]
or: [BinLocationListItemFilterInput!]
"Unique bin location identifier."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Bin location name (unique within the warehouse)."
name: StringOperationFilterInput
"Warehouse that owns this bin location."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Current status of the bin location (0=Active, 1=Deactivated, 2=Locked)."
status: ComparableInt32OperationFilterInput
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: ComparableInt32OperationFilterInput
"Optional sort order."
sort: ComparableNullableOfInt32OperationFilterInput
}
"Single row of the bin locations overview list."
input BinLocationListItemSortInput {
"Unique bin location identifier."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Bin location name (unique within the warehouse)."
name: SortEnumType @cost(weight: "10")
"Current status of the bin location (0=Active, 1=Deactivated, 2=Locked)."
status: SortEnumType @cost(weight: "10")
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: SortEnumType @cost(weight: "10")
"Optional sort order."
sort: SortEnumType @cost(weight: "10")
}
"Occupancy data (fill factors) for a single bin location in a warehouse."
input BinLocationOccupancyItemFilterInput {
and: [BinLocationOccupancyItemFilterInput!]
or: [BinLocationOccupancyItemFilterInput!]
"Unique bin location identifier."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Volume fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
volumeFillFactor: ComparableDecimalOperationFilterInput
"Weight fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
weightFillFactor: ComparableDecimalOperationFilterInput
"Date of the last WMS inventory count for this bin location. Null if never inventoried."
lastInventoryDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
}
"Occupancy data (fill factors) for a single bin location in a warehouse."
input BinLocationOccupancyItemSortInput {
"Unique bin location identifier."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Volume fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
volumeFillFactor: SortEnumType @cost(weight: "10")
"Weight fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
weightFillFactor: SortEnumType @cost(weight: "10")
"Date of the last WMS inventory count for this bin location. Null if never inventoried."
lastInventoryDate: SortEnumType @cost(weight: "10")
}
"Single row of the bin location pick heatmap query."
input BinLocationPickHeatmapItemFilterInput {
and: [BinLocationPickHeatmapItemFilterInput!]
or: [BinLocationPickHeatmapItemFilterInput!]
"Id of the bin location."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Warehouse that owns this bin location."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Number of completed pick operations in the selected time period."
pickCount: ComparableInt32OperationFilterInput
"Total quantity picked in the selected time period."
pickQuantity: ComparableDecimalOperationFilterInput
}
"Single row of the bin location pick heatmap query."
input BinLocationPickHeatmapItemSortInput {
"Id of the bin location."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Warehouse that owns this bin location."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Number of completed pick operations in the selected time period."
pickCount: SortEnumType @cost(weight: "10")
"Total quantity picked in the selected time period."
pickQuantity: SortEnumType @cost(weight: "10")
}
"Calculate prices, discounts, and taxes for a sales order without persisting it. - Request"
input CalculateSalesOrderCommandRequestInput {
"The sales order calculation request model in the original state before any changes."
calculateSalesOrderRequest: CreateCalculateSalesOrderRequestInput!
"The mode for tax recalculation (NoRecalculation, KeepNetPrices, KeepGrossPrices)."
recalculateTaxMode: RecalculateTaxMode!
"The history of changes made to the sales order request. Changes are processed in the order specified."
changes: [CreateCalculateSalesOrderRequestChangeInput!]!
}
"Cancel marketplace order cancellation request uploads. - Request"
input CancelMarketplaceOrderCancellationRequestUploadCommandRequestInput {
"Marketplace order cancellation event keys whose upload should be cancelled."
orderCancellationEventKeys: [ID]!
}
"Cancel a sales invoice - Request"
input CancelSalesInvoiceCommandRequestInput {
"The ID of the sales invoice to cancel."
salesInvoiceId: ID!
"The reason for cancelling the invoice."
cancellationReasonId: ID!
"An optional comment explaining the cancellation."
cancellationComment: String
}
"Cancel a sales invoice correction - Request"
input CancelSalesInvoiceCorrectionCommandRequestInput {
"The ID of the sales invoice correction to cancel."
salesInvoiceCorrectionId: ID!
"The reason for cancelling the sales invoice correction."
cancellationReasonId: ID!
"An optional comment explaining the cancellation."
cancellationComment: String
}
"Cancel a sales quotation - Request"
input CancelSalesQuotationCommandRequestInput {
"The ID of the sales quotation to cancel."
salesQuotationId: ID!
"The reason for cancelling the quotation."
cancellationReasonId: ID!
"An optional comment explaining the cancellation."
cancellationComment: String
}
"Single Row of the category overview"
input CategoryListItemFilterInput {
and: [CategoryListItemFilterInput!]
or: [CategoryListItemFilterInput!]
"Id of the category."
id: ComparableKategorieKeyOperationFilterInput
"Id of the parent category."
parentId: ComparableKategorieKeyOperationFilterInput
}
"Single Row of the category overview"
input CategoryListItemSortInput {
"Id of the category."
id: KategorieKeySortInput @cost(weight: "10")
"Id of the parent category."
parentId: KategorieKeySortInput @cost(weight: "10")
"Sortnumber of the category."
sortNumber: SortEnumType @cost(weight: "10")
"Default Category Name"
name: SortEnumType @cost(weight: "10")
}
"Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information. - Request"
input ChangeItemCommandRequestInput {
"Unique ID of the item to be modified - this key is used for all further operations with the item."
itemId: ID!
"The ID of the product group to which the item should be assigned. Product groups serve for categorical classification of items for reports and analyses."
productGroupId: ID
"The ID of the shipping class to which the item should be assigned."
shippingClassId: ID
"The ID of the manufacturer to which the item should be assigned."
manufacturerId: ID
"Category assignments of the item. Defines all categories to which the item should be assigned for better organization and navigation."
categories: UpdateItemCategoriesInput
"Identifiers of the item with all relevant markings and numbers for unique identification of the item in various systems."
identifiers: UpdateItemIdentifiersInput
"Descriptions of the item in different languages and for different platforms\/sales channels. Includes names, short and long descriptions as well as SEO-relevant information."
descriptions: UpdateItemDescriptionsInput
"Price structures of the item for different sales channels, customer groups and individual customers. Includes sales prices, purchase prices and tier prices."
prices: UpdateItemPricesInput
"Physical dimensions and weight specifications of the item for storage, shipping and product presentation. Important for shipping cost calculations and storage space optimization."
measurements: UpdateItemMeasurementsInput
"tbd"
images: UpdateItemImagesInput
"Custom fields defined for the item to store additional information. Useful for special requirements or integrations."
customFields: UpdateItemCustomFieldsInput
"Suppliers associated with the item including supplier-specific information such as purchase prices, delivery times and order intervals."
suppliers: UpdateItemSuppliersInput
"Variations of an item"
variations: UpdateItemVariationsInput
"Delivery status id determining the availability display of the item (e.g. 'immediately available', '2-3 days'). Tab 'Sonstiges'."
deliveryStatusId: ID
"Indicates whether the item can be included in exported price lists. Tab 'Sonstiges'."
includeInPriceList: Boolean
"Indicates whether order suggestions should be ignored for this item. If true, the item will not appear in automatic order suggestions. Tab 'Sonstiges'."
ignoreOrderSuggestions: Boolean
"Indicates whether the item is not eligible for discounts (Rabatte ignorieren \/ Nicht Rabattfähig). Tab 'Sonstiges'."
ignoreDiscounts: Boolean
"Country of origin (Herkunftsland) - ISO code or country name. Max length 64. Tab 'Sonstiges'."
countryOfOrigin: String
"Additional notes (Anmerkung) for the item - unlimited length. Tab 'Sonstiges'."
notes: String
"Features of an item"
features: UpdateItemFeaturesInput
"Attributes of an item"
attributes: UpdateItemAttributesInput
"UnitPricing information of an item"
unitPricing: UpdateItemUnitPricingInput
"SpecialPrices information of an item"
specialPrices: UpdateItemSpecialPricesInput
"ItemStorageConstraints information of an item"
storageConstraints: UpdateItemStorageConstraintsInput
}
"Modifies an existing Package Weight - Request"
input ChangePackageWeightCommandRequestInput {
"ID of the Package to be modified"
packageId: String!
"The new Weight of the Package"
weight: Decimal!
}
"Single row of the company table"
input CompanyListItemFilterInput {
and: [CompanyListItemFilterInput!]
or: [CompanyListItemFilterInput!]
"Unique ID to identify a company (kFirma)."
id: ComparableFirmaKeyOperationFilterInput
"Name of the company."
companyName: StringOperationFilterInput
"Owner of the company."
owner: StringOperationFilterInput
"Tax identification number."
taxId: StringOperationFilterInput
}
"Single row of the company table"
input CompanyListItemSortInput {
"Unique ID to identify a company (kFirma)."
id: FirmaKeySortInput @cost(weight: "10")
"Name of the company."
companyName: SortEnumType @cost(weight: "10")
"Owner of the company."
owner: SortEnumType @cost(weight: "10")
"Tax identification number."
taxId: SortEnumType @cost(weight: "10")
}
input ComparableArtikelKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBenutzerKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBildKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBillOfMaterialKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBillOfMaterialsStateOperationFilterInput {
eq: BillOfMaterialsState @cost(weight: "10")
neq: BillOfMaterialsState @cost(weight: "10")
in: [BillOfMaterialsState!] @cost(weight: "10")
nin: [BillOfMaterialsState!] @cost(weight: "10")
gt: BillOfMaterialsState @cost(weight: "10")
ngt: BillOfMaterialsState @cost(weight: "10")
gte: BillOfMaterialsState @cost(weight: "10")
ngte: BillOfMaterialsState @cost(weight: "10")
lt: BillOfMaterialsState @cost(weight: "10")
nlt: BillOfMaterialsState @cost(weight: "10")
lte: BillOfMaterialsState @cost(weight: "10")
nlte: BillOfMaterialsState @cost(weight: "10")
}
input ComparableBooleanOperationFilterInput {
eq: Boolean @cost(weight: "10")
neq: Boolean @cost(weight: "10")
in: [Boolean!] @cost(weight: "10")
nin: [Boolean!] @cost(weight: "10")
gt: Boolean @cost(weight: "10")
ngt: Boolean @cost(weight: "10")
gte: Boolean @cost(weight: "10")
ngte: Boolean @cost(weight: "10")
lt: Boolean @cost(weight: "10")
nlt: Boolean @cost(weight: "10")
lte: Boolean @cost(weight: "10")
nlte: Boolean @cost(weight: "10")
}
input ComparableBuchungsArtKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableByteOperationFilterInput {
eq: Byte @cost(weight: "10")
neq: Byte @cost(weight: "10")
in: [Byte!] @cost(weight: "10")
nin: [Byte!] @cost(weight: "10")
gt: Byte @cost(weight: "10")
ngt: Byte @cost(weight: "10")
gte: Byte @cost(weight: "10")
ngte: Byte @cost(weight: "10")
lt: Byte @cost(weight: "10")
nlt: Byte @cost(weight: "10")
lte: Byte @cost(weight: "10")
nlte: Byte @cost(weight: "10")
}
input ComparableCustomFieldReferenceTypeOperationFilterInput {
eq: CustomFieldReferenceType @cost(weight: "10")
neq: CustomFieldReferenceType @cost(weight: "10")
in: [CustomFieldReferenceType!] @cost(weight: "10")
nin: [CustomFieldReferenceType!] @cost(weight: "10")
gt: CustomFieldReferenceType @cost(weight: "10")
ngt: CustomFieldReferenceType @cost(weight: "10")
gte: CustomFieldReferenceType @cost(weight: "10")
ngte: CustomFieldReferenceType @cost(weight: "10")
lt: CustomFieldReferenceType @cost(weight: "10")
nlt: CustomFieldReferenceType @cost(weight: "10")
lte: CustomFieldReferenceType @cost(weight: "10")
nlte: CustomFieldReferenceType @cost(weight: "10")
}
input ComparableCustomFieldTypeOperationFilterInput {
eq: CustomFieldType @cost(weight: "10")
neq: CustomFieldType @cost(weight: "10")
in: [CustomFieldType!] @cost(weight: "10")
nin: [CustomFieldType!] @cost(weight: "10")
gt: CustomFieldType @cost(weight: "10")
ngt: CustomFieldType @cost(weight: "10")
gte: CustomFieldType @cost(weight: "10")
ngte: CustomFieldType @cost(weight: "10")
lt: CustomFieldType @cost(weight: "10")
nlt: CustomFieldType @cost(weight: "10")
lte: CustomFieldType @cost(weight: "10")
nlte: CustomFieldType @cost(weight: "10")
}
input ComparableDateTimeOffsetOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime!] @cost(weight: "10")
nin: [DateTime!] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableDateTimeOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime!] @cost(weight: "10")
nin: [DateTime!] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableDecimalOperationFilterInput {
eq: Decimal @cost(weight: "10")
neq: Decimal @cost(weight: "10")
in: [Decimal!] @cost(weight: "10")
nin: [Decimal!] @cost(weight: "10")
gt: Decimal @cost(weight: "10")
ngt: Decimal @cost(weight: "10")
gte: Decimal @cost(weight: "10")
ngte: Decimal @cost(weight: "10")
lt: Decimal @cost(weight: "10")
nlt: Decimal @cost(weight: "10")
lte: Decimal @cost(weight: "10")
nlte: Decimal @cost(weight: "10")
}
input ComparableDeliveryCompleteStatusOperationFilterInput {
eq: DeliveryCompleteStatus @cost(weight: "10")
neq: DeliveryCompleteStatus @cost(weight: "10")
in: [DeliveryCompleteStatus!] @cost(weight: "10")
nin: [DeliveryCompleteStatus!] @cost(weight: "10")
gt: DeliveryCompleteStatus @cost(weight: "10")
ngt: DeliveryCompleteStatus @cost(weight: "10")
gte: DeliveryCompleteStatus @cost(weight: "10")
ngte: DeliveryCompleteStatus @cost(weight: "10")
lt: DeliveryCompleteStatus @cost(weight: "10")
nlt: DeliveryCompleteStatus @cost(weight: "10")
lte: DeliveryCompleteStatus @cost(weight: "10")
nlte: DeliveryCompleteStatus @cost(weight: "10")
}
input ComparableDeliveryStatusOperationFilterInput {
eq: DeliveryStatus @cost(weight: "10")
neq: DeliveryStatus @cost(weight: "10")
in: [DeliveryStatus!] @cost(weight: "10")
nin: [DeliveryStatus!] @cost(weight: "10")
gt: DeliveryStatus @cost(weight: "10")
ngt: DeliveryStatus @cost(weight: "10")
gte: DeliveryStatus @cost(weight: "10")
ngte: DeliveryStatus @cost(weight: "10")
lt: DeliveryStatus @cost(weight: "10")
nlt: DeliveryStatus @cost(weight: "10")
lte: DeliveryStatus @cost(weight: "10")
nlte: DeliveryStatus @cost(weight: "10")
}
input ComparableDispositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableEigenesFeldKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableExternalSalesInvoiceTypeOperationFilterInput {
eq: ExternalSalesInvoiceType @cost(weight: "10")
neq: ExternalSalesInvoiceType @cost(weight: "10")
in: [ExternalSalesInvoiceType!] @cost(weight: "10")
nin: [ExternalSalesInvoiceType!] @cost(weight: "10")
gt: ExternalSalesInvoiceType @cost(weight: "10")
ngt: ExternalSalesInvoiceType @cost(weight: "10")
gte: ExternalSalesInvoiceType @cost(weight: "10")
ngte: ExternalSalesInvoiceType @cost(weight: "10")
lt: ExternalSalesInvoiceType @cost(weight: "10")
nlt: ExternalSalesInvoiceType @cost(weight: "10")
lte: ExternalSalesInvoiceType @cost(weight: "10")
nlte: ExternalSalesInvoiceType @cost(weight: "10")
}
input ComparableExternerBelegKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableExternerBelegPositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableExternerBelegTransaktionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableFirmaKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableGutschriftKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableGutschriftPosKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableHerstellerKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableInt32OperationFilterInput {
eq: Int @cost(weight: "10")
neq: Int @cost(weight: "10")
in: [Int!] @cost(weight: "10")
nin: [Int!] @cost(weight: "10")
gt: Int @cost(weight: "10")
ngt: Int @cost(weight: "10")
gte: Int @cost(weight: "10")
ngte: Int @cost(weight: "10")
lt: Int @cost(weight: "10")
nlt: Int @cost(weight: "10")
lte: Int @cost(weight: "10")
nlte: Int @cost(weight: "10")
}
input ComparableInvoicePaymentStatusOperationFilterInput {
eq: InvoicePaymentStatus @cost(weight: "10")
neq: InvoicePaymentStatus @cost(weight: "10")
in: [InvoicePaymentStatus!] @cost(weight: "10")
nin: [InvoicePaymentStatus!] @cost(weight: "10")
gt: InvoicePaymentStatus @cost(weight: "10")
ngt: InvoicePaymentStatus @cost(weight: "10")
gte: InvoicePaymentStatus @cost(weight: "10")
ngte: InvoicePaymentStatus @cost(weight: "10")
lt: InvoicePaymentStatus @cost(weight: "10")
nlt: InvoicePaymentStatus @cost(weight: "10")
lte: InvoicePaymentStatus @cost(weight: "10")
nlte: InvoicePaymentStatus @cost(weight: "10")
}
input ComparableInvoiceStatusOperationFilterInput {
eq: InvoiceStatus @cost(weight: "10")
neq: InvoiceStatus @cost(weight: "10")
in: [InvoiceStatus!] @cost(weight: "10")
nin: [InvoiceStatus!] @cost(weight: "10")
gt: InvoiceStatus @cost(weight: "10")
ngt: InvoiceStatus @cost(weight: "10")
gte: InvoiceStatus @cost(weight: "10")
ngte: InvoiceStatus @cost(weight: "10")
lt: InvoiceStatus @cost(weight: "10")
nlt: InvoiceStatus @cost(weight: "10")
lte: InvoiceStatus @cost(weight: "10")
nlte: InvoiceStatus @cost(weight: "10")
}
input ComparableItemDescriptionTypeOperationFilterInput {
eq: ItemDescriptionType @cost(weight: "10")
neq: ItemDescriptionType @cost(weight: "10")
in: [ItemDescriptionType!] @cost(weight: "10")
nin: [ItemDescriptionType!] @cost(weight: "10")
gt: ItemDescriptionType @cost(weight: "10")
ngt: ItemDescriptionType @cost(weight: "10")
gte: ItemDescriptionType @cost(weight: "10")
ngte: ItemDescriptionType @cost(weight: "10")
lt: ItemDescriptionType @cost(weight: "10")
nlt: ItemDescriptionType @cost(weight: "10")
lte: ItemDescriptionType @cost(weight: "10")
nlte: ItemDescriptionType @cost(weight: "10")
}
input ComparableKategorieKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableKundeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableKundenGruppeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableKundenKategorieKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLhmKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLhmTypeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLieferantKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLieferantenArtikelKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLotSizeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLotTypeOperationFilterInput {
eq: LotType @cost(weight: "10")
neq: LotType @cost(weight: "10")
in: [LotType!] @cost(weight: "10")
nin: [LotType!] @cost(weight: "10")
gt: LotType @cost(weight: "10")
ngt: LotType @cost(weight: "10")
gte: LotType @cost(weight: "10")
ngte: LotType @cost(weight: "10")
lt: LotType @cost(weight: "10")
nlt: LotType @cost(weight: "10")
lte: LotType @cost(weight: "10")
nlte: LotType @cost(weight: "10")
}
input ComparableMarketplaceExternalDocumentTypeOperationFilterInput {
eq: MarketplaceExternalDocumentType @cost(weight: "10")
neq: MarketplaceExternalDocumentType @cost(weight: "10")
in: [MarketplaceExternalDocumentType!] @cost(weight: "10")
nin: [MarketplaceExternalDocumentType!] @cost(weight: "10")
gt: MarketplaceExternalDocumentType @cost(weight: "10")
ngt: MarketplaceExternalDocumentType @cost(weight: "10")
gte: MarketplaceExternalDocumentType @cost(weight: "10")
ngte: MarketplaceExternalDocumentType @cost(weight: "10")
lt: MarketplaceExternalDocumentType @cost(weight: "10")
nlt: MarketplaceExternalDocumentType @cost(weight: "10")
lte: MarketplaceExternalDocumentType @cost(weight: "10")
nlte: MarketplaceExternalDocumentType @cost(weight: "10")
}
input ComparableMarketplaceNotificationSeverityOperationFilterInput {
eq: MarketplaceNotificationSeverity @cost(weight: "10")
neq: MarketplaceNotificationSeverity @cost(weight: "10")
in: [MarketplaceNotificationSeverity!] @cost(weight: "10")
nin: [MarketplaceNotificationSeverity!] @cost(weight: "10")
gt: MarketplaceNotificationSeverity @cost(weight: "10")
ngt: MarketplaceNotificationSeverity @cost(weight: "10")
gte: MarketplaceNotificationSeverity @cost(weight: "10")
ngte: MarketplaceNotificationSeverity @cost(weight: "10")
lt: MarketplaceNotificationSeverity @cost(weight: "10")
nlt: MarketplaceNotificationSeverity @cost(weight: "10")
lte: MarketplaceNotificationSeverity @cost(weight: "10")
nlte: MarketplaceNotificationSeverity @cost(weight: "10")
}
input ComparableMarketplaceNotificationTypeOperationFilterInput {
eq: MarketplaceNotificationType @cost(weight: "10")
neq: MarketplaceNotificationType @cost(weight: "10")
in: [MarketplaceNotificationType!] @cost(weight: "10")
nin: [MarketplaceNotificationType!] @cost(weight: "10")
gt: MarketplaceNotificationType @cost(weight: "10")
ngt: MarketplaceNotificationType @cost(weight: "10")
gte: MarketplaceNotificationType @cost(weight: "10")
ngte: MarketplaceNotificationType @cost(weight: "10")
lt: MarketplaceNotificationType @cost(weight: "10")
nlt: MarketplaceNotificationType @cost(weight: "10")
lte: MarketplaceNotificationType @cost(weight: "10")
nlte: MarketplaceNotificationType @cost(weight: "10")
}
input ComparableMarketplaceOfferTypeOperationFilterInput {
eq: MarketplaceOfferType @cost(weight: "10")
neq: MarketplaceOfferType @cost(weight: "10")
in: [MarketplaceOfferType!] @cost(weight: "10")
nin: [MarketplaceOfferType!] @cost(weight: "10")
gt: MarketplaceOfferType @cost(weight: "10")
ngt: MarketplaceOfferType @cost(weight: "10")
gte: MarketplaceOfferType @cost(weight: "10")
ngte: MarketplaceOfferType @cost(weight: "10")
lt: MarketplaceOfferType @cost(weight: "10")
nlt: MarketplaceOfferType @cost(weight: "10")
lte: MarketplaceOfferType @cost(weight: "10")
nlte: MarketplaceOfferType @cost(weight: "10")
}
input ComparableMarketplaceOfferViewStatusOperationFilterInput {
eq: MarketplaceOfferViewStatus @cost(weight: "10")
neq: MarketplaceOfferViewStatus @cost(weight: "10")
in: [MarketplaceOfferViewStatus!] @cost(weight: "10")
nin: [MarketplaceOfferViewStatus!] @cost(weight: "10")
gt: MarketplaceOfferViewStatus @cost(weight: "10")
ngt: MarketplaceOfferViewStatus @cost(weight: "10")
gte: MarketplaceOfferViewStatus @cost(weight: "10")
ngte: MarketplaceOfferViewStatus @cost(weight: "10")
lt: MarketplaceOfferViewStatus @cost(weight: "10")
nlt: MarketplaceOfferViewStatus @cost(weight: "10")
lte: MarketplaceOfferViewStatus @cost(weight: "10")
nlte: MarketplaceOfferViewStatus @cost(weight: "10")
}
input ComparableMarketplaceOrderCancellationRequestUploadStatusOperationFilterInput {
eq: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
neq: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
in: [MarketplaceOrderCancellationRequestUploadStatus!] @cost(weight: "10")
nin: [MarketplaceOrderCancellationRequestUploadStatus!] @cost(weight: "10")
gt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
ngt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
gte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
ngte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
lt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
nlt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
lte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
nlte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceOrderCancellationUploadStatusOperationFilterInput {
eq: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
neq: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
in: [MarketplaceOrderCancellationUploadStatus!] @cost(weight: "10")
nin: [MarketplaceOrderCancellationUploadStatus!] @cost(weight: "10")
gt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
ngt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
gte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
ngte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
lt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
nlt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
lte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
nlte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
}
input ComparableMarketplacePaymentUploadStatusOperationFilterInput {
eq: MarketplacePaymentUploadStatus @cost(weight: "10")
neq: MarketplacePaymentUploadStatus @cost(weight: "10")
in: [MarketplacePaymentUploadStatus!] @cost(weight: "10")
nin: [MarketplacePaymentUploadStatus!] @cost(weight: "10")
gt: MarketplacePaymentUploadStatus @cost(weight: "10")
ngt: MarketplacePaymentUploadStatus @cost(weight: "10")
gte: MarketplacePaymentUploadStatus @cost(weight: "10")
ngte: MarketplacePaymentUploadStatus @cost(weight: "10")
lt: MarketplacePaymentUploadStatus @cost(weight: "10")
nlt: MarketplacePaymentUploadStatus @cost(weight: "10")
lte: MarketplacePaymentUploadStatus @cost(weight: "10")
nlte: MarketplacePaymentUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceReturnUploadStatusOperationFilterInput {
eq: MarketplaceReturnUploadStatus @cost(weight: "10")
neq: MarketplaceReturnUploadStatus @cost(weight: "10")
in: [MarketplaceReturnUploadStatus!] @cost(weight: "10")
nin: [MarketplaceReturnUploadStatus!] @cost(weight: "10")
gt: MarketplaceReturnUploadStatus @cost(weight: "10")
ngt: MarketplaceReturnUploadStatus @cost(weight: "10")
gte: MarketplaceReturnUploadStatus @cost(weight: "10")
ngte: MarketplaceReturnUploadStatus @cost(weight: "10")
lt: MarketplaceReturnUploadStatus @cost(weight: "10")
nlt: MarketplaceReturnUploadStatus @cost(weight: "10")
lte: MarketplaceReturnUploadStatus @cost(weight: "10")
nlte: MarketplaceReturnUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceShippingInformationUploadStatusOperationFilterInput {
eq: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
neq: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
in: [MarketplaceShippingInformationUploadStatus!] @cost(weight: "10")
nin: [MarketplaceShippingInformationUploadStatus!] @cost(weight: "10")
gt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
ngt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
gte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
ngte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
lt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
nlt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
lte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
nlte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
}
input ComparableNullableOfByteOperationFilterInput {
eq: Byte @cost(weight: "10")
neq: Byte @cost(weight: "10")
in: [Byte] @cost(weight: "10")
nin: [Byte] @cost(weight: "10")
gt: Byte @cost(weight: "10")
ngt: Byte @cost(weight: "10")
gte: Byte @cost(weight: "10")
ngte: Byte @cost(weight: "10")
lt: Byte @cost(weight: "10")
nlt: Byte @cost(weight: "10")
lte: Byte @cost(weight: "10")
nlte: Byte @cost(weight: "10")
}
input ComparableNullableOfDateTimeOffsetOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime] @cost(weight: "10")
nin: [DateTime] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableNullableOfDateTimeOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime] @cost(weight: "10")
nin: [DateTime] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableNullableOfDecimalOperationFilterInput {
eq: Decimal @cost(weight: "10")
neq: Decimal @cost(weight: "10")
in: [Decimal] @cost(weight: "10")
nin: [Decimal] @cost(weight: "10")
gt: Decimal @cost(weight: "10")
ngt: Decimal @cost(weight: "10")
gte: Decimal @cost(weight: "10")
ngte: Decimal @cost(weight: "10")
lt: Decimal @cost(weight: "10")
nlt: Decimal @cost(weight: "10")
lte: Decimal @cost(weight: "10")
nlte: Decimal @cost(weight: "10")
}
input ComparableNullableOfInt32OperationFilterInput {
eq: Int @cost(weight: "10")
neq: Int @cost(weight: "10")
in: [Int] @cost(weight: "10")
nin: [Int] @cost(weight: "10")
gt: Int @cost(weight: "10")
ngt: Int @cost(weight: "10")
gte: Int @cost(weight: "10")
ngte: Int @cost(weight: "10")
lt: Int @cost(weight: "10")
nlt: Int @cost(weight: "10")
lte: Int @cost(weight: "10")
nlte: Int @cost(weight: "10")
}
input ComparableNullableOfTaxSettingOperationFilterInput {
eq: TaxSetting @cost(weight: "10")
neq: TaxSetting @cost(weight: "10")
in: [TaxSetting] @cost(weight: "10")
nin: [TaxSetting] @cost(weight: "10")
gt: TaxSetting @cost(weight: "10")
ngt: TaxSetting @cost(weight: "10")
gte: TaxSetting @cost(weight: "10")
ngte: TaxSetting @cost(weight: "10")
lt: TaxSetting @cost(weight: "10")
nlt: TaxSetting @cost(weight: "10")
lte: TaxSetting @cost(weight: "10")
nlte: TaxSetting @cost(weight: "10")
}
input ComparableNullableOfTimeSpanOperationFilterInput {
eq: TimeSpan @cost(weight: "10")
neq: TimeSpan @cost(weight: "10")
in: [TimeSpan] @cost(weight: "10")
nin: [TimeSpan] @cost(weight: "10")
gt: TimeSpan @cost(weight: "10")
ngt: TimeSpan @cost(weight: "10")
gte: TimeSpan @cost(weight: "10")
ngte: TimeSpan @cost(weight: "10")
lt: TimeSpan @cost(weight: "10")
nlt: TimeSpan @cost(weight: "10")
lte: TimeSpan @cost(weight: "10")
nlte: TimeSpan @cost(weight: "10")
}
input ComparableOverallComponentPostingsInventoryAccountingDataRequirementsOperationFilterInput {
eq: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
neq: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
in: [OverallComponentPostingsInventoryAccountingDataRequirements!] @cost(weight: "10")
nin: [OverallComponentPostingsInventoryAccountingDataRequirements!] @cost(weight: "10")
gt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
ngt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
gte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
ngte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
lt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
nlt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
lte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
nlte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
}
input ComparablePlattformKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableProdItemKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableProductionOrderKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableProductionTypeOperationFilterInput {
eq: ProductionType @cost(weight: "10")
neq: ProductionType @cost(weight: "10")
in: [ProductionType!] @cost(weight: "10")
nin: [ProductionType!] @cost(weight: "10")
gt: ProductionType @cost(weight: "10")
ngt: ProductionType @cost(weight: "10")
gte: ProductionType @cost(weight: "10")
ngte: ProductionType @cost(weight: "10")
lt: ProductionType @cost(weight: "10")
nlt: ProductionType @cost(weight: "10")
lte: ProductionType @cost(weight: "10")
nlte: ProductionType @cost(weight: "10")
}
input ComparableReadOnlyTypeOperationFilterInput {
eq: ReadOnlyType @cost(weight: "10")
neq: ReadOnlyType @cost(weight: "10")
in: [ReadOnlyType!] @cost(weight: "10")
nin: [ReadOnlyType!] @cost(weight: "10")
gt: ReadOnlyType @cost(weight: "10")
ngt: ReadOnlyType @cost(weight: "10")
gte: ReadOnlyType @cost(weight: "10")
ngte: ReadOnlyType @cost(weight: "10")
lt: ReadOnlyType @cost(weight: "10")
nlt: ReadOnlyType @cost(weight: "10")
lte: ReadOnlyType @cost(weight: "10")
nlte: ReadOnlyType @cost(weight: "10")
}
input ComparableRechnungKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableRechnungPositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableRechnungStornogrundKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableResourceCategoryKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableResourceTypeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableRueckhaltegrundKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSalesInvoiceTaxSettingOperationFilterInput {
eq: SalesInvoiceTaxSetting @cost(weight: "10")
neq: SalesInvoiceTaxSetting @cost(weight: "10")
in: [SalesInvoiceTaxSetting!] @cost(weight: "10")
nin: [SalesInvoiceTaxSetting!] @cost(weight: "10")
gt: SalesInvoiceTaxSetting @cost(weight: "10")
ngt: SalesInvoiceTaxSetting @cost(weight: "10")
gte: SalesInvoiceTaxSetting @cost(weight: "10")
ngte: SalesInvoiceTaxSetting @cost(weight: "10")
lt: SalesInvoiceTaxSetting @cost(weight: "10")
nlt: SalesInvoiceTaxSetting @cost(weight: "10")
lte: SalesInvoiceTaxSetting @cost(weight: "10")
nlte: SalesInvoiceTaxSetting @cost(weight: "10")
}
input ComparableScxChannelKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableScxShopKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSerialNumberTrackingModeOperationFilterInput {
eq: SerialNumberTrackingMode @cost(weight: "10")
neq: SerialNumberTrackingMode @cost(weight: "10")
in: [SerialNumberTrackingMode!] @cost(weight: "10")
nin: [SerialNumberTrackingMode!] @cost(weight: "10")
gt: SerialNumberTrackingMode @cost(weight: "10")
ngt: SerialNumberTrackingMode @cost(weight: "10")
gte: SerialNumberTrackingMode @cost(weight: "10")
ngte: SerialNumberTrackingMode @cost(weight: "10")
lt: SerialNumberTrackingMode @cost(weight: "10")
nlt: SerialNumberTrackingMode @cost(weight: "10")
lte: SerialNumberTrackingMode @cost(weight: "10")
nlte: SerialNumberTrackingMode @cost(weight: "10")
}
input ComparableShelfLifeEndDateGenerationModeOperationFilterInput {
eq: ShelfLifeEndDateGenerationMode @cost(weight: "10")
neq: ShelfLifeEndDateGenerationMode @cost(weight: "10")
in: [ShelfLifeEndDateGenerationMode!] @cost(weight: "10")
nin: [ShelfLifeEndDateGenerationMode!] @cost(weight: "10")
gt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
ngt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
gte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
ngte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
lt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
nlt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
lte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
nlte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
}
input ComparableShopKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSpracheKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSteuerklasseKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSteuerschluesselKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableTaxTypeOperationFilterInput {
eq: TaxType @cost(weight: "10")
neq: TaxType @cost(weight: "10")
in: [TaxType!] @cost(weight: "10")
nin: [TaxType!] @cost(weight: "10")
gt: TaxType @cost(weight: "10")
ngt: TaxType @cost(weight: "10")
gte: TaxType @cost(weight: "10")
ngte: TaxType @cost(weight: "10")
lt: TaxType @cost(weight: "10")
nlt: TaxType @cost(weight: "10")
lte: TaxType @cost(weight: "10")
nlte: TaxType @cost(weight: "10")
}
input ComparableVerkaufAuftragKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVerkaufAuftragPositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVersandartKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVersandklasseKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVorlagenSetKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWaehrungKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenLagerBereichKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenLagerEingangKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenLagerPlatzKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarengruppeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenlagerKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWorkbenchResourceKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableZahlungsartKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableZustandKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
"- Request"
input CopyItemdetailsCommandRequestInput {
"The unique identifier of the source itemdetails to be copied."
copyDetailsFromItemId: ID!
"Transfer the itemdetails into the items identified by these unique identifiers."
copyDetailsIntoItemIds: [ID]!
"Specifies which properties and aspects of the source item should be duplicated to the new items."
copyOptions: CreateItemdetailsCopyOptionsInput!
}
"Definition of a country item"
input CountryItemFilterInput {
and: [CountryItemFilterInput!]
or: [CountryItemFilterInput!]
"The ISO code of the country"
countryIso: StringOperationFilterInput
"The name of the country"
name: StringOperationFilterInput
"The numeric ISO code of the country"
numericIso: ComparableInt32OperationFilterInput
"Indicates if the country is part of the European Union"
isEu: ComparableBooleanOperationFilterInput
"The continent of the country"
continent: StringOperationFilterInput
}
"Definition of a country item"
input CountryItemSortInput {
"The ISO code of the country"
countryIso: SortEnumType @cost(weight: "10")
"The name of the country"
name: SortEnumType @cost(weight: "10")
"The numeric ISO code of the country"
numericIso: SortEnumType @cost(weight: "10")
"The continent of the country"
continent: SortEnumType @cost(weight: "10")
"The ISO code of the currency used in the country"
currencyIso: SortEnumType @cost(weight: "10")
}
input CreateAttributeSalesChannelValuesInput {
"Identifies the saleschannel for this attributevalue"
salesChannelId: ID!
"Contains the values for a saleschannel"
values: [CreateAttributeValueInput]
}
input CreateAttributeValueInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Value of this attribute as string. Please consider the Attribute Type for correct formatting."
value: String!
}
input CreateAttributeValuesInput {
"Identifies the attribute"
attributeId: ID!
"Defines the default values for the attribute and item in different languages."
defaultValues: [CreateAttributeValueInput]
"Contains all values for saleschannels for this attribute and item"
salesChannelValues: [CreateAttributeSalesChannelValuesInput]
}
"Options for copying item attributes."
input CreateAttributesCopyOptionsInput {
"Indicates whether attributes should be copied."
isActive: Boolean!
"Specifies whether to replace existing attributes or attach\/merge new attributes with existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating item attributes."
input CreateAttributesDuplicationOptionsInput {
"Indicates whether item attributes should be duplicated."
isActive: Boolean
}
"Creates a new bill of materials for a production item, including its components. - Request"
input CreateBillOfMaterialsCommandRequestInput {
"The ID of the production item for which the bill of materials is to be created."
productionItemId: ID!
"The input for creating a bill of materials as part of a production item."
input: CreateBillOfMaterialsInput!
}
"Represents the input for creating a bill of materials as part of a production item."
input CreateBillOfMaterialsInput {
"The name of the bill of materials."
name: String!
"An optional description of the bill of materials."
description: String
"Requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This requirement can be overridden for individual components. Optional; defaults to None. Must not be set to a value other than None if no component's underlying item has a shelf life end date configured."
componentPostingsShelfLifeEndDateRequirements: CreateOverallComponentPostingsInventoryAccountingDataRequirements
"Requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This requirement can be overridden for individual components. Optional; defaults to None. Must not be set to a value other than None if no component's underlying item has a batch number configured."
componentPostingsBatchNumberRequirements: CreateOverallComponentPostingsInventoryAccountingDataRequirements
"Indicates how the shelf life end date of the produced item is calculated after completing a lot."
shelfLifeEndDateGenerationMode: CreateShelfLifeEndDateGenerationMode
"A time span that is added when calculating the shelf life end date of the produced item after completing a lot. Required when ShelfLifeEndDateGenerationMode is ProductionDate; optional when ShelfLifeEndDateGenerationMode is Earliest or Latest; is ignored when ShelfLifeEndDateGenerationMode is not specified."
additionalShelfLifeEndDateTime: TimeSpan
"The operations of this bill of materials. At least one operation is required, and across all operations at least one item must be present."
operations: [CreateBillOfMaterialsOperationInput!]!
}
"Creates a new bill of materials item for a bill of materials operation. - Request"
input CreateBillOfMaterialsItemCommandRequestInput {
"The ID of the production item."
productionItemId: ID!
"The ID of the bill of materials."
billOfMaterialsId: ID!
"The ID of the bill of materials operation."
billOfMaterialsOperationId: ID!
"The input for creating a bill of materials item."
input: CreateBillOfMaterialsItemInput!
}
"Represents the input for creating a bill of materials item as part of a bill of materials operation."
input CreateBillOfMaterialsItemInput {
"The ID of the item to be used as a bill of materials item."
itemId: ID!
"The required quantity of this component for the production of the production item. Must be greater than zero."
quantity: Decimal!
"The ID of the measurement unit in which the quantity is managed, or NULL to use the sales unit of the underlying item."
measurementUnitId: ID
"Requirements for the production input of this component regarding the shelf life end dates of the stock accounts to be debited. Overrides the corresponding setting on the bill of materials level for this component. Optional; defaults to Inherited, which applies the requirement specified at the bill of materials level. Must not be set to a value other than Inherited if the underlying item does not have a shelf life end date configured."
componentPostingsShelfLifeEndDateRequirements: CreateComponentPostingsInventoryAccountingDataRequirements
"Requirements for the production input of this component regarding the batch numbers of the stock accounts to be debited. Overrides the corresponding setting on the bill of materials level for this component. Optional; defaults to Inherited, which applies the requirement specified at the bill of materials level. Must not be set to a value other than Inherited if the underlying item does not have a batch number configured."
componentPostingsBatchNumberRequirements: CreateComponentPostingsInventoryAccountingDataRequirements
}
"Creates a new bill of materials operation for a bill of materials, including its items. - Request"
input CreateBillOfMaterialsOperationCommandRequestInput {
"The ID of the production item."
productionItemId: ID!
"The ID of the bill of materials."
billOfMaterialsId: ID!
"The input for creating a bill of materials operation."
input: CreateBillOfMaterialsOperationInput!
}
"Represents the input for creating a bill of materials operation as part of a new bill of materials."
input CreateBillOfMaterialsOperationInput {
"The ID of the operation to be assigned to this bill of materials operation. The operation must exist."
operationId: ID!
"The bill of materials items assigned to this operation. Optional per individual operation, but at least one component must be present across all operations within the bill of materials."
items: [CreateBillOfMaterialsItemInput]
}
"Creates a new bin location in a warehouse. - Request"
input CreateBinLocationCommandRequestInput {
"Warehouse where the bin location should be created."
warehouseId: ID!
"Name of the bin location (must be unique within the warehouse, max 50 chars, no apostrophes)."
name: String!
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: Int!
"Optional sort order."
sort: Int
}
"Options for copying bill of materials (BOM) components."
input CreateBomComponentsCopyOptionsInput {
"Indicates whether BOM components should be copied."
isActive: Boolean!
"Specifies whether to replace all existing BOM components or attach\/add new components to the existing BOM structure."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating bill of materials components."
input CreateBomDuplicationOptionsInput {
"Indicates whether bill of materials components should be duplicated."
isActive: Boolean
}
"Address information for sales order calculation (tax determination)."
input CreateCalculateSalesOrderAddressInput {
"The ISO code of the address country for tax calculation."
countryIso: String!
"The state of the address for tax calculation."
state: String
"The VAT ID of the address for tax calculation."
vatId: String
}
"Represents a change to apply to an existing line item."
input CreateCalculateSalesOrderLineItemRequestChangeInput {
"The synchronization identifier for the line item to update."
syncNumber: Int!
"The quantity of the item."
quantity: Decimal
"Manual override for the net sales price per unit. Cannot be set simultaneously with SalesPriceGross."
salesPriceNet: Decimal
"Manual override for the gross sales price per unit. When set, the net price is recalculated. Cannot be set simultaneously with SalesPriceNet."
salesPriceGross: Decimal
"The discount percentage for the line item (e.g., 10.0 for 10% discount)."
discountPercent: Decimal
"The tax class identifier for this line item. If set, overrides the automatically determined tax class."
taxClassId: ID
}
"Represents a set of changes to apply to line items."
input CreateCalculateSalesOrderLineItemRequestChangeSetInput {
"The list of new line items to create."
create: [CreateCalculateSalesOrderLineItemRequestInput]
"The list of existing line items to update."
update: [CreateCalculateSalesOrderLineItemRequestChangeInput]
"The list of sync numbers of line items to delete."
delete: [Int!]
}
"Request model for a sales order line item calculation."
input CreateCalculateSalesOrderLineItemRequestInput {
"The synchronization identifier for the line item. Must be unique and greater than 0. This ID is assigned by the client and remains constant."
syncNumber: Int!
"The unique identifier of the item\/article. If omitted, a free-text position is created."
itemId: ID
"The quantity of the item. Must be greater than 0."
quantity: Decimal!
"Manual override for the net sales price per unit. If set, overrides the calculated price. Cannot be set simultaneously with SalesPriceGross."
salesPriceNet: Decimal
"Manual override for the gross sales price per unit. When set, the net price is recalculated. Cannot be set simultaneously with SalesPriceNet."
salesPriceGross: Decimal
"The discount percentage for the line item (e.g., 10.0 for 10% discount)."
discountPercent: Decimal
"The tax class identifier for this line item. If set, overrides the automatically determined tax class."
taxClassId: ID
"The SyncNumber of the parent line item. Used to assign configuration components to their parent configuration item."
parentSyncNumber: Int
}
"Represents a change to apply to the sales order calculation request."
input CreateCalculateSalesOrderRequestChangeInput {
"The company ID to use for the calculation."
companyId: ID
"The customer ID to use for the calculation."
customerId: ID
"The shipping method ID to use for the calculation."
shippingMethodId: ID
"The billing address information for tax calculation."
billingAddress: CreateCalculateSalesOrderAddressInput
"The shipment address information for tax calculation."
shipmentAddress: CreateCalculateSalesOrderAddressInput
"The line item changes to apply."
lineItemChanges: CreateCalculateSalesOrderLineItemRequestChangeSetInput
"The ISO code of the currency for price calculation."
currencyIso: String
"Manual override for the currency conversion factor."
currencyFactor: Decimal
"The ISO code of the departure country for tax calculation."
departureCountryIso: String
"The departure country state\/region code for state-level tax calculation."
departureCountryStateCode: String
"Additional weight in kg to add to the order for shipping cost calculation."
extraWeight: Decimal
"The tax special treatment mode for the sales order."
specialTaxTreatment: SpecialTaxTreatment
"The tax reference of the sales order. This setting controls which data is used during tax calculation."
taxReference: TaxReference
}
"Request model for calculating prices, discounts, taxes, and shipping costs for a sales order."
input CreateCalculateSalesOrderRequestInput {
"The unique identifier of the company for the sales order."
companyId: ID!
"The unique identifier of the customer for whom the sales order is being calculated."
customerId: ID!
"The shipping method ID for shipping cost calculation and tax determination."
shippingMethodId: ID
"The shop ID for shop-specific price calculation."
shopId: ID
"The billing address information for tax calculation."
billingAddress: CreateCalculateSalesOrderAddressInput
"The shipment address information for tax calculation."
shipmentAddress: CreateCalculateSalesOrderAddressInput
"The list of sales order line items to be calculated."
lineItems: [CreateCalculateSalesOrderLineItemRequestInput!]!
"The ISO code of the currency for price calculation (e.g., EUR, USD). If not specified, the default currency will be used."
currencyIso: String
"Manual override for the currency conversion factor. If set (greater than 0), overrides the default factor from the currency settings."
currencyFactor: Decimal
"The ISO code of the departure country for tax calculation."
departureCountryIso: String!
"The departure country state\/region code for state-level tax calculation (e.g., US states like CA, NY)."
departureCountryStateCode: String
"Additional weight in kg to add to the order for shipping cost calculation."
extraWeight: Decimal
"The tax special treatment mode for the sales order (e.g., ReverseCharge, TaxExempt)."
specialTaxTreatment: SpecialTaxTreatment
"The tax reference of the sales order. This setting controls which data is used during tax calculation."
taxReference: TaxReference
}
"Creates a new Category. - Request"
input CreateCategoryCommandRequestInput {
"The parent category of the category."
parentId: ID
"The sort number of the category."
sortNumber: Int
"The category name."
name: String!
}
"Options for copying item characteristics (Merkmale)."
input CreateCharacteristicsCopyOptionsInput {
"Indicates whether characteristics should be copied."
isActive: Boolean!
"Specifies whether to replace all existing characteristics or attach\/add new characteristics to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating item characteristics."
input CreateCharacteristicsDuplicationOptionsInput {
"Indicates whether item characteristics should be duplicated."
isActive: Boolean
}
"Options for copying item configurations."
input CreateConfigurationsCopyOptionsInput {
"Indicates whether configurations should be copied."
isActive: Boolean!
"Specifies whether to replace all existing configurations or attach\/add new configurations to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating configurations."
input CreateConfigurationsDuplicationOptionsInput {
"Indicates whether configurations should be duplicated."
isActive: Boolean
}
input CreateCreateCustomerAddressInput {
"Name of the street (including number)."
street: String!
"Additional address information."
additionalAddressLine: String
"City name of the customer."
city: String!
"Postal code of the customer."
postalCode: String
"Name of the state."
state: String
"ISO code of the country (2 letters)."
countryIso: String!
"The customers email address."
emailAddress: String
"The customers phone number."
phoneNumber: String
"The customers mobile phone number."
mobilePhoneNumber: String
"The customers fax number."
faxNumber: String
"The customers VAT ID."
vatId: String
"The customers salutation (e.g. Mr., Mrs., etc.)"
salutation: String
"The customers title (e.g. Dr., Prof., etc.)"
title: String
"The customers first name"
firstName: String
"The customers last name"
lastName: String
"The customers company name"
companyName: String
"The customers company additional line"
additionalCompanyLine: String
}
input CreateCreateCustomerPaymentSettingsInput {
"The customers credit limit."
creditLimit: Int
"Payment target (in days)."
paymentDueDateInDays: Int
"The customers discount percentage."
discount: Decimal
"Whether the customer is blocked for dunning notices."
isDunningBlocked: Boolean
}
"Address details for the sales order."
input CreateCreateSalesOrderAddressInput {
"The SalesOrderAddress Salutation"
salutation: String
"The SalesOrderAddress Title"
title: String
"The SalesOrderAddress FirstName"
firstName: String
"The SalesOrderAddress LastName"
lastName: String
"The SalesOrderAddress Company"
company: String
"The SalesOrderAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesOrderAddress Street"
street: String!
"The SalesOrderAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesOrderAddress City"
city: String!
"The SalesOrderAddress PostalCode"
postalCode: String
"The SalesOrderAddress State"
state: String
"The SalesOrderAddress CountryISO"
countryIso: String!
"The SalesOrderAddress PostId"
postId: String
"The SalesOrderAddress EmailAddress"
emailAddress: String
"The SalesOrderAddress PhoneNumber"
phoneNumber: String
"The SalesOrderAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesOrderAddress Fax"
fax: String
"The SalesOrderAddress VAT ID"
vatId: String
}
"Defines the departure country information for a sales order during its creation."
input CreateCreateSalesOrderDepartureCountryInput {
"The ISO code of the departure country."
countryIso: String!
"The sales order departure country currency iso"
currencyIso: String!
"The sales order departure country currency factor"
currencyFactor: Decimal
"The SalesOrder State"
state: String
}
"External details for the sales order."
input CreateCreateSalesOrderExternalDetailsInput {
"The SalesOrder ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType
"The SalesOrder ExternalSalesOrderNumber"
externalSalesOrderNumber: String
}
"Line item details for the new sales order."
input CreateCreateSalesOrderLineItemInput {
"Unique ID to identify an item."
itemId: ID
"The SalesOrderLineItem ParentSalesOrderLineItemId"
parentSalesOrderLineItemId: ID
"The SalesOrderLineItem TaxClassId"
taxClassId: ID
"The SalesOrderLineItem TaxCodeId"
taxCodeId: ID
"The SalesOrderLineItem BillOfMaterialsType"
billOfMaterialsType: BillOfMaterialsType
"The SalesOrderLineItem ConfigurationItemType"
configurationItemType: ConfigurationItemType
"The discount of the line item."
discountPercent: Decimal
"The SalesOrderLineItem FNSKU"
fnSku: String
"Name of the position."
name: String
"The SalesOrderLineItem Note"
note: String
"The purchase price of the item."
purchasePriceNet: Decimal
"The quantity of the line item."
quantity: Decimal
"The net sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales order line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesOrderLineItem LineItemType"
type: LineItemType
"List of SalesOrderLineItemVariant"
variants: [CreateCreateSalesOrderLineItemVariantInput]
}
"Sales order line item variant details."
input CreateCreateSalesOrderLineItemVariantInput {
"The SalesOrderLineItemVariant ExtraWeight"
extraWeight: Decimal
"The SalesOrderLineItemVariant Name"
name: String!
"The SalesOrderLineItemVariant SurchargeNet"
surchargeNet: Decimal
"The SalesOrderLineItemVariant Value"
value: String
"The SalesOrderLineItemVariant ItemVariantId"
itemVariantId: ID!
"The SalesOrderLineItemVariant ItemVariantValueId"
itemVariantValueId: ID
}
"Payment details for the new sales order."
input CreateCreateSalesOrderPaymentDetailsInput {
"The SalesOrder CashDiscount"
cashDiscount: Decimal
"The SalesOrder CashDiscountDays"
cashDiscountDays: Int
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int
"The sales order departure country currency iso"
currencyIso: String!
"The sales order departure country currency factor"
currencyFactor: Decimal
}
"Payment info for the new sales order."
input CreateCreateSalesOrderPaymentInfoInput {
"The SalesOrderPaymentInfo AccountHolder"
accountHolder: String
"The SalesOrderPaymentInfo BankName"
bankName: String
"The SalesOrderPaymentInfo BIC"
bic: String
"The SalesOrderPaymentInfo CreditorId"
creditorId: String
"The SalesOrderPaymentInfo DueDate"
dueDate: DateTime
"The SalesOrderPaymentInfo EndToEndId"
endToEndId: String
"The SalesOrderPaymentInfo IBAN"
iban: String
"The SalesOrderPaymentInfo MandateReference"
mandateReference: String
"The SalesOrderPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesOrderPaymentInfo PaymentReference"
paymentReference: String
"The SalesOrderPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for the new sales order."
input CreateCreateSalesOrderShippingDetailsInput {
"The SalesOrder DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesOrder EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesOrder ExtraWeight"
extraWeight: Decimal
"The SalesOrder MaxDeliveryDays"
maxDeliveryDays: Int
"The SalesOrder ShippingDate"
shippingDate: DateTime
"The SalesOrder ShippingPriority"
shippingPriority: Int
}
"Tax details for the new sales order."
input CreateCreateSalesOrderTaxDetailsInput {
"The SalesOrder TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference
"The SalesOrder SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment
"The SalesOrder TaxSetting"
taxSetting: TaxSetting
}
"Tax details for the new sales order."
input CreateCreateSalesOrderTextInput {
"The SalesOrderText Comment"
comment: String
"The SalesOrderText CustomerComment"
customerComment: String
"The SalesOrderText PrintText"
printText: String
"The SalesOrderText ProcessStatus"
processStatus: String
}
"Billing address details for the sales quotation."
input CreateCreateSalesQuotationAddressInput {
"The SalesQuotationAddress Salutation"
salutation: String
"The SalesQuotationAddress Title"
title: String
"The SalesQuotationAddress FirstName"
firstName: String
"The SalesQuotationAddress LastName"
lastName: String
"The SalesQuotationAddress Company"
company: String
"The SalesQuotationAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesQuotationAddress Street"
street: String!
"The SalesQuotationAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesQuotationAddress City"
city: String!
"The SalesQuotationAddress PostalCode"
postalCode: String
"The SalesQuotationAddress State"
state: String
"The SalesQuotationAddress CountryISO"
countryIso: String!
"The SalesQuotationAddress PostId"
postId: String
"The SalesQuotationAddress EmailAddress"
emailAddress: String
"The SalesQuotationAddress PhoneNumber"
phoneNumber: String
"The SalesQuotationAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesQuotationAddress Fax"
fax: String
}
"Defines the departure country information for a sales quotation during its creation."
input CreateCreateSalesQuotationDepartureCountryInput {
"The ISO code of the departure country."
countryIso: String!
"The sales quotation departure country currency iso"
currencyIso: String!
"The sales quotation departure country currency factor"
currencyFactor: Decimal
"The SalesQuotation State"
state: String
}
"External details for the sales quotation."
input CreateCreateSalesQuotationExternalDetailsInput {
"The SalesQuotation ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesQuotation ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType
"The SalesQuotation ExternalSalesQuotationNumber"
externalSalesQuotationNumber: String
}
"Line item details for the new sales quotation."
input CreateCreateSalesQuotationLineItemInput {
"Unique ID to identify an item."
itemId: ID
"The SalesQuotationLineItem ParentSalesQuotationLineItemId"
parentSalesQuotationLineItemId: ID
"The SalesQuotationLineItem TaxClassId"
taxClassId: ID
"The SalesQuotationLineItem TaxCodeId"
taxCodeId: ID
"The SalesQuotationLineItem BillOfMaterialsType"
billOfMaterialsType: BillOfMaterialsType
"The SalesQuotationLineItem ConfigurationItemType"
configurationItemType: ConfigurationItemType
"The discount of the line item."
discountPercent: Decimal
"The SalesQuotationLineItem FNSKU"
fnSku: String
"Name of the position."
name: String
"The SalesQuotationLineItem Note"
note: String
"The purchase price of the item."
purchasePriceNet: Decimal
"The quantity of the line item."
quantity: Decimal
"The net sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales quotation line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesQuotationLineItem LineItemType"
type: LineItemType
"List of SalesQuotationLineItemVariant"
variants: [CreateCreateSalesQuotationLineItemVariantInput]
}
"Sales quotation line item variant details."
input CreateCreateSalesQuotationLineItemVariantInput {
"The SalesQuotationLineItemVariant ExtraWeight"
extraWeight: Decimal
"The SalesQuotationLineItemVariant Name"
name: String!
"The SalesQuotationLineItemVariant SurchargeNet"
surchargeNet: Decimal
"The SalesQuotationLineItemVariant Value"
value: String
"The SalesQuotationLineItemVariant ItemVariantId"
itemVariantId: ID!
"The SalesQuotationLineItemVariant ItemVariantValueId"
itemVariantValueId: ID
}
"Payment details for the new sales quotation."
input CreateCreateSalesQuotationPaymentDetailsInput {
"The SalesQuotation CashDiscount"
cashDiscount: Decimal
"The SalesQuotation CashDiscountDays"
cashDiscountDays: Int
"The SalesQuotation FinancingCosts"
financingCosts: Decimal
"The SalesQuotation PaymentDueDateInDays"
paymentDueDateInDays: Int
"The sales quotation departure country currency iso"
currencyIso: String!
"The sales quotation departure country currency factor"
currencyFactor: Decimal
}
"Payment info for the new sales quotation."
input CreateCreateSalesQuotationPaymentInfoInput {
"The SalesQuotationPaymentInfo AccountHolder"
accountHolder: String
"The SalesQuotationPaymentInfo BankName"
bankName: String
"The SalesQuotationPaymentInfo BIC"
bic: String
"The SalesQuotationPaymentInfo CreditorId"
creditorId: String
"The SalesQuotationPaymentInfo DueDate"
dueDate: DateTime
"The SalesQuotationPaymentInfo EndToEndId"
endToEndId: String
"The SalesQuotationPaymentInfo IBAN"
iban: String
"The SalesQuotationPaymentInfo MandateReference"
mandateReference: String
"The SalesQuotationPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesQuotationPaymentInfo PaymentReference"
paymentReference: String
"The SalesQuotationPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for the new sales quotation."
input CreateCreateSalesQuotationShippingDetailsInput {
"The SalesQuotation DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesQuotation EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesQuotation ExtraWeight"
extraWeight: Decimal
"The SalesQuotation MaxDeliveryDays"
maxDeliveryDays: Int
"The SalesQuotation ShippingDate"
shippingDate: DateTime
"The SalesQuotation ShippingPriority"
shippingPriority: Int
}
"Tax details for the new sales quotation."
input CreateCreateSalesQuotationTaxDetailsInput {
"The SalesQuotation SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment
"The SalesQuotation TaxSetting"
taxSetting: TaxSetting
}
"Text details for the new sales quotation."
input CreateCreateSalesQuotationTextInput {
"The SalesQuotationText Comment"
comment: String
"The SalesQuotationText CustomerComment"
customerComment: String
"The SalesQuotationText PrintText"
printText: String
"The SalesQuotationText ProcessStatus"
processStatus: String
}
"Options for copying cross-selling data."
input CreateCrossSellingCopyOptionsInput {
"Indicates whether cross-selling data should be copied."
isActive: Boolean!
"Specifies whether to replace existing cross-selling relations or attach\/add new ones to existing cross-selling data."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating cross-selling data."
input CreateCrossSellingDuplicationOptionsInput {
"Indicates whether cross-selling data should be duplicated."
isActive: Boolean
}
"Options for copying custom fields (eigene Felder)."
input CreateCustomFieldsCopyOptionsInput {
"Indicates whether custom fields should be copied."
isActive: Boolean!
"Specifies whether to replace all existing custom field values or attach\/merge new custom field values with existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating custom fields."
input CreateCustomFieldsDuplicationOptionsInput {
"Indicates whether custom fields should be duplicated."
isActive: Boolean
}
"Creates a customer - Request"
input CreateCustomerCommandRequestInput {
"Id of the company the customer belongs to. Optional — defaults to 0 (no company) when omitted."
companyId: ID
"Customer group for the customer to be in."
customerGroupId: ID!
"The customers category ID."
customerCategoryId: ID
"The customers preferred payment method ID."
paymentMethodId: ID
"The accounts receivable number of the customer."
accountsReceivableNumber: Int
"The customer's date of birth."
birthday: DateTime
"The customer's commercial register number."
commercialRegisterNumber: String
"Number of the customer. If no number is given when posting a customer, the number will be generated automatically."
customerNumber: String
"The customers ebay name."
ebayName: String
"The customers homepage URL."
homepage: String
"The source of initial contact. This could be for example a specific sales channel, a convention or a marketing campaign."
initialContact: String
"States if a customer is from a cash-register or point of sale and if their data should be synchronized with JTL-POS, for example."
isCashRegisterBased: Boolean
"The customer's locked status."
isLocked: Boolean
"The customer's preferred language in ISO format (e.g. \"de\", \"en\")."
languageIso: String
"The customer's tax identification number."
taxIdentificationNumber: String
"Default billing address of the customer."
billingAddress: CreateCreateCustomerAddressInput!
"Default shipping address of the customer."
shipmentAddress: CreateCreateCustomerAddressInput
"Settings relevant to payment for the customer."
paymentSettings: CreateCreateCustomerPaymentSettingsInput
}
input CreateCustomerGroupSurchargeInput {
"Id of the customergroup"
customerGroupId: ID!
"Surcharge for that customergroup"
surcharge: Decimal
"Defines if the surcharges will be synchronized to online saleschannels. Does not apply for the default customer group surcharges, which are always synchronized when not overriden."
isActive: Boolean
}
"Defines a default description of an item in a specific language. This description is used as a fallback when no more specific platform or sales channel descriptions are available."
input CreateDefaultDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the actual description data such as name, short and long description as well as SEO-relevant information."
descriptionData: CreateDescriptionDataInput!
}
"Delivers an existing Package - Request"
input CreateDeliverPackageCommandRequestInput {
"ID of the Package to be modified"
packageId: String!
"The Tracking Code of the Package. Only required if configured in the Shipping Method"
trackingCode: String
"The Shipping Date of the Package. Only required if configured in the Shipping Method"
shippingDate: DateTime
}
"Options for copying delivery options and constraints."
input CreateDeliveryOptionsCopyOptionsInput {
"Indicates whether delivery options should be copied."
isActive: Boolean!
"Specifies whether to replace existing delivery options. Only Replace is applicable for delivery options, as they are exclusive settings."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating delivery options."
input CreateDeliveryOptionsDuplicationOptionsInput {
"Indicates whether delivery options should be duplicated."
isActive: Boolean
}
"Defines the actual description data of an item. This structure contains all textual information of an item including SEO-relevant metadata for online shops."
input CreateDescriptionDataInput {
"The name of the item as displayed in the user interface or shop."
itemName: String
"Short description of the item for overview displays and search results."
shortDescription: String
"Detailed description of the item with comprehensive product information and properties."
description: String
"Meta description for search engine optimization (SEO) that is displayed in search results."
metaDescription: String
"Meta keywords for search engine optimization to improve discoverability of the item."
metaKeywords: String
"HTML title tag for the item that is displayed in the browser tab and search results."
titleTag: String
"URL path for the item to create SEO-friendly and speaking URLs."
urlPath: String
}
input CreateDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Name of the Variation in the specific language"
name: String!
}
"Options for copying item texts and descriptions."
input CreateDescriptionsCopyOptionsInput {
"Indicates whether texts and descriptions should be copied."
isActive: Boolean!
"Indicates whether the item name should be copied."
considerItemName: Boolean!
"Indicates whether the item description (long text) should be copied."
considerItemDescription: Boolean!
"Indicates whether item metadata (meta description, meta keywords, title tag) should be copied."
considerItemMetadata: Boolean!
"Indicates whether the item URL path (SEO URL) should be copied."
considerItemUrlPath: Boolean!
"Specifies whether to replace existing texts or attach\/merge new texts with existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating descriptions."
input CreateDescriptionsDuplicationOptionsInput {
"Indicates whether descriptions should be duplicated."
isActive: Boolean
"Indicates whether the item description should be considered during duplication. When true, the full description text will be duplicated."
considerDescriptions: Boolean
"Indicates whether the item metadata (such as meta description, meta keywords, and title tags) should be considered during duplication."
considerMetadata: Boolean
"Indicates whether the URL path should be considered during duplication. When true, the SEO-friendly URL path will be duplicated."
considerUrlPaths: Boolean
"Indicates whether the item name should be considered during duplication. When true, the item name from descriptions will be duplicated."
considerNames: Boolean
}
"Options for copying download files."
input CreateDownloadFilesCopyOptionsInput {
"Indicates whether download files should be copied."
isActive: Boolean!
"Specifies whether to replace all existing download files or attach\/add new download files to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating download files."
input CreateDownloadFilesDuplicationOptionsInput {
"Indicates whether download files should be duplicated."
isActive: Boolean
}
input CreateEbayImagesInput {
"Unique ID to identify an ebay account."
ebayAccountId: ID!
"List of images assigned to the platform."
images: [CreateItemImageInput]
}
"Options for copying item identifiers (EAN, ISBN, HAN, UPC, TARIC, etc.)."
input CreateIdentifiersCopyOptionsInput {
"Indicates whether identifiers should be copied."
isActive: Boolean!
"Specifies whether to replace existing identifiers. Only Replace is applicable for identifiers as they are unique values."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating identifiers."
input CreateIdentifiersDuplicationOptionsInput {
"Indicates whether identifiers should be duplicated."
isActive: Boolean
"Indicates whether the EAN (European Article Number) should be considered during duplication."
considerEan: Boolean
"Indicates whether the ISBN (International Standard Book Number) should be considered during duplication."
considerIsbn: Boolean
"Indicates whether the UPC (Universal Product Code) should be considered during duplication."
considerUpc: Boolean
"Indicates whether the HAN (manufacturer number) should be considered during duplication."
considerHan: Boolean
"Indicates whether the TARIC code should be considered during duplication."
considerTaricCode: Boolean
"Indicates whether the country of origin code should be considered during duplication."
considerCountryCode: Boolean
"Indicates whether the hazard identification number should be considered during duplication."
considerHazardNumber: Boolean
"Indicates whether the series information should be considered during duplication."
considerSeries: Boolean
"Indicates whether the UN number should be considered during duplication."
considerUnNumber: Boolean
"Indicates whether the Amazon FNSKU should be considered during duplication."
considerAmazonFnsku: Boolean
"Indicates whether item notes should be considered during duplication."
considerNotes: Boolean
"Indicates whether search terms should be considered during duplication."
considerSearchTerms: Boolean
"Indicates whether the include in price list flag should be considered during duplication."
considerIncludeInPriceList: Boolean
"Indicates whether order suggestions should be considered during duplication."
considerOrderSuggestions: Boolean
}
"Options for copying item images."
input CreateImagesCopyOptionsInput {
"Indicates whether images should be copied."
isActive: Boolean!
"Specifies whether to replace all existing images or attach\/add new images to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating images."
input CreateImagesDuplicationOptionsInput {
"Indicates whether images should be duplicated."
isActive: Boolean
}
input CreateItemAttributesInput {
"Contains all attribute values assigned to the item"
values: [CreateAttributeValuesInput]
}
"Defines the category assignments of an item for creation. This structure manages all categories to which an item can be assigned and enables hierarchical classification for better organization and navigation."
input CreateItemCategoriesInput {
"Contains all categories to which the item is assigned. An item can be assigned to multiple categories simultaneously to enable flexible categorization and better discoverability."
categories: [CreateItemCategoryInput!]!
}
"Defines a single category assignment for an item. This structure represents the link between an item and a specific category in the hierarchical category system of the ERP system."
input CreateItemCategoryInput {
"Unique key of the category that identifies the specific category to which the item should be assigned. This key establishes the connection to the category data."
categoryId: ID!
}
"Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements. - Request"
input CreateItemCommandRequestInput {
"The ID of the product group to which the item should be assigned. Product groups serve for categorical classification of items for reports and analyses."
productGroupId: ID
"The ID of the shipping class to which the item should be assigned."
shippingClassId: ID
"The ID of the manufacturer to which the item should be assigned."
manufacturerId: ID
"Category assignments of the item. Defines all categories to which the item should be assigned for better organization and navigation."
categories: CreateItemCategoriesInput!
"Identifiers of the item with all relevant markings and numbers for unique identification of the item in various systems."
identifiers: CreateItemIdentifiersInput!
"Descriptions of the item in different languages and for different platforms\/sales channels. Includes names, short and long descriptions as well as SEO-relevant information."
descriptions: CreateItemDescriptionsInput!
"Price structures of the item for different sales channels, customer groups and individual customers. Includes sales prices, purchase prices and tier prices."
prices: CreateItemPricesInput
"Suppliers associated with the item including supplier-specific information such as purchase prices, delivery times and order intervals."
suppliers: CreateItemSuppliersInput
"Physical dimensions and weight specifications of the item for storage, shipping and product presentation. Important for shipping cost calculations and storage space optimization."
measurements: CreateItemMeasurementsInput
"tbd"
images: CreateItemImagesInput
"Custom fields defined for the item to store additional information. Useful for special requirements or integrations."
customFields: CreateItemCustomFieldsInput
"Variations of an item"
variations: CreateItemVariationsInput
"Features of an item"
features: CreateItemFeaturesInput
"Attributes of an item"
attributes: CreateItemAttributesInput
"UnitPricing information of an item"
unitPricing: CreateItemUnitPricingInput
"SpecialPrices information of an item"
specialPrices: CreateItemSpecialPricesInput
"ItemStorageConstraints information of an item"
storageConstraints: CreateItemStorageConstraintsInput
}
"Defines a single custom field value for an item. This structure connects a custom field definition with its actual value for a specific item."
input CreateItemCustomFieldValueInput {
"Unique identifier of the custom field definition. References the custom field that was previously created in the system."
fieldId: ID!
"The actual value stored in this custom field. The format and content depend on the custom field type definition (text, number, date, etc.)."
value: String!
"The culture name (e.g., \"en-US\", \"de-DE\") associated with the custom field value. This is important for localized fields where the value may vary based on the user's language or region. When returning those values from the server side this Format is always InvariantCulture. When sending values to the server side the culture name is optional and if not provided, it will be treated as InvariantCulture. Otherwise this value initializes a CultureInfo Object."
valueCultureName: String!
}
"Defines custom fields for an item to store additional, user-defined information. Custom fields allow flexible extension of item data beyond standard properties and can be used for special business requirements, integrations, or custom workflows."
input CreateItemCustomFieldsInput {
"List of custom field values assigned to the item. Each entry represents a custom field with its corresponding value."
fieldValues: [CreateItemCustomFieldValueInput!]!
}
"Defines customer group-specific prices for an item. This structure enables differentiated pricing by customer groups, allowing different price levels for different customer segments."
input CreateItemCustomerGroupPricesInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers)."
customerGroupId: ID!
"List of prices for this customer group - can contain different tier prices or volume discounts."
prices: [CreateItemPriceInput!]!
}
"Defines a customer group-specific special price for an item. This structure represents a single promotional price for a specific customer group in a sales channel."
input CreateItemCustomerGroupSpecialPriceInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers) for which this special price applies."
customerGroupId: ID!
"Net special price for this customer group without taxes. Setting this to null will deactivate the special price for this customer group."
netPrice: Decimal
"Indicates whether this special price is active for this customer group. Automatically set to false when NetPrice is set to null."
isActive: Boolean
}
"Defines customer-specific prices for an item. This structure enables individual price agreements for specific customers that can deviate from standard or customer group prices."
input CreateItemCustomerPricesInput {
"Key of the customer that identifies the specific customer for whom these individual prices apply."
customerId: ID!
"List of individual prices for this customer - can contain different tier prices or special conditions."
prices: [CreateItemPriceInput!]!
}
"Defines the collection of all descriptions of an item for creation. This structure manages default, platform, and sales channel-specific item descriptions for different languages and distribution channels."
input CreateItemDescriptionsInput {
"Default descriptions of the item. This is used when no more specific platform or sales channel descriptions are available and serves as a fallback description."
defaultDescriptions: [CreateDefaultDescriptionInput!]!
"List of sales channel-specific descriptions for sales platforms like JTL-Shop. Enables individual customization of item descriptions for specific sales channels."
salesChannelDescriptions: [CreateSalesChannelDescriptionInput]
"List of platform-specific descriptions for non-sales platforms like print. Allows different descriptions for various output platforms."
platformDescriptions: [CreatePlatformDescriptionInput]
}
"Represents the basic information for a duplicated item including SKU and name."
input CreateItemDuplicateInput {
"The stock keeping unit (SKU) for the duplicated item. Must be unique."
sku: String!
"The name of the duplicated item."
name: String!
}
"Defines which item properties should be duplicated when creating item copies. This structure controls the duplication behavior for all relevant item aspects."
input CreateItemDuplicationOptionsInput {
"Options for duplicating over-sales settings."
oversalesDuplicationOptions: CreateOversalesDuplicationOptionsInput
"Options for duplicating item attributes."
attributesDuplicationOptions: CreateAttributesDuplicationOptionsInput
"Options for duplicating images."
imagesDuplicationOptions: CreateImagesDuplicationOptionsInput
"Options for duplicating download files."
downloadFilesDuplicationOptions: CreateDownloadFilesDuplicationOptionsInput
"Options for duplicating upload files."
uploadFilesDuplicationOptions: CreateUploadFilesDuplicationOptionsInput
"Options for duplicating media files."
mediaFilesDuplicationOptions: CreateMediaFilesDuplicationOptionsInput
"Options for duplicating item characteristics."
characteristicsDuplicationOptions: CreateCharacteristicsDuplicationOptionsInput
"Options for duplicating bill of materials components."
bomDuplicationOptions: CreateBomDuplicationOptionsInput
"Options for duplicating variations."
variationsDuplicationOptions: CreateVariationsDuplicationOptionsInput
"Options for duplicating configurations."
configurationsDuplicationOptions: CreateConfigurationsDuplicationOptionsInput
"Options for duplicating descriptions."
descriptionsDuplicationOptions: CreateDescriptionsDuplicationOptionsInput
"Options for duplicating cross-selling data."
crossSellingDuplicationOptions: CreateCrossSellingDuplicationOptionsInput
"Options for duplicating custom fields."
customFieldsDuplicationOptions: CreateCustomFieldsDuplicationOptionsInput
"Options for duplicating purchase prices."
purchasePricesDuplicationOptions: CreatePurchasePricesDuplicationOptionsInput
"Options for duplicating identifiers."
identifiersDuplicationOptions: CreateIdentifiersDuplicationOptionsInput
"Options for duplicating sales prices."
salesPricesDuplicationOptions: CreateSalesPricesDuplicationOptionsInput
"Options for duplicating master data."
masterDataDuplicationOptions: CreateMasterDataDuplicationOptionsInput
"Options for duplicating special prices."
specialPricesDuplicationOptions: CreateSpecialPricesDuplicationOptionsInput
"Options for duplicating delivery options."
deliveryOptionsDuplicationOptions: CreateDeliveryOptionsDuplicationOptionsInput
"Options for duplicating dimensions and weights."
measurementssDuplicationOptions: CreateMeasurementssDuplicationOptionsInput
"Options for duplicating supplier data."
suppliersDuplicationOptions: CreateSuppliersDuplicationOptionsInput
"Options for duplicating saleschannel settings."
saleschannelDuplicationOptions: CreateSaleschannelDuplicationOptionsInput
"Options for duplicating SCX data."
scxDuplicationOptions: CreateScxDuplicationOptionsInput
"Options for duplicating packaging data."
packagingDuplicationOptions: CreatePackagingDuplicationOptionsInput
}
"Defines a single feature assignment for an item. This structure represents the link between an item and a specific feature value from the feature system, allowing detailed product characterization."
input CreateItemFeatureInput {
"Unique key of the feature value that identifies the specific feature characteristic to be assigned to the item. This key establishes the connection to a predefined feature value in the feature system."
featureId: ID!
}
"Defines the feature assignments of an item. This structure manages all features (characteristics\/attributes) that describe specific properties or attributes of an item, such as color, size, material, or other custom characteristics used for product differentiation and filtering."
input CreateItemFeaturesInput {
"Contains all features assigned to the item. Each feature represents a specific characteristic or attribute that describes the item in more detail, enabling better product differentiation and advanced filtering capabilities."
features: [CreateItemFeatureInput!]!
}
"Defines various identifiers of an item for creation. This structure includes all relevant markings and numbers used for unique identification of an item."
input CreateItemIdentifiersInput {
"Unique item number (Stock Keeping Unit) - the user-assigned main identification of the item."
sku: String
"Amazon FNSKU (Fulfillment Network Stock Keeping Unit) - used by Amazon for inventory management."
amazonFnsku: String
"GTIN (Global Trade Item Number, formerly EAN) - internationally standardized product identification for global trade."
gtin: String
"Manufacturer's item number - the official product number assigned by the manufacturer."
manufacturerNumber: String
"ISBN (International Standard Book Number) - mainly used for books and other publications."
isbn: String
"Taric code - customs tariff number for international trade and customs processing."
tariccode: String
"UPC (Universal Product Code) - barcode standard mainly used in North America."
upc: String
"UN number - used for marking dangerous goods in transport."
unNumber: String
"Hazard number - identifies the type of danger for hazardous goods in transport."
hazardNumber: String
"Own identifier - user-defined internal identification for company-specific purposes."
ownIdentifier: String
"Default ASIN (Amazon Standard Identification Number) - primary Amazon product identification."
defaultAsin: String
"JTL-Fulfillment-SKU (JFSKU) - unique identifier in the JTL Fulfillment Network (FFN) for item identification."
jfsku: String
}
input CreateItemImageInput {
"Unique ID to identify an image."
blobIdentifier: UUID!
"Sortnumber of the image."
sortNumber: Int!
"Declares the main image of the item. Typically it is the image with sortnumber 1."
isMainImage: Boolean!
}
input CreateItemImagesInput {
"List of default images assigned to the item."
defaultImages: [CreateItemImageInput]
"List of images assigned to different platforms."
platformImages: [CreatePlatformImagesInput]
"List of images assigned to different saleschannels."
saleschannelImages: [CreateSaleschannelImagesInput]
"List of images assigned to different eBay accounts."
ebayImages: [CreateEbayImagesInput]
}
"Defines the physical dimensions and weight specifications of an item for creation. This structure includes all relevant measurements for storage, shipping and product presentation and is used for shipping cost calculations and storage space optimizations."
input CreateItemMeasurementsInput {
"Height of the item in the configured unit of measurement (usually centimeters or millimeters)."
height: Decimal
"Length of the item in the configured unit of measurement (usually centimeters or millimeters)."
length: Decimal
"Shipping weight of the item for shipping cost calculation in the configured weight unit (usually kilograms or grams). May differ from the actual item weight."
shippingWeight: Decimal
"Actual weight of the item without packaging in the configured weight unit (usually kilograms or grams)."
weight: Decimal
"Width of the item in the configured unit of measurement (usually centimeters or millimeters)."
width: Decimal
}
"Defines a single price with tiering options and discount possibilities. This structure forms the basis for complex price structures with volume discounts and percentage price reductions from the standard price."
input CreateItemPriceInput {
"Minimum quantity from which this price applies - enables tier prices based on order quantity (e.g., from 10 pieces)."
fromQuantity: Int!
"Net price for this price tier without taxes - the actual selling price for the specified quantity tier."
netPrice: Decimal
"Percentage discount on the standard price - indicates by what percentage the standard price is reduced for this price tier. Used as an alternative to NetPrice."
reduceStandardPriceByPercent: Decimal
}
"Defines the complete price structure of an item for creation. This structure includes all price information for different sales channels, customer groups and individual customer prices as well as basic price information."
input CreateItemPricesInput {
"Indicates whether discounts should be ignored for this item. When set to true, no automatic discounts will be applied to the item prices."
ignoreDiscounts: Boolean
"Net sales price of the item without taxes and discounts - the basic selling price of the item."
salesPriceNet: Decimal
"Manufacturer's suggested retail price (MSRP) - the selling price recommended by the manufacturer."
suggestedRetailPrice: Decimal
"Net purchase price without taxes - the price at which the item was purchased."
purchasePriceNet: Decimal
"eBay-specific selling price - special price for eBay sales."
ebayPrice: Decimal
"Amazon-specific selling price - special price for Amazon sales."
amazonPrice: Decimal
"List of sales channel-specific prices - enables different pricing for various sales channels or shops."
salesChannelPrices: [CreateItemSaleschannelPricesInput]
"List of customer-specific prices - allows individual price agreements for specific customers."
customerPrices: [CreateItemCustomerPricesInput]
"List of default prices for different customer groups - these prices serve as fallback when no more specific prices are defined."
defaultPrices: [CreateItemCustomerGroupPricesInput]
}
"Defines sales channel-specific special prices for an item. This structure enables different promotional pricing for a specific sales channel or shop with customer group-related special price structures."
input CreateItemSalesChannelSpecialPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this special price structure applies."
salesChannelId: ID!
"List of special prices for different customer groups within this sales channel - enables differentiated promotional pricing by customer groups."
specialPrices: [CreateItemCustomerGroupSpecialPriceInput!]!
}
"Defines sales channel-specific prices for an item. This structure enables different pricing for various sales channels or shops with customer group-related price structures."
input CreateItemSaleschannelPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this price structure applies."
saleschannelId: ID!
"List of prices for different customer groups within this sales channel - enables differentiated pricing by customer groups."
customerGroupPrices: [CreateItemCustomerGroupPricesInput!]!
"Indicates whether this sales channel is active for the item - determines whether the item can be sold in this sales channel."
isActive: Boolean
}
"Defines the special prices (promotional prices) structure of an item. This structure includes time-based and stock-based special pricing for different sales channels and customer groups, as well as Amazon-specific special prices."
input CreateItemSpecialPricesInput {
"Indicates whether special prices are active for this item. When set to true, the special price rules defined below will be applied according to their conditions."
isActive: Boolean
"Date from which the special price becomes active. The special price will only be valid from this date onwards."
startDate: DateTime
"Date until which the special price remains active. The special price will expire after this date. Only evaluated if IsEndDateActive is true."
endDate: DateTime
"Indicates whether the end date should be considered. If false, the special price has no expiration date."
isEndDateActive: Boolean
"Minimum stock quantity that must be available for the special price to remain active. Only evaluated if IsStockRestrictionActive is true."
minimumStockQuantity: Int
"Indicates whether the stock restriction should be applied. When true, the special price is only active if the stock level is greater than or equal to MinimumStockQuantity. Can only be activated for items that use stock management."
isStockRestrictionActive: Boolean
"List of sales channel-specific special prices - enables different promotional pricing for various sales channels or shops with customer group differentiation."
salesChannelSpecialPrices: [CreateItemSalesChannelSpecialPricesInput]
}
"Defines the storage and inventory management constraints of an item. This structure includes settings for negative stock handling, inventory management, serial numbers, batch tracking, and best-before date management."
input CreateItemStorageConstraintsInput {
"Allows selling a higher quantity of the item than is actually in stock. This global setting must be activated first before platform-specific or sales channel-specific negative stock settings can be enabled."
allowNegativeStock: Boolean
"List of platform-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific platforms (e.g., eBay, Amazon). AllowNegativeStock must be activated as well for these settings to take effect."
itemPlatformNegativeStocks: [CreateNegativeStockPlatformInput]
"List of sales channel-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific sales channels or shops. AllowNegativeStock must be activated as well for these settings to take effect."
itemSalesChannelNegativeStocks: [CreateNegativeStockSalesChannelInput]
"Item buffer quantity - defines a safety stock buffer that is reserved and not available for sale. This helps prevent overselling and ensures availability for important orders."
buffer: Int
"Global minimum stock level across all warehouses. When the total stock falls below this value, the item is flagged for reordering. Used for automatic order suggestions and low-stock warnings."
globalMinimumStockLevel: Decimal
"Indicates whether the item uses batch management. When enabled, the item requires batch numbers to be assigned for each stock movement to enable tracking and traceability."
hasBatch: Boolean
"Determines if the item is working with inventory management. When active, stock levels are tracked and managed; when inactive, the item is treated as always available regardless of stock levels."
isInventoryManagementActive: Boolean
"Determines if the item is working with best-before date (MHD - Mindesthaltbarkeitsdatum) management. When enabled, stock items must have an assigned best-before date for tracking perishable goods."
isBestBeforeManaged: Boolean
"Determines if the item can be sold in split quantities (fractional units). When enabled, stock can be managed in decimal quantities (e.g., 2.5 pieces) instead of only whole numbers."
isStockDivisible: Boolean
"Determines the type of serial number processing. Defines whether serial numbers are inactive, active, or tracked for this item."
serialNumberType: SerialNumberType
}
input CreateItemSupplierInput {
"Id of the supplier"
supplierId: ID!
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Stock level of the item at the supplier."
stockLevel: Decimal
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"VAT rate of the item at the supplier."
vatRate: Decimal
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal
"Scale prices defined by the supplier for this item."
scalePrices: [CreateSupplierPriceInput]
}
input CreateItemSuppliersInput {
"Sets the default supplier for the item."
defaultSupplier: ID
"Sets the default supplier for dropshipping for the item."
defaultDropshippingSupplier: ID
"Assigned suppliers for the item"
suppliers: [CreateItemSupplierInput]
}
"Defines the item unit pricing settings for creation and modification. This structure includes all relevant information about the sales unit, packaging unit, inner quantity and base price details for an item."
input CreateItemUnitPricingInput {
"Id of the sales unit in which the item is sold (e.g. piece or box)."
salesUnitId: ID
"Id of the packaging unit of the item."
packagingUnitId: ID
"The amount of content for one piece of the sales unit, relative to the inner quantity unit."
innerQuantity: Decimal
"The measurement unit for the inner quantity (e.g. kg or liter)."
innerQuantityUnitId: ID
"Indicates whether the base price should be automatically calculated and displayed."
isBasePriceDeclared: Boolean
"The measurement unit to which the base price refers (e.g. per liter or per 100 grams)."
basePriceReferenceUnitId: ID
"The reference amount used when calculating the base price (e.g. 1 for per liter, 100 for per 100 grams)."
basePriceReferenceAmount: Decimal
}
input CreateItemVariationsInput {
"Contains all Variations"
variations: [CreateVariationInput]
}
"Defines which item properties should be copied when copying item details. This structure controls the copy behavior for all relevant item aspects."
input CreateItemdetailsCopyOptionsInput {
"Options for copying item attributes."
attributesCopyOptions: CreateAttributesCopyOptionsInput
"Options for copying item texts and descriptions."
descriptionsCopyOptions: CreateDescriptionsCopyOptionsInput
"Options for copying item images."
imagesCopyOptions: CreateImagesCopyOptionsInput
"Options for copying cross-selling data."
crossSellingCopyOptions: CreateCrossSellingCopyOptionsInput
"Options for copying download files."
downloadFilesCopyOptions: CreateDownloadFilesCopyOptionsInput
"Options for copying custom fields."
customFieldsCopyOptions: CreateCustomFieldsCopyOptionsInput
"Options for copying purchase prices."
purchasePricesCopyOptions: CreatePurchasePricesCopyOptionsInput
"Options for copying item identifiers."
identifiersCopyOptions: CreateIdentifiersCopyOptionsInput
"Options for copying item configurations."
configurationsCopyOptions: CreateConfigurationsCopyOptionsInput
"Options for copying supplier data."
suppliersCopyOptions: CreateSuppliersCopyOptionsInput
"Options for copying delivery options."
deliveryOptionsCopyOptions: CreateDeliveryOptionsCopyOptionsInput
"Options for copying dimensions and weights."
measurementsCopyOptions: CreateMeasurementsCopyOptionsInput
"Options for copying media files."
mediaFilesCopyOptions: CreateMediaFilesCopyOptionsInput
"Options for copying item characteristics."
characteristicsCopyOptions: CreateCharacteristicsCopyOptionsInput
"Options for copying online shop settings."
onlineShopsCopyOptions: CreateOnlineShopsCopyOptionsInput
"Options for copying over-sales settings."
oversalesCopyOptions: CreateOversalesCopyOptionsInput
"Options for copying SCX marketplace data."
scxCopyOptions: CreateScxCopyOptionsInput
"Options for copying special prices."
specialPricesCopyOptions: CreateSpecialPricesCopyOptionsInput
"Options for copying master data."
masterDataCopyOptions: CreateMasterDataCopyOptionsInput
"Options for copying bill of materials components."
bomComponentsCopyOptions: CreateBomComponentsCopyOptionsInput
"Options for copying upload files."
uploadFilesCopyOptions: CreateUploadFilesCopyOptionsInput
"Options for copying variations."
variationsCopyOptions: CreateVariationsCopyOptionsInput
"Options for copying sales prices."
salesPricesCopyOptions: CreateSalesPricesCopyOptionsInput
"Options for copying packaging settings."
packagingCopyOptions: CreatePackagingCopyOptionsInput
}
"Creates a new lot size for a production item. - Request"
input CreateLotSizeCommandRequestInput {
"The ID of the production item for which the lot size is to be created."
productionItemId: ID!
"The input for creating a lot size as part of a production item."
input: CreateLotSizeInput!
}
"Represents the input for creating a lot size as part of a production item."
input CreateLotSizeInput {
"The lot size value. Must be greater than zero."
lotSize: Int!
}
"Options for copying master data (manufacturer, product group, shipping class, tax class, etc.)."
input CreateMasterDataCopyOptionsInput {
"Indicates whether master data should be copied."
isActive: Boolean!
"Specifies whether to replace existing master data. Only Replace is applicable for master data as these are exclusive assignments."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating master data."
input CreateMasterDataDuplicationOptionsInput {
"Indicates whether master data should be duplicated."
isActive: Boolean
"Indicates whether the manufacturer should be considered during duplication."
considerManufacturer: Boolean
"Indicates whether the product group should be considered during duplication."
considerProductGroup: Boolean
"Indicates whether the tax class should be considered during duplication."
considerTaxClass: Boolean
"Indicates whether the shipping class should be considered during duplication."
considerShippingClass: Boolean
"Indicates whether the base price unit should be considered during duplication."
considerBasePriceUnit: Boolean
"Indicates whether minimum purchase settings should be considered during duplication."
considerMinimumPurchaseSettings: Boolean
"Indicates whether packaging information should be considered during duplication."
considerPackaging: Boolean
"Indicates whether the non-discountable flag should be considered during duplication."
considerNonDiscountable: Boolean
"Indicates whether the item type should be considered during duplication."
considerItemType: Boolean
"Indicates whether inventory management settings should be considered during duplication."
considerInventoryManagement: Boolean
"Indicates whether minimum and maximum inventory levels should be considered during duplication."
considerMinMaxInventory: Boolean
"Indicates whether the product compliance responsible person should be considered during duplication."
considerProductCompliancePerson: Boolean
}
"Options for copying dimensions and weights."
input CreateMeasurementsCopyOptionsInput {
"Indicates whether dimensions and weights should be copied."
isActive: Boolean!
"Specifies whether to replace existing dimensions and weights. Only Replace is applicable for measurements."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating dimensions and weights."
input CreateMeasurementssDuplicationOptionsInput {
"Indicates whether dimensions and weights should be duplicated."
isActive: Boolean
}
"Options for copying media files."
input CreateMediaFilesCopyOptionsInput {
"Indicates whether media files should be copied."
isActive: Boolean!
"Specifies whether to replace all existing media files or attach\/add new media files to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating media files."
input CreateMediaFilesDuplicationOptionsInput {
"Indicates whether media files should be duplicated."
isActive: Boolean
}
"Defines negative stock settings for a specific platform. This structure enables individual configuration of negative stock handling per platform (e.g., eBay, Amazon), allowing overselling for specific marketplaces when the global AllowNegativeStock is enabled."
input CreateNegativeStockPlatformInput {
"Key of the platform that identifies the specific marketplace or platform (e.g., eBay, Amazon) for which this negative stock setting applies."
platformId: ID!
"Determines if negative stock is allowed for this platform. When true, orders can be accepted even when the item is out of stock on this specific marketplace."
isNegativeStockAllowed: Boolean!
}
"Defines negative stock settings for a specific sales channel. This structure enables individual configuration of negative stock handling per sales channel, allowing overselling for specific online shops when the global AllowNegativeStock is enabled."
input CreateNegativeStockSalesChannelInput {
"Key of the sales channel that identifies the specific shop or sales channel for which this negative stock setting applies."
salesChannelId: ID!
"Determines if negative stock is allowed for this sales channel. When true, orders can be accepted even when the item is out of stock in this specific channel."
isNegativeStockAllowed: Boolean!
}
"Options for copying online shop settings and visibility."
input CreateOnlineShopsCopyOptionsInput {
"Indicates whether online shop settings should be copied."
isActive: Boolean!
"Specifies whether to replace all existing online shop settings or attach\/add new shop settings to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for copying over-sales settings."
input CreateOversalesCopyOptionsInput {
"Indicates whether over-sales settings should be copied."
isActive: Boolean!
"Specifies whether to replace existing over-sales settings or attach new ones. Only Replace is applicable for over-sales settings."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating over-sales settings."
input CreateOversalesDuplicationOptionsInput {
"Indicates whether over-sales settings should be duplicated."
isActive: Boolean
}
"Options for copying item packaging settings."
input CreatePackagingCopyOptionsInput {
"Indicates whether configurations should be copied."
isActive: Boolean!
"Specifies whether to replace all existing configurations or attach\/add new configurations to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for copying item packaging settings."
input CreatePackagingDuplicationOptionsInput {
"Indicates whether packaging settings should be duplicated."
isActive: Boolean!
}
"Defines a platform-specific description of an item. This enables different descriptions for various output platforms like print or other non-sales platforms."
input CreatePlatformDescriptionInput {
"Unique key of the platform for which this description is intended (e.g., print, labels)."
platformId: ID!
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the platform-specific description data with all relevant texts and SEO information."
descriptionData: CreateDescriptionDataInput!
}
input CreatePlatformImagesInput {
"Unique ID to identify a platform."
platformId: ID!
"List of images assigned to the platform."
images: [CreateItemImageInput]
}
"Creates a new production item, including its bills of materials with their components. - Request"
input CreateProductionItemCommandRequestInput {
"The input for creating the production item, including the details of the production item itself and the bills of materials and lot sizes to be created for the production item."
input: CreateProductionItemInput!
}
"Represents the input for creating a new production item, including the details of the production item itself and the bills of materials and lot sizes to be created for the production item."
input CreateProductionItemInput {
"The ID of the item for which the production item is to be created."
itemId: ID!
"Indicates whether this production item is a customized production item (true) or a regular production item (false)."
isCustomized: Boolean
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateId: ID
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no per-unit item label should be printed on completion. Optional."
singleItemLabelTemplateId: ID
"The bills of materials to create for this production item. At least one bill of materials is required. Each bill of materials must contain at least one operation, and across all operations, at least one component must be present."
billsOfMaterials: [CreateBillOfMaterialsInput!]!
"The optional lot sizes to create for this production item."
lotSizes: [CreateLotSizeInput]
}
"Creates a new production order. - Request"
input CreateProductionOrderCommandRequestInput {
"The input for creating the production order, including the production item, bill of materials, lot configuration, and optional scheduling details."
input: CreateProductionOrderInput!
}
"Represents the input for creating a new production order, including references to the production item, the bill of materials as well as the lot configuration and scheduling details."
input CreateProductionOrderInput {
"The ID of the production item for which the production order is to be created."
productionItemId: ID!
"The ID of the bill of materials to be used for production."
billOfMaterialsId: ID!
"The number of lots to be produced."
lotCount: Int!
"The size of each lot to be produced."
lotSize: Decimal!
"The planned total quantity to be produced."
targetTotalQuantity: Decimal!
"Indicates whether it is allowed for this order to have a target total quantity below the lot size (true) or not (false). Defaults to false."
isTargetTotalQuantityBelowLotSizeAllowed: Boolean
"The reference number associated with the production order."
referenceNumber: String
"The project number associated with the production order."
projectNumber: String
"Additional note on the order that will be displayed during production."
notice: String
"The planned start time of the production order."
targetStartTimestamp: DateTime
"The planned completion time of the production order."
targetCompletionTimestamp: DateTime
}
"Options for copying purchase prices."
input CreatePurchasePricesCopyOptionsInput {
"Indicates whether purchase prices should be copied."
isActive: Boolean!
"Specifies whether to replace existing purchase prices. Only Replace is applicable for purchase prices."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating purchase prices."
input CreatePurchasePricesDuplicationOptionsInput {
"Indicates whether purchase prices should be duplicated."
isActive: Boolean
}
"Defines a sales channel-specific description of an item. This enables individual customization of item descriptions for specific sales channels or shops."
input CreateSalesChannelDescriptionInput {
"Unique key of the sales channel or shop for which this description is intended."
salesChannelId: ID!
"ISO2 language code that determines the language for this sales channel-specific description."
languageIso: String!
"Contains the sales channel-specific description data with all relevant texts and SEO information."
descriptionData: CreateDescriptionDataInput!
}
input CreateSalesChannelSurchargeInput {
"Id of the saleschannel"
salesChannelId: ID!
"Contains the surcharges for that saleschannel and customergroup"
surcharges: [CreateCustomerGroupSurchargeInput!]!
}
"Create a new sales invoice for a salesorder - Request"
input CreateSalesInvoiceCommandRequestInput {
"The ID of the sales order to create the invoice for."
salesOrderId: ID!
"If true, only the delivered quantities of the sales order line items are added to the new invoice."
invoiceOnlyDeliveredQuantity: Boolean
"If true, the invoice will be created as a draft. An invoice draft has no invoice number yet and can be edited until finalized."
asDraft: Boolean
}
"Create a new sales invoice correction from an existing invoice - Request"
input CreateSalesInvoiceCorrectionCommandRequestInput {
"The ID of the sales invoice to create the correction for."
salesInvoiceId: ID!
"Indicates if the sales invoice correction should be created as draft."
asDraft: Boolean
"Indicates if only undelivered quantities should be used."
useUndeliveredQuantities: Boolean
"If true, the workflows do not trigger automatic."
disableAutomaticWorkflows: Boolean
"If true, the sales order quantities will be reduced."
reduceSalesOrderQuantities: Boolean
"If true, the delivery quantities will be reduced."
reduceDeliveryQuantities: Boolean
"If true, the web shop order will be canceled"
cancelWebShopOrder: Boolean
}
"Creates a new sales order. - Request"
input CreateSalesOrderCommandRequestInput {
"Indicates whether automatic workflows should be disabled for this sales order."
disableAutomaticWorkflows: Boolean
"Indicates whether the billing address should be used as the shipment address. If no shipment address is provided and the flag ist not set, the billing address will also be used as shipment address. If the shipment address is provided, this flag will be ignored."
useBillingAddressAsShipmentAddress: Boolean
"The SalesOrder CartonItemId"
cartonItemId: ID
"The SalesOrder CompanyId"
companyId: ID!
"The customer ID."
customerId: ID!
"The SalesOrder OnHoldReasonId"
onHoldReasonId: ID
"The SalesOrder PaymentMethodId"
paymentMethodId: ID
"The SalesOrder ProcessColourId"
processColourId: ID
"The SalesOrder ProcessStatusId"
processStatusId: ID
"SalesOrderBillingAddress"
billingAddress: CreateCreateSalesOrderAddressInput!
"DepartureCountry"
departureCountry: CreateCreateSalesOrderDepartureCountryInput!
"ExternalDetails"
externalDetails: CreateCreateSalesOrderExternalDetailsInput
"List of SalesOrderLineItem"
lineItems: [CreateCreateSalesOrderLineItemInput!]!
"PaymentDetails"
paymentDetails: CreateCreateSalesOrderPaymentDetailsInput!
"SalesOrderPaymentInfo"
paymentInfo: CreateCreateSalesOrderPaymentInfoInput
"SalesOrderShipmentAddress"
shipmentAddress: CreateCreateSalesOrderAddressInput
"ShippingDetails"
shippingDetails: CreateCreateSalesOrderShippingDetailsInput
"TaxDetails"
taxDetails: CreateCreateSalesOrderTaxDetailsInput
"SalesOrderText"
text: CreateCreateSalesOrderTextInput
"The SalesOrder CustomerSalesOrderNumber"
customerSalesOrderNumber: String
"The SalesOrder ItemDescriptionType"
itemDescriptionType: ItemDescriptionType
"The SalesOrder LanguageISO"
languageIso: String!
"The SalesOrder ReadOnlyType"
readOnlyType: ReadOnlyType
"The SalesOrder Date"
salesOrderDate: DateTime
"The SalesOrder SalesOrderNumber"
salesOrderNumber: String
"The SalesOrder ShippingMethodId"
shippingMethodId: ID
"The SalesOrder VATId"
vatId: String!
}
"Create a new sales order for a sales quotation - Request"
input CreateSalesOrderFromSalesQuotationCommandRequestInput {
"The ID of the sales quotation to create the order from."
salesQuotationId: ID!
}
"Options for copying sales prices including shop-specific and customer group prices."
input CreateSalesPricesCopyOptionsInput {
"Indicates whether sales prices should be copied."
isActive: Boolean!
"Specifies whether to replace all existing sales prices or attach\/add new price entries to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating sales prices."
input CreateSalesPricesDuplicationOptionsInput {
"Indicates whether sales prices should be duplicated."
isActive: Boolean
}
"Creates a new sales quotation. - Request"
input CreateSalesQuotationCommandRequestInput {
"Indicates whether automatic workflows should be disabled for this sales quotation."
disableAutomaticWorkflows: Boolean
"Indicates whether the billing address should be used as the shipment address. If no shipment address is provided and the flag ist not set, the billing address will also be used as shipment address. If the shipment address is provided, this flag will be ignored."
useBillingAddressAsShipmentAddress: Boolean
"The SalesQuotation CartonItemId"
cartonItemId: ID
"The SalesQuotation CompanyId"
companyId: ID!
"The customer ID."
customerId: ID!
"The SalesQuotation OnHoldReasonId"
onHoldReasonId: ID
"The SalesQuotation PaymentMethodId"
paymentMethodId: ID
"The SalesQuotation ProcessColourId"
processColourId: ID
"The SalesQuotation ProcessStatusId"
processStatusId: ID
"SalesQuotationBillingAddress"
billingAddress: CreateCreateSalesQuotationAddressInput!
"DepartureCountry"
departureCountry: CreateCreateSalesQuotationDepartureCountryInput!
"ExternalDetails"
externalDetails: CreateCreateSalesQuotationExternalDetailsInput
"List of SalesQuotationLineItem"
lineItems: [CreateCreateSalesQuotationLineItemInput!]!
"PaymentDetails"
paymentDetails: CreateCreateSalesQuotationPaymentDetailsInput!
"SalesQuotationPaymentInfo"
paymentInfo: CreateCreateSalesQuotationPaymentInfoInput
"SalesQuotationShipmentAddress"
shipmentAddress: CreateCreateSalesQuotationAddressInput
"ShippingDetails"
shippingDetails: CreateCreateSalesQuotationShippingDetailsInput
"TaxDetails"
taxDetails: CreateCreateSalesQuotationTaxDetailsInput
"SalesQuotationText"
text: CreateCreateSalesQuotationTextInput
"The SalesQuotation CustomerSalesQuotationNumber"
customerSalesQuotationNumber: String
"The VAT ID of the customer."
customerVatId: String
"The SalesQuotation ItemDescriptionType"
itemDescriptionType: ItemDescriptionType
"The SalesQuotation LanguageISO"
languageIso: String!
"The SalesQuotation ReadOnlyType"
readOnlyType: ReadOnlyType
"The SalesQuotation Date"
salesQuotationDate: DateTime
"The SalesQuotation SalesQuotationNumber"
salesQuotationNumber: String
"The SalesQuotation ShippingMethodId"
shippingMethodId: ID
"The SalesQuotation VATId"
vatId: String!
}
"Options for duplicating saleschannel settings."
input CreateSaleschannelDuplicationOptionsInput {
"Indicates whether saleschannel settings should be duplicated."
isActive: Boolean
"Indicates whether item highlight options should be considered during duplication. When true, special highlighting and promotional settings for sales channels will be duplicated."
considerHighlightOptions: Boolean
}
input CreateSaleschannelImagesInput {
"Unique ID to identify a saleschannel."
saleschannelId: ID!
"List of images assigned to the platform."
images: [CreateItemImageInput]
}
"Options for copying SCX (shopping.com XML) marketplace data."
input CreateScxCopyOptionsInput {
"Indicates whether SCX data should be copied."
isActive: Boolean!
"Specifies whether to replace existing SCX data or attach\/add new SCX data to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating SCX data."
input CreateScxDuplicationOptionsInput {
"Indicates whether SCX data should be duplicated."
isActive: Boolean
"Indicates whether assigned categories should be considered during duplication. When true, category assignments for sales channels will be duplicated."
considerCategoryMappings: Boolean
"Indicates whether custom field values should be considered during duplication. When true, sales channel-specific custom field values will be duplicated."
considerSalesChannelFieldValues: Boolean
"Indicates whether all shops should be considered during duplication. When true, SCX data will be duplicated for all configured sales channels."
considerEveryShop: Boolean
"List of sales channel keys for which the SCX data should be duplicated. Only data for the specified sales channels will be copied to the new item."
shopsToConsider: [ID]
}
"Creates a new shipping box within a warehouse. - Request"
input CreateShippingBoxCommandRequestInput {
"Warehouse to create the box in."
warehouseId: ID!
"Display name for the box (must be unique within warehouse)."
displayId: String!
"Box type (immutable after creation)."
typeId: ID!
"Bin location to assign the box to."
binLocationId: ID!
"Optional list of free-form attributes."
attributes: [String!]!
}
"Creates a new shipping class - Request"
input CreateShippingClassCommandRequestInput {
"The name of the shipping class."
name: String!
}
"Options for copying special prices (Sonderpreise) including time-based promotional prices."
input CreateSpecialPricesCopyOptionsInput {
"Indicates whether special prices should be copied."
isActive: Boolean!
"Specifies whether to replace all existing special prices or attach\/add new special price entries to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating special prices."
input CreateSpecialPricesDuplicationOptionsInput {
"Indicates whether special prices should be duplicated."
isActive: Boolean
}
input CreateSupplierPriceInput {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal
}
"Options for copying supplier data."
input CreateSuppliersCopyOptionsInput {
"Indicates whether supplier data should be copied."
isActive: Boolean!
"Indicates whether the supplier-specific item SKU (article number) should be copied. When true, the SKU used by the supplier will be copied to the target items."
keepItemNumber: Boolean!
"Indicates whether the supplier-specific item name should be copied. When true, the item name used by the supplier will be copied to the target items."
keepItemName: Boolean!
"Specifies whether to replace all existing suppliers or attach\/add new suppliers to the existing supplier list."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating supplier data."
input CreateSuppliersDuplicationOptionsInput {
"Indicates whether supplier data should be duplicated."
isActive: Boolean
"Indicates whether the supplier-specific item SKU (article number) should be kept during duplication. When true, the SKU used by the supplier will be duplicated."
keepItemNumber: Boolean
"Indicates whether the supplier-specific item name should be kept during duplication. When true, the item name used by the supplier will be duplicated."
keepItemName: Boolean
}
"Creates a new tax class in the system - Request"
input CreateTaxClassCommandRequestInput {
"Whether this tax class is the standard tax class. Setting this to true will set all other tax classes to non-standard."
isStandard: Boolean!
"The name of the new tax class"
name: String!
"The type of the tax class"
taxType: TaxType!
}
"Creates a new tax code in the system - Request"
input CreateTaxCodeCommandRequestInput {
"The cash discount account of the new tax code"
cashDiscountAccount: String!
"The general ledger account of the new tax code"
generalLedgerAccount: String!
"Whether this tax code is automatic"
isAutomatic: Boolean!
"The name of the new tax code"
name: String!
"The number of the new tax code. If not provided, a number will be auto-assigned."
number: Int
}
"Options for copying upload files."
input CreateUploadFilesCopyOptionsInput {
"Indicates whether upload files should be copied."
isActive: Boolean!
"Specifies whether to replace all existing upload files or attach\/add new upload files to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating upload files."
input CreateUploadFilesDuplicationOptionsInput {
"Indicates whether upload files should be duplicated."
isActive: Boolean
}
input CreateVariationInput {
"Id of the Variation"
variationId: ID
"Position of this Variation in the List"
position: Int
"Descriptions of this Variation in multiple Languages"
descriptions: [CreateDescriptionInput!]!
"Values for this Variation"
values: [CreateVariationValueInput]
"Type of the Variation"
variationType: VariationType!
}
input CreateVariationValueInput {
"Id of the VariationValue"
variationValueId: ID
"Itemnumber for this variationvalue"
itemNumber: String
"GTIN for this variationvalue"
gtin: String
"Offset for the weight of this variationvalue"
weightOffset: Decimal
"Descriptions of this VariationValue in multiple Languages"
descriptions: [CreateDescriptionInput!]!
"Surcharges of this VariationValue"
surcharges: CreateVariationValueSurchargesInput
"Position of this VariationValue in the List"
position: Int
"Image for this variation value. This image will be used as the main image for the variation combination if this variation value is part of it and the variation combination doesn't have its own image."
image: ID
}
input CreateVariationValueSurchargesInput {
"Default Surcharge if there is none specified for a specific saleschannel + customergroup"
defaultSurchargeNet: Decimal
"Default Surcharges for specific customergroups in general, independent of saleschannel"
customerGroupSurcharges: [CreateCustomerGroupSurchargeInput]
"Surcharge for specific saleschannels + customergroups"
salesChannelSurcharges: [CreateSalesChannelSurchargeInput]
}
"Options for copying item variations."
input CreateVariationsCopyOptionsInput {
"Indicates whether variations should be copied."
isActive: Boolean!
"Specifies whether to replace all existing variations or attach\/add new variations to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating variations."
input CreateVariationsDuplicationOptionsInput {
"Indicates whether variations should be duplicated."
isActive: Boolean
}
"Creates a new warehouse zone. - Request"
input CreateWarehouseZoneCommandRequestInput {
"Warehouse to create the zone in."
warehouseId: ID!
"Zone short code (must be unique within the warehouse)."
code: String!
"Zone type (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: Int!
"Optional zone description."
description: String
}
"Creates a new workbench resource - Request"
input CreateWorkbenchResourceCommandRequestInput {
"This workbench resource's unique number."
number: String!
"This workbench resource's name."
name: String!
"This workbench resource's description."
description: String!
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ID!
"The name of the host assigned to this workbench resource."
hostName: String!
"The ID of the warehouse assigned to this workbench resource."
warehouseId: ID!
"The reservation mode of this workbench resource."
reservationMode: ReservationMode!
"Specifies whether the dialog for displaying and\/or capturing process parameter values in the context of production should be displayed automatically when process parameter values can\/must be displayed or captured."
autoShowProcessParameterValuesInProduction: Boolean!
"Specifies whether and to what extent the use of expired components is permitted."
expiredComponentsUsage: ExpiredComponentsUsage!
"Specifies wthether and how available stock should be reserved when creating a replenishment order."
replenishmentCreationStockReservationMode: ReplenishmentCreationAvailableStockReservationMode!
}
"Creates a new workbench resource type - Request"
input CreateWorkbenchResourceTypeCommandRequestInput {
"The workbench resource type's name."
name: String!
}
"Single row of the currencies overview table"
input CurrencyFilterInput {
and: [CurrencyFilterInput!]
or: [CurrencyFilterInput!]
"Currency id"
id: ComparableWaehrungKeyOperationFilterInput
"ISO code of the currency"
iso: StringOperationFilterInput
"Name of the currency"
name: StringOperationFilterInput
"Currency factor"
factor: ComparableDecimalOperationFilterInput
"Is default currency"
isDefault: ComparableBooleanOperationFilterInput
"Date and time of the last update"
updated: ComparableNullableOfDateTimeOffsetOperationFilterInput
}
"Single row of the currencies overview table"
input CurrencySortInput {
"Currency id"
id: WaehrungKeySortInput @cost(weight: "10")
"ISO code of the currency"
iso: SortEnumType @cost(weight: "10")
"Name of the currency"
name: SortEnumType @cost(weight: "10")
"Currency factor"
factor: SortEnumType @cost(weight: "10")
"Is default currency"
isDefault: SortEnumType @cost(weight: "10")
"Date and time of the last update"
updated: SortEnumType @cost(weight: "10")
}
"Metadata definition of custom fields (Eigene Felder)"
input CustomFieldListItemFilterInput {
and: [CustomFieldListItemFilterInput!]
or: [CustomFieldListItemFilterInput!]
"Unique identifier of the custom field."
customFieldKey: ComparableEigenesFeldKeyOperationFilterInput
"Name of the custom field in the specified language."
name: StringOperationFilterInput
"Group name where the custom field belongs to."
group: StringOperationFilterInput
"Data type of the custom field. Possible values: Kein = No specific type, Ganzzahl = Integer number, FliesskommaZahl = Floating point number, Text = Free text, Checkbox = Boolean checkbox, Liste = Selection list, Url = Website URL, EMail = Email address, TelNr = Phone number, LandIso = Country ISO code, Preis = Price\/Currency, Datum = Date, KurzText = Short text"
customFieldType: ComparableCustomFieldTypeOperationFilterInput
"The underlying .NET data type of the CustomFieldType: 'int' for Ganzzahl and Checkbox, 'string' for Text, KurzText, Url, EMail, TelNr, LandIso, Liste, and Kein, 'decimal' for FliesskommaZahl and Preis, 'DateTime' for Datum"
dataType: StringOperationFilterInput
"Entity type the custom field belongs to (e.g., Artikel, Kategorie, Kunde)."
referenceType: ComparableCustomFieldReferenceTypeOperationFilterInput
"Indicates whether the field is mandatory."
isRequired: ComparableBooleanOperationFilterInput
"Indicates whether the field value is readonly."
isReadonly: ComparableBooleanOperationFilterInput
"Indicates whether the field is hidden in UI."
isInvisible: ComparableBooleanOperationFilterInput
}
"Metadata definition of custom fields (Eigene Felder)"
input CustomFieldListItemSortInput {
"Unique identifier of the custom field."
customFieldKey: EigenesFeldKeySortInput @cost(weight: "10")
"Name of the custom field in the specified language."
name: SortEnumType @cost(weight: "10")
"Group name where the custom field belongs to."
group: SortEnumType @cost(weight: "10")
"Sort order within the group."
sort: SortEnumType @cost(weight: "10")
"Data type of the custom field. Possible values: Kein = No specific type, Ganzzahl = Integer number, FliesskommaZahl = Floating point number, Text = Free text, Checkbox = Boolean checkbox, Liste = Selection list, Url = Website URL, EMail = Email address, TelNr = Phone number, LandIso = Country ISO code, Preis = Price\/Currency, Datum = Date, KurzText = Short text"
customFieldType: SortEnumType @cost(weight: "10")
"The underlying .NET data type of the CustomFieldType: 'int' for Ganzzahl and Checkbox, 'string' for Text, KurzText, Url, EMail, TelNr, LandIso, Liste, and Kein, 'decimal' for FliesskommaZahl and Preis, 'DateTime' for Datum"
dataType: SortEnumType @cost(weight: "10")
}
"Model Class: CustomerCategory"
input CustomerCategoryFilterInput {
and: [CustomerCategoryFilterInput!]
or: [CustomerCategoryFilterInput!]
"Unique internal ID of the customer category."
id: ComparableKundenKategorieKeyOperationFilterInput
"The name of the customer category."
name: StringOperationFilterInput
}
"Model Class: CustomerCategory"
input CustomerCategorySortInput {
"Unique internal ID of the customer category."
id: KundenKategorieKeySortInput @cost(weight: "10")
"The name of the customer category."
name: SortEnumType @cost(weight: "10")
}
"Model Class: CustomerGroup"
input CustomerGroupFilterInput {
and: [CustomerGroupFilterInput!]
or: [CustomerGroupFilterInput!]
"Unique internal ID of the customer group."
id: ComparableKundenGruppeKeyOperationFilterInput
"The name of the customer group."
name: StringOperationFilterInput
"Indicates if the customer group is the default group. Only one group can be selected as the default group."
isDefault: ComparableBooleanOperationFilterInput
"The discounted percentage for the customer group."
discount: ComparableDecimalOperationFilterInput
"Indicates if the customer group sees the net price in the online shop."
isNetPrice: ComparableBooleanOperationFilterInput
}
"Model Class: CustomerGroup"
input CustomerGroupSortInput {
"Unique internal ID of the customer group."
id: KundenGruppeKeySortInput @cost(weight: "10")
"The name of the customer group."
name: SortEnumType @cost(weight: "10")
"Indicates if the customer group is the default group. Only one group can be selected as the default group."
isDefault: SortEnumType @cost(weight: "10")
"The discounted percentage for the customer group."
discount: SortEnumType @cost(weight: "10")
"Indicates if the customer group sees the net price in the online shop."
isNetPrice: SortEnumType @cost(weight: "10")
}
"Single row of the customers overview table"
input CustomerListItemFilterInput {
and: [CustomerListItemFilterInput!]
or: [CustomerListItemFilterInput!]
"Customer id"
id: ComparableKundeKeyOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer's eBay user name."
ebayName: StringOperationFilterInput
"Customer's date of birth."
birthday: StringOperationFilterInput
"Customer's homepage URL."
homepage: StringOperationFilterInput
"Last name of the customer"
lastName: StringOperationFilterInput
"First name of the customer"
firstName: StringOperationFilterInput
"Phone number."
phoneNumber: StringOperationFilterInput
"Fax number."
faxNumber: StringOperationFilterInput
"Email address."
emailAddress: StringOperationFilterInput
"Company name (if applicable)."
companyName: StringOperationFilterInput
"Postal code."
postalCode: StringOperationFilterInput
"City."
city: StringOperationFilterInput
"Country name."
countryName: StringOperationFilterInput
"ISO-Code of the country."
countryIso: StringOperationFilterInput
"Company extension."
additionalCompanyLine: StringOperationFilterInput
"Formal salutation (e.g., Mr., Ms.)."
salutation: StringOperationFilterInput
"Academic or professional title."
title: StringOperationFilterInput
"Street and house number."
street: StringOperationFilterInput
"Additional address information."
additionalAddressLine: StringOperationFilterInput
"Date the customer record was created."
createdDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Mobile phone number."
mobilePhoneNumber: StringOperationFilterInput
"Customer-specific discount rate."
discountRate: ComparableNullableOfDecimalOperationFilterInput
"VAT identification number."
vatId: StringOperationFilterInput
"Subscription status for the newsletter."
hasNewsletter: ComparableBooleanOperationFilterInput
"Customer's PostID (specific delivery identifier)."
postId: StringOperationFilterInput
"Number of days for payment terms."
paymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Federal state or province."
state: StringOperationFilterInput
"Source or origin of the customer."
initialContact: StringOperationFilterInput
"Flag indicating if the customer is a cash register\/POS customer."
isCashRegisterBased: ComparableBooleanOperationFilterInput
"Account lock status."
isLocked: ComparableBooleanOperationFilterInput
"Commercial register number."
commercialRegisterNumber: StringOperationFilterInput
"Accounts receivable number for accounting."
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Name of the customer category."
customerCategoryName: StringOperationFilterInput
"Name of the customer group."
customerGroupName: StringOperationFilterInput
"Key\/ID of the customer category."
customerCategoryId: ComparableKundenKategorieKeyOperationFilterInput
"Key\/ID of the customer group."
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Flag indicating participation in JTL Fulfillment."
isJtlFulfillment: ComparableBooleanOperationFilterInput
"Comma-separated list of all assigned customer labels."
labels: StringOperationFilterInput
"The language iso code of the customer"
languageIso: StringOperationFilterInput
}
"Single row of the customers overview table"
input CustomerListItemSortInput {
"Customer id"
id: KundeKeySortInput @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer's eBay user name."
ebayName: SortEnumType @cost(weight: "10")
"Customer's date of birth."
birthday: SortEnumType @cost(weight: "10")
"Customer's homepage URL."
homepage: SortEnumType @cost(weight: "10")
"Last name of the customer"
lastName: SortEnumType @cost(weight: "10")
"First name of the customer"
firstName: SortEnumType @cost(weight: "10")
"Phone number."
phoneNumber: SortEnumType @cost(weight: "10")
"Fax number."
faxNumber: SortEnumType @cost(weight: "10")
"Email address."
emailAddress: SortEnumType @cost(weight: "10")
"Company name (if applicable)."
companyName: SortEnumType @cost(weight: "10")
"Postal code."
postalCode: SortEnumType @cost(weight: "10")
"City."
city: SortEnumType @cost(weight: "10")
"Country name."
countryName: SortEnumType @cost(weight: "10")
"ISO-Code of the country."
countryIso: SortEnumType @cost(weight: "10")
"Company extension."
additionalCompanyLine: SortEnumType @cost(weight: "10")
"Formal salutation (e.g., Mr., Ms.)."
salutation: SortEnumType @cost(weight: "10")
"Academic or professional title."
title: SortEnumType @cost(weight: "10")
"Street and house number."
street: SortEnumType @cost(weight: "10")
"Additional address information."
additionalAddressLine: SortEnumType @cost(weight: "10")
"Date the customer record was created."
createdDate: SortEnumType @cost(weight: "10")
"Mobile phone number."
mobilePhoneNumber: SortEnumType @cost(weight: "10")
"Customer-specific discount rate."
discountRate: SortEnumType @cost(weight: "10")
"VAT identification number."
vatId: SortEnumType @cost(weight: "10")
"Subscription status for the newsletter."
hasNewsletter: SortEnumType @cost(weight: "10")
"Customer's PostID (specific delivery identifier)."
postId: SortEnumType @cost(weight: "10")
"Number of days for payment terms."
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Federal state or province."
state: SortEnumType @cost(weight: "10")
"Source or origin of the customer."
initialContact: SortEnumType @cost(weight: "10")
"Flag indicating if the customer is a cash register\/POS customer."
isCashRegisterBased: SortEnumType @cost(weight: "10")
"Account lock status."
isLocked: SortEnumType @cost(weight: "10")
"Commercial register number."
commercialRegisterNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number for accounting."
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Name of the customer category."
customerCategoryName: SortEnumType @cost(weight: "10")
"Name of the customer group."
customerGroupName: SortEnumType @cost(weight: "10")
"Key\/ID of the customer category."
customerCategoryId: KundenKategorieKeySortInput @cost(weight: "10")
"Key\/ID of the customer group."
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Flag indicating participation in JTL Fulfillment."
isJtlFulfillment: SortEnumType @cost(weight: "10")
"Comma-separated list of all assigned customer labels."
labels: SortEnumType @cost(weight: "10")
"The language iso code of the customer"
languageIso: SortEnumType @cost(weight: "10")
}
"Deactivates a bin location, making it unavailable for operations. - Request"
input DeactivateBinLocationCommandRequestInput {
"Unique identifier of the bin location to deactivate."
binLocationId: ID!
}
"Deactivates a language in the system - Request"
input DeactivateLanguageCommandRequestInput {
"The culture or ISO code of the language to be deactivate."
cultureOrIso: String!
}
"Deletes a bill of materials. - Request"
input DeleteBillOfMaterialsCommandRequestInput {
"The ID of the bill of materials to be deleted."
id: ID!
}
"Deletes a bill of materials item from a bill of materials. - Request"
input DeleteBillOfMaterialsItemCommandRequestInput {
"The ID of the bill of materials item to be deleted."
id: ID!
}
"Deletes a bill of materials operation from a bill of materials. - Request"
input DeleteBillOfMaterialsOperationCommandRequestInput {
"The ID of the bill of materials operation to be deleted."
id: ID!
}
"Deletes a bin location from the warehouse. - Request"
input DeleteBinLocationCommandRequestInput {
"Unique identifier of the bin location to delete."
binLocationId: ID!
}
"Delete a Category - Request"
input DeleteCategoryCommandRequestInput {
"The category to delete"
id: ID!
"The destination category to which all remaining child categories will be moved."
moveChildrenTargetId: ID
}
"Removes an existing variation from an item. All associated variation values and combinations will also be removed. - Request"
input DeleteItemVariationCommandRequestInput {
"Unique ID of the variation to be deleted."
variationId: ID!
}
"Removes a specific value from an item variation. - Request"
input DeleteItemVariationValueCommandRequestInput {
"Unique ID of the variation value to be deleted."
variationValueId: ID!
}
"Deletes the specified marketplace offers. - Request"
input DeleteMarketplaceOfferCommandRequestInput {
"Marketplace offer keys to delete."
offerKeys: [ID]!
"If true, related marketplace assignment data is removed from items as well."
removeDataFromItem: Boolean!
}
"Delete existing product groups. - Request"
input DeleteProductGroupsCommandRequestInput {
"IDs of the product groups to delete."
ids: [ID]!
}
"Permanently deletes a shipping box and all its attributes (Rule SB-8). - Request"
input DeleteShippingBoxCommandRequestInput {
"The shipping box to delete."
shippingBoxId: ID!
}
"Deletes an existing tax class - Request"
input DeleteTaxClassCommandRequestInput {
"The ID of the tax class to delete"
id: ID!
}
"Deletes an existing tax code - Request"
input DeleteTaxCodeCommandRequestInput {
"The ID of the tax code to delete"
id: ID!
}
"Deletes a warehouse zone. - Request"
input DeleteWarehouseZoneCommandRequestInput {
"The zone to delete."
zoneId: ID!
}
"Creates one or more duplicates of an existing item with specified duplication options. - Request"
input DuplicateItemsCommandRequestInput {
"The unique identifier of the source item to be duplicated."
duplicateItemId: ID!
"The basic information (SKU and name) for the items to be created as duplicates."
duplicatesToCreate: [CreateItemDuplicateInput!]!
"Indicates whether the item creation workflow should be executed after creating the duplicates."
executeItemCreatedWorkflowOnCreation: Boolean!
"Specifies which properties and aspects of the source item should be duplicated to the new items."
itemDuplicationOptions: CreateItemDuplicationOptionsInput!
}
input EigenesFeldKeySortInput {
kAttribut: SortEnumType @cost(weight: "10")
}
"Last tracked bin location activity per employee."
input EmployeeLocationItemFilterInput {
and: [EmployeeLocationItemFilterInput!]
or: [EmployeeLocationItemFilterInput!]
"Employee user ID (kBenutzer)."
userIdentifier: ComparableInt32OperationFilterInput
"Employee display name."
userName: StringOperationFilterInput
"Timestamp of the last tracked activity."
lastActivityTimestamp: ComparableDateTimeOperationFilterInput
"Bin location where the last activity occurred."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Activity type of the last activity."
activityTypeId: ComparableBuchungsArtKeyOperationFilterInput
"Display name of the activity type."
activityTypeName: StringOperationFilterInput
}
"Last tracked bin location activity per employee."
input EmployeeLocationItemSortInput {
"Employee user ID (kBenutzer)."
userIdentifier: SortEnumType @cost(weight: "10")
"Employee display name."
userName: SortEnumType @cost(weight: "10")
"Timestamp of the last tracked activity."
lastActivityTimestamp: SortEnumType @cost(weight: "10")
"Display name of the activity type."
activityTypeName: SortEnumType @cost(weight: "10")
}
"Exclude marketplace invoice corrections from upload. - Request"
input ExcludeMarketplaceInvoiceCorrectionFromUploadCommandRequestInput {
"Marketplace order keys of invoice corrections to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace invoice correction PDFs from upload. - Request"
input ExcludeMarketplaceInvoiceCorrectionPdfFromUploadCommandRequestInput {
"Upload document IDs of invoice correction PDFs to exclude from upload."
documentUploadQueueKeys: [ID]!
}
"Exclude marketplace invoice PDFs from upload. - Request"
input ExcludeMarketplaceInvoicePdfFromUploadCommandRequestInput {
"Upload document IDs of invoice PDFs to exclude from upload."
documentUploadQueueKeys: [ID]!
}
"Exclude marketplace order cancellation uploads from upload. - Request"
input ExcludeMarketplaceOrderCancellationUploadFromUploadCommandRequestInput {
"Marketplace order keys of cancellation uploads to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace payment uploads from upload. - Request"
input ExcludeMarketplacePaymentUploadFromUploadCommandRequestInput {
"Marketplace order keys of payment uploads to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace return uploads from upload. - Request"
input ExcludeMarketplaceReturnUploadFromUploadCommandRequestInput {
"Marketplace order keys of return uploads to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace shipping information uploads from upload. - Request"
input ExcludeMarketplaceShippingInformationUploadFromUploadCommandRequestInput {
"Marketplace order shipping keys of shipping information uploads to exclude from upload."
orderShippingKeys: [ID]!
}
input ExternalDocumentInternalFilterInput {
and: [ExternalDocumentInternalFilterInput!]
or: [ExternalDocumentInternalFilterInput!]
"Primary key of document"
externalDocumentTransactionId: ComparableExternerBelegTransaktionKeyOperationFilterInput
"Primary key of company"
companyId: ComparableFirmaKeyOperationFilterInput
"Primary key of customer"
customerId: ComparableKundeKeyOperationFilterInput
"Primary key of platform"
platformId: ComparablePlattformKeyOperationFilterInput
"Primary key of payment type document"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Primary key of invoice"
externalInvoiceDocumentId: ComparableExternerBelegKeyOperationFilterInput
"Invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Credit note number"
externalDocumentNumber: StringOperationFilterInput
"Document date"
externalDocumentDate: ComparableDateTimeOffsetOperationFilterInput
"External order number"
externalDocumentOrderNumber: StringOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Currency code"
currency: StringOperationFilterInput
"Shipping currency code"
departureCountryCurrencyIso: StringOperationFilterInput
"Shipping currency factor"
departureCountryCurrenyFactor: ComparableNullableOfDecimalOperationFilterInput
"Service date"
serviceDate: ComparableDateTimeOffsetOperationFilterInput
"Payment date"
payDate: ComparableDateTimeOffsetOperationFilterInput
"Platform ID"
platformIdentifier: StringOperationFilterInput
"Debtor number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Tax setting"
taxSetting: ComparableByteOperationFilterInput
"Document type"
externalDocumentType: ComparableByteOperationFilterInput
"Country VAT ID"
companyVatIdNumber: StringOperationFilterInput
"Seller VAT ID"
customerVatIdNumber: StringOperationFilterInput
"Shipping country ISO code"
departureCountryIso: StringOperationFilterInput
"Payment information"
paymentMethodName: StringOperationFilterInput
"Order date"
orderDate: ComparableDateTimeOffsetOperationFilterInput
"Shipping company name"
shipmentAddressCompany: StringOperationFilterInput
"Shipping last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipping street address"
shipmentAddressStreet: StringOperationFilterInput
"Shipping ZIP code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipping city"
shipmentAddressCity: StringOperationFilterInput
"Shipping phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipping additional address information"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipping country ISO code"
shipmentAddressCountryIso: StringOperationFilterInput
"Shipping VAT ID"
shipmentAddressVatIdNumber: StringOperationFilterInput
"Customer company name"
customerDefaultBillingAddressCompany: StringOperationFilterInput
"Customer salutation"
customerDefaultBillingAddressSalutation: StringOperationFilterInput
"Customer title"
customerDefaultBillingAddressTitle: StringOperationFilterInput
"Customer first name"
customerDefaultBillingAddressFirstName: StringOperationFilterInput
"Customer last name"
customerDefaultBillingAddressLastName: StringOperationFilterInput
"Customer street address"
customerDefaultBillingAddressStreet: StringOperationFilterInput
"Customer ZIP code"
customerDefaultBillingAddressPostalCode: StringOperationFilterInput
"Customer city"
customerDefaultBillingAddressCity: StringOperationFilterInput
"Customer country"
customerDefaultBillingAddressCountry: StringOperationFilterInput
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerDefaultBillingAddressFaxNumber: StringOperationFilterInput
"Customer additional information"
customerDefaultBillingAddressForTheAttentionOf: StringOperationFilterInput
"Customer country ISO code"
customerDefaultBillingAddressCountryIso: StringOperationFilterInput
"Customer email address"
customerDefaultBillingAddressEmailAddress: StringOperationFilterInput
"Customer VAT ID"
customerDefaultBillingAddressVatIdNumber: StringOperationFilterInput
"Customer number from sales order"
salesOrderCustomerNumber: StringOperationFilterInput
"Customer group"
customerGroupName: StringOperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableInt32OperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Invoice company name"
billingAddressCompany: StringOperationFilterInput
"Invoice last name"
billingAddressLastName: StringOperationFilterInput
"Invoice street address"
billingAddressStreet: StringOperationFilterInput
"Invoice ZIP code"
billingAddressPostalCode: StringOperationFilterInput
"Invoice city"
billingAddressCity: StringOperationFilterInput
"Invoice phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Invoice additional address information"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Invoice country ISO code"
billingAddressCountryIso: StringOperationFilterInput
"Invoice VAT ID"
billingAddressVatIdNumber: StringOperationFilterInput
"Document total gross value"
externalDocumentTotalGrossValue: ComparableDecimalOperationFilterInput
"Document total net value"
externalDocumentTotalNetValue: ComparableDecimalOperationFilterInput
"Shipping date"
shipmentDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Order payment type"
orderPaymentMethodName: StringOperationFilterInput
"Shipping country count"
shipmentCountryCount: ComparableInt32OperationFilterInput
}
input ExternalDocumentInternalSortInput {
"Primary key of document"
externalDocumentTransactionId: ExternerBelegTransaktionKeySortInput @cost(weight: "10")
"Primary key of company"
companyId: FirmaKeySortInput @cost(weight: "10")
"Primary key of customer"
customerId: KundeKeySortInput @cost(weight: "10")
"Primary key of platform"
platformId: PlattformKeySortInput @cost(weight: "10")
"Primary key of payment type document"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Primary key of invoice"
externalInvoiceDocumentId: ExternerBelegKeySortInput @cost(weight: "10")
"Invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Credit note number"
externalDocumentNumber: SortEnumType @cost(weight: "10")
"Document date"
externalDocumentDate: SortEnumType @cost(weight: "10")
"External order number"
externalDocumentOrderNumber: SortEnumType @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Currency code"
currency: SortEnumType @cost(weight: "10")
"Shipping currency code"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Shipping currency factor"
departureCountryCurrenyFactor: SortEnumType @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Payment date"
payDate: SortEnumType @cost(weight: "10")
"Platform ID"
platformIdentifier: SortEnumType @cost(weight: "10")
"Debtor number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"Document type"
externalDocumentType: SortEnumType @cost(weight: "10")
"Country VAT ID"
companyVatIdNumber: SortEnumType @cost(weight: "10")
"Seller VAT ID"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"Shipping country ISO code"
departureCountryIso: SortEnumType @cost(weight: "10")
"Payment information"
paymentMethodName: SortEnumType @cost(weight: "10")
"Order date"
orderDate: SortEnumType @cost(weight: "10")
"Shipping company name"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipping last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipping street address"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipping ZIP code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipping city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipping phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipping additional address information"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipping country ISO code"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipping VAT ID"
shipmentAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer company name"
customerDefaultBillingAddressCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerDefaultBillingAddressSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerDefaultBillingAddressTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerDefaultBillingAddressFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerDefaultBillingAddressLastName: SortEnumType @cost(weight: "10")
"Customer street address"
customerDefaultBillingAddressStreet: SortEnumType @cost(weight: "10")
"Customer ZIP code"
customerDefaultBillingAddressPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerDefaultBillingAddressCity: SortEnumType @cost(weight: "10")
"Customer country"
customerDefaultBillingAddressCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerDefaultBillingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Customer additional information"
customerDefaultBillingAddressForTheAttentionOf: SortEnumType @cost(weight: "10")
"Customer country ISO code"
customerDefaultBillingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer email address"
customerDefaultBillingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer VAT ID"
customerDefaultBillingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number from sales order"
salesOrderCustomerNumber: SortEnumType @cost(weight: "10")
"Customer group"
customerGroupName: SortEnumType @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Invoice company name"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Invoice last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Invoice street address"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Invoice ZIP code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Invoice city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Invoice phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Invoice additional address information"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Invoice country ISO code"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Invoice VAT ID"
billingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Document total gross value"
externalDocumentTotalGrossValue: SortEnumType @cost(weight: "10")
"Document total net value"
externalDocumentTotalNetValue: SortEnumType @cost(weight: "10")
"Shipping date"
shipmentDate: SortEnumType @cost(weight: "10")
"Order payment type"
orderPaymentMethodName: SortEnumType @cost(weight: "10")
"Shipping country count"
shipmentCountryCount: SortEnumType @cost(weight: "10")
}
input ExternalDocumentLineItemInternalFilterInput {
and: [ExternalDocumentLineItemInternalFilterInput!]
or: [ExternalDocumentLineItemInternalFilterInput!]
"External document line item ID"
externalDocumentLineItemId: ComparableExternerBelegPositionKeyOperationFilterInput
"External document ID"
externalDocumentId: ComparableExternerBelegKeyOperationFilterInput
"Sales price gross"
externalDocumentSalesPriceGross: ComparableDecimalOperationFilterInput
"External document sales price net"
externalDocumentSalesPriceNet: ComparableDecimalOperationFilterInput
"External document purchase price net"
externalDocumentPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Quantity"
quantity: ComparableDecimalOperationFilterInput
"Item name"
itemName: StringOperationFilterInput
"SKU"
sku: StringOperationFilterInput
"Tax rate"
taxRate: ComparableDecimalOperationFilterInput
"Tax class ID"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Taric code"
taric: StringOperationFilterInput
"Item weight"
itemWeight: ComparableNullableOfDecimalOperationFilterInput
"Item volume"
itemVolume: ComparableNullableOfDecimalOperationFilterInput
"Product group ID"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Purchase price net"
purchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Product group"
productGroup: StringOperationFilterInput
"Warehouse ID"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"External document invoice line item ID"
externalDocumentInvoiceLineItemId: ComparableExternerBelegPositionKeyOperationFilterInput
}
input ExternalDocumentLineItemInternalSortInput {
"External document line item ID"
externalDocumentLineItemId: ExternerBelegPositionKeySortInput @cost(weight: "10")
"External document ID"
externalDocumentId: ExternerBelegKeySortInput @cost(weight: "10")
"Sales price gross"
externalDocumentSalesPriceGross: SortEnumType @cost(weight: "10")
"External document sales price net"
externalDocumentSalesPriceNet: SortEnumType @cost(weight: "10")
"External document purchase price net"
externalDocumentPurchasePriceNet: SortEnumType @cost(weight: "10")
"Quantity"
quantity: SortEnumType @cost(weight: "10")
"Item name"
itemName: SortEnumType @cost(weight: "10")
"SKU"
sku: SortEnumType @cost(weight: "10")
"Tax rate"
taxRate: SortEnumType @cost(weight: "10")
"Tax class ID"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Taric code"
taric: SortEnumType @cost(weight: "10")
"Item weight"
itemWeight: SortEnumType @cost(weight: "10")
"Item volume"
itemVolume: SortEnumType @cost(weight: "10")
"Product group ID"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Purchase price net"
purchasePriceNet: SortEnumType @cost(weight: "10")
"Product group"
productGroup: SortEnumType @cost(weight: "10")
"Warehouse ID"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"External document invoice line item ID"
externalDocumentInvoiceLineItemId: ExternerBelegPositionKeySortInput @cost(weight: "10")
}
"ExternerBeleg Key"
input ExternerBelegKeySortInput {
"Gets the identifier for ExternerBeleg"
kExternerBeleg: SortEnumType @cost(weight: "10")
}
"ExternerBeleg Key"
input ExternerBelegPositionKeySortInput {
"Gets the identifier for ExternerBeleg"
kExternerBelegPosition: SortEnumType @cost(weight: "10")
}
"ExternerBeleg Key"
input ExternerBelegTransaktionKeySortInput {
"Gets the identifier for ExternerBelegTransaktion"
kExternerBelegTransaktion: SortEnumType @cost(weight: "10")
}
"Represents a key for identifying a firm within the application."
input FirmaKeySortInput {
"Gets the unique identifier for the firm."
kFirma: SortEnumType @cost(weight: "10")
}
input GutschriftKeySortInput {
kGutschrift: SortEnumType @cost(weight: "10")
}
input GutschriftPosKeySortInput {
kGutschriftPos: SortEnumType @cost(weight: "10")
}
input HerstellerKeySortInput {
kHersteller: SortEnumType @cost(weight: "10")
}
"Single row of the item overview"
input ItemListItemFilterInput {
and: [ItemListItemFilterInput!]
or: [ItemListItemFilterInput!]
"Item id"
id: ComparableArtikelKeyOperationFilterInput
"Bill of materials ID"
billOfMaterialsId: ComparableNullableOfInt32OperationFilterInput
"Parent item ID (for variation children)"
parentItemId: ComparableArtikelKeyOperationFilterInput
"Item id for category search"
itemIdForCategoryItemId: ComparableArtikelKeyOperationFilterInput
"Item number"
sku: StringOperationFilterInput
"Sort number for display ordering"
sortNumber: ComparableInt32OperationFilterInput
"Name of the item in the requested language"
name: StringOperationFilterInput
"Sales unit name"
unit: StringOperationFilterInput
"Item description (first 255 chars)"
description: StringOperationFilterInput
"Short description (first 255 chars)"
shortDescription: StringOperationFilterInput
"Notes of the item"
notes: StringOperationFilterInput
"Label names"
labels: StringOperationFilterInput
"Series name"
series: StringOperationFilterInput
"GTIN (former EAN) of the item"
gtin: StringOperationFilterInput
"Manufacturer number of the item"
manufacturerNumber: StringOperationFilterInput
"ISBN of the item"
isbn: StringOperationFilterInput
"Default ASIN of the item"
defaultAsin: StringOperationFilterInput
"TaricCode of the item"
taricCode: StringOperationFilterInput
"UPC of the item"
upc: StringOperationFilterInput
"UNNumber of the item"
unNumber: StringOperationFilterInput
"HazardNumber of the item"
hazardNumber: StringOperationFilterInput
"Amazon FNSKU"
amazonFnsku: StringOperationFilterInput
"Identifier for JTL Fulfillment Network"
jfsku: StringOperationFilterInput
"Country of origin"
countryOfOrigin: StringOperationFilterInput
"Name of the manufacturer"
manufacturerName: StringOperationFilterInput
"Delivery status name"
deliveryStatus: StringOperationFilterInput
"Automatic delivery time calculation active"
isDeliveryTimeAutomatic: ComparableBooleanOperationFilterInput
"Manual delivery time in days"
manualDeliveryTimeDays: ComparableNullableOfInt32OperationFilterInput
"Item width"
width: ComparableDecimalOperationFilterInput
"Item height"
height: ComparableDecimalOperationFilterInput
"Item length"
length: ComparableDecimalOperationFilterInput
"Shipping weight"
shippingWeight: ComparableDecimalOperationFilterInput
"Item weight (without packaging)"
weight: ComparableDecimalOperationFilterInput
"Creation date of the item"
createdDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Last modification date (date only)"
modifiedDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Last modification timestamp (date and time)"
modifiedTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Release date of the item"
releaseDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date of last purchase"
lastPurchaseDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Name of the last editor"
lastEditor: StringOperationFilterInput
"Item Net Price"
salesPriceNet: ComparableDecimalOperationFilterInput
"Sales price gross (including tax)"
salesPriceGross: ComparableDecimalOperationFilterInput
"UVP"
suggestedRetailPrice: ComparableDecimalOperationFilterInput
"Average purchase price net"
averagePurchasePriceNet: ComparableDecimalOperationFilterInput
"Last Purchase Net Price"
lastPurchasePrice: ComparableDecimalOperationFilterInput
"AmazonPrice Net Price"
amazonPrice: ComparableDecimalOperationFilterInput
"EbayPrice Net Price"
ebayPrice: ComparableDecimalOperationFilterInput
"Profit of this item"
profit: ComparableNullableOfDecimalOperationFilterInput
"Profit in percent"
profitPercent: ComparableDecimalOperationFilterInput
"Special price status (0 = no special price, 1 = expired, 2 = active)"
specialPriceStatus: ComparableInt32OperationFilterInput
"Base price value"
basePriceValue: ComparableNullableOfDecimalOperationFilterInput
"Base price unit display code"
basePriceUnit: StringOperationFilterInput
"Measurement unit name"
measurementUnit: StringOperationFilterInput
"Total stock in all warehouses"
stockTotal: ComparableDecimalOperationFilterInput
"Own Stock (without children\/variations)"
stockOwn: ComparableDecimalOperationFilterInput
"Stock incoming"
stockIncoming: ComparableDecimalOperationFilterInput
"Stock on purchase list"
stockOnPurchaseList: ComparableDecimalOperationFilterInput
"Total stock in orders"
stockInOrders: ComparableDecimalOperationFilterInput
"Available stock"
stockAvailable: ComparableDecimalOperationFilterInput
"Total stock reserved"
stockReservedTotal: ComparableDecimalOperationFilterInput
"Stock in Amazon offers"
stockInAmazonOffers: ComparableInt32OperationFilterInput
"Stock in eBay listings"
ebayStock: ComparableDecimalOperationFilterInput
"Minimum order quantity"
minimumOrderQuantity: ComparableDecimalOperationFilterInput
"Purchase interval"
purchaseInterval: ComparableDecimalOperationFilterInput
"The item buffer"
buffer: ComparableInt32OperationFilterInput
"The Item minimum stock level"
minimumStock: ComparableDecimalOperationFilterInput
"Determines if negative stock is allowed for this item"
allowNegativeStock: ComparableBooleanOperationFilterInput
"Determines if the item is working with inventory management"
isInventoryManagementActive: ComparableBooleanOperationFilterInput
"Determines if the item is working with split quantities in stock"
isDivisible: ComparableBooleanOperationFilterInput
"The Item HasBatch"
hasBatch: ComparableBooleanOperationFilterInput
"Determines if the item is working with best before date (MHD)"
hasBestBeforeDate: ComparableBooleanOperationFilterInput
"If the item uses serial number management."
isSerialNumberManaged: ComparableBooleanOperationFilterInput
"Serial number tracking flag"
serialNumberTrackingMode: ComparableSerialNumberTrackingModeOperationFilterInput
"Indicates if the item is active"
isActive: ComparableBooleanOperationFilterInput
"Is on price list flag"
isOnPriceList: ComparableBooleanOperationFilterInput
"Is top item flag"
isTopItem: ComparableBooleanOperationFilterInput
"Is new item flag"
isNew: ComparableBooleanOperationFilterInput
"Is bill of materials"
isBillOfMaterials: ComparableBooleanOperationFilterInput
"Is bill of materials component"
isBillOfMaterialsComponent: ComparableBooleanOperationFilterInput
"Is variation parent"
isVariationParent: ComparableBooleanOperationFilterInput
"Is variation child"
isVariationChild: ComparableBooleanOperationFilterInput
"Has minimum stock level"
hasMinimumStock: ComparableBooleanOperationFilterInput
"Is blocked for order suggestions"
isBlockedForOrderSuggestions: ComparableBooleanOperationFilterInput
"Is active in at least one shop"
isShopActive: ComparableBooleanOperationFilterInput
"No order process flag"
isOrderProcessProhibited: ComparableBooleanOperationFilterInput
"Sales packaging unit (VPE)"
salesPackagingUnit: ComparableNullableOfByteOperationFilterInput
"Condition ID"
conditionId: ComparableZustandKeyOperationFilterInput
"Condition name"
conditionName: StringOperationFilterInput
"Determines if the item is being shared in the JTL Fulfillment Network"
isFulfillmentActive: ComparableBooleanOperationFilterInput
"Determines if the item is managed by this client"
isFulfillmentOwn: ComparableBooleanOperationFilterInput
"Tax class ID"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Name of the tax class"
taxClassName: StringOperationFilterInput
"Manufacturer ID"
manufacturerId: ComparableHerstellerKeyOperationFilterInput
"Product group ID"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Name of the ProductGroup"
productGroupName: StringOperationFilterInput
"Default supplier ID"
defaultSupplierId: ComparableLieferantKeyOperationFilterInput
"Name of the Default Supplier"
defaultSupplier: StringOperationFilterInput
"Shipping class ID"
shippingClassId: ComparableVersandklasseKeyOperationFilterInput
"Shipping class name"
shippingClassName: StringOperationFilterInput
"The id of the default image."
defaultImageId: ComparableBildKeyOperationFilterInput
"Additional processing time in days"
additionalProcessingTime: ComparableNullableOfInt32OperationFilterInput
"Meta description for SEO (first 255 chars)"
metaDescription: StringOperationFilterInput
"Title tag for SEO (first 255 chars)"
titleTag: StringOperationFilterInput
"Meta keywords for SEO (first 255 chars)"
metaKeywords: StringOperationFilterInput
"Language ID for descriptions"
languageId: ComparableSpracheKeyOperationFilterInput
"Company ID"
companyId: ComparableFirmaKeyOperationFilterInput
}
"Single row of the item overview"
input ItemListItemSortInput {
"Item id"
id: ArtikelKeySortInput @cost(weight: "10")
"Bill of materials ID"
billOfMaterialsId: SortEnumType @cost(weight: "10")
"Parent item ID (for variation children)"
parentItemId: ArtikelKeySortInput @cost(weight: "10")
"Item id for category search"
itemIdForCategoryItemId: ArtikelKeySortInput @cost(weight: "10")
"Item number"
sku: SortEnumType @cost(weight: "10")
"Sort number for display ordering"
sortNumber: SortEnumType @cost(weight: "10")
"Name of the item in the requested language"
name: SortEnumType @cost(weight: "10")
"Sales unit name"
unit: SortEnumType @cost(weight: "10")
"Item description (first 255 chars)"
description: SortEnumType @cost(weight: "10")
"Short description (first 255 chars)"
shortDescription: SortEnumType @cost(weight: "10")
"Notes of the item"
notes: SortEnumType @cost(weight: "10")
"Label names"
labels: SortEnumType @cost(weight: "10")
"Series name"
series: SortEnumType @cost(weight: "10")
"GTIN (former EAN) of the item"
gtin: SortEnumType @cost(weight: "10")
"Manufacturer number of the item"
manufacturerNumber: SortEnumType @cost(weight: "10")
"ISBN of the item"
isbn: SortEnumType @cost(weight: "10")
"Default ASIN of the item"
defaultAsin: SortEnumType @cost(weight: "10")
"TaricCode of the item"
taricCode: SortEnumType @cost(weight: "10")
"UPC of the item"
upc: SortEnumType @cost(weight: "10")
"UNNumber of the item"
unNumber: SortEnumType @cost(weight: "10")
"HazardNumber of the item"
hazardNumber: SortEnumType @cost(weight: "10")
"Amazon FNSKU"
amazonFnsku: SortEnumType @cost(weight: "10")
"Identifier for JTL Fulfillment Network"
jfsku: SortEnumType @cost(weight: "10")
"Country of origin"
countryOfOrigin: SortEnumType @cost(weight: "10")
"Name of the manufacturer"
manufacturerName: SortEnumType @cost(weight: "10")
"Delivery status name"
deliveryStatus: SortEnumType @cost(weight: "10")
"Automatic delivery time calculation active"
isDeliveryTimeAutomatic: SortEnumType @cost(weight: "10")
"Manual delivery time in days"
manualDeliveryTimeDays: SortEnumType @cost(weight: "10")
"Item width"
width: SortEnumType @cost(weight: "10")
"Item height"
height: SortEnumType @cost(weight: "10")
"Item length"
length: SortEnumType @cost(weight: "10")
"Shipping weight"
shippingWeight: SortEnumType @cost(weight: "10")
"Item weight (without packaging)"
weight: SortEnumType @cost(weight: "10")
"Creation date of the item"
createdDate: SortEnumType @cost(weight: "10")
"Last modification date (date only)"
modifiedDate: SortEnumType @cost(weight: "10")
"Last modification timestamp (date and time)"
modifiedTimestamp: SortEnumType @cost(weight: "10")
"Release date of the item"
releaseDate: SortEnumType @cost(weight: "10")
"Date of last purchase"
lastPurchaseDate: SortEnumType @cost(weight: "10")
"Name of the last editor"
lastEditor: SortEnumType @cost(weight: "10")
"Item Net Price"
salesPriceNet: SortEnumType @cost(weight: "10")
"Sales price gross (including tax)"
salesPriceGross: SortEnumType @cost(weight: "10")
"UVP"
suggestedRetailPrice: SortEnumType @cost(weight: "10")
"Average purchase price net"
averagePurchasePriceNet: SortEnumType @cost(weight: "10")
"Last Purchase Net Price"
lastPurchasePrice: SortEnumType @cost(weight: "10")
"AmazonPrice Net Price"
amazonPrice: SortEnumType @cost(weight: "10")
"EbayPrice Net Price"
ebayPrice: SortEnumType @cost(weight: "10")
"Profit of this item"
profit: SortEnumType @cost(weight: "10")
"Profit in percent"
profitPercent: SortEnumType @cost(weight: "10")
"Special price status (0 = no special price, 1 = expired, 2 = active)"
specialPriceStatus: SortEnumType @cost(weight: "10")
"Base price value"
basePriceValue: SortEnumType @cost(weight: "10")
"Base price unit display code"
basePriceUnit: SortEnumType @cost(weight: "10")
"Measurement unit name"
measurementUnit: SortEnumType @cost(weight: "10")
"Total stock in all warehouses"
stockTotal: SortEnumType @cost(weight: "10")
"Own Stock (without children\/variations)"
stockOwn: SortEnumType @cost(weight: "10")
"Stock incoming"
stockIncoming: SortEnumType @cost(weight: "10")
"Stock on purchase list"
stockOnPurchaseList: SortEnumType @cost(weight: "10")
"Total stock in orders"
stockInOrders: SortEnumType @cost(weight: "10")
"Available stock"
stockAvailable: SortEnumType @cost(weight: "10")
"Total stock reserved"
stockReservedTotal: SortEnumType @cost(weight: "10")
"Stock in Amazon offers"
stockInAmazonOffers: SortEnumType @cost(weight: "10")
"Stock in eBay listings"
ebayStock: SortEnumType @cost(weight: "10")
"Minimum order quantity"
minimumOrderQuantity: SortEnumType @cost(weight: "10")
"Purchase interval"
purchaseInterval: SortEnumType @cost(weight: "10")
"The item buffer"
buffer: SortEnumType @cost(weight: "10")
"The Item minimum stock level"
minimumStock: SortEnumType @cost(weight: "10")
"Determines if negative stock is allowed for this item"
allowNegativeStock: SortEnumType @cost(weight: "10")
"Determines if the item is working with inventory management"
isInventoryManagementActive: SortEnumType @cost(weight: "10")
"Determines if the item is working with split quantities in stock"
isDivisible: SortEnumType @cost(weight: "10")
"The Item HasBatch"
hasBatch: SortEnumType @cost(weight: "10")
"Determines if the item is working with best before date (MHD)"
hasBestBeforeDate: SortEnumType @cost(weight: "10")
"If the item uses serial number management."
isSerialNumberManaged: SortEnumType @cost(weight: "10")
"Serial number tracking flag"
serialNumberTrackingMode: SortEnumType @cost(weight: "10")
"Indicates if the item is active"
isActive: SortEnumType @cost(weight: "10")
"Is on price list flag"
isOnPriceList: SortEnumType @cost(weight: "10")
"Is top item flag"
isTopItem: SortEnumType @cost(weight: "10")
"Is new item flag"
isNew: SortEnumType @cost(weight: "10")
"Is bill of materials"
isBillOfMaterials: SortEnumType @cost(weight: "10")
"Is bill of materials component"
isBillOfMaterialsComponent: SortEnumType @cost(weight: "10")
"Is variation parent"
isVariationParent: SortEnumType @cost(weight: "10")
"Is variation child"
isVariationChild: SortEnumType @cost(weight: "10")
"Has minimum stock level"
hasMinimumStock: SortEnumType @cost(weight: "10")
"Is blocked for order suggestions"
isBlockedForOrderSuggestions: SortEnumType @cost(weight: "10")
"Is active in at least one shop"
isShopActive: SortEnumType @cost(weight: "10")
"No order process flag"
isOrderProcessProhibited: SortEnumType @cost(weight: "10")
"Sales packaging unit (VPE)"
salesPackagingUnit: SortEnumType @cost(weight: "10")
"Condition ID"
conditionId: ZustandKeySortInput @cost(weight: "10")
"Condition name"
conditionName: SortEnumType @cost(weight: "10")
"Determines if the item is being shared in the JTL Fulfillment Network"
isFulfillmentActive: SortEnumType @cost(weight: "10")
"Determines if the item is managed by this client"
isFulfillmentOwn: SortEnumType @cost(weight: "10")
"Tax class ID"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Name of the tax class"
taxClassName: SortEnumType @cost(weight: "10")
"Manufacturer ID"
manufacturerId: HerstellerKeySortInput @cost(weight: "10")
"Product group ID"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Name of the ProductGroup"
productGroupName: SortEnumType @cost(weight: "10")
"Default supplier ID"
defaultSupplierId: LieferantKeySortInput @cost(weight: "10")
"Name of the Default Supplier"
defaultSupplier: SortEnumType @cost(weight: "10")
"Shipping class ID"
shippingClassId: VersandklasseKeySortInput @cost(weight: "10")
"Shipping class name"
shippingClassName: SortEnumType @cost(weight: "10")
"The id of the default image."
defaultImageId: BildKeySortInput @cost(weight: "10")
"Additional processing time in days"
additionalProcessingTime: SortEnumType @cost(weight: "10")
"Meta description for SEO (first 255 chars)"
metaDescription: SortEnumType @cost(weight: "10")
"Title tag for SEO (first 255 chars)"
titleTag: SortEnumType @cost(weight: "10")
"Meta keywords for SEO (first 255 chars)"
metaKeywords: SortEnumType @cost(weight: "10")
"Language ID for descriptions"
languageId: SpracheKeySortInput @cost(weight: "10")
"Company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
}
"Model Class: ItemSupplierListItem"
input ItemSupplierListItemFilterInput {
and: [ItemSupplierListItemFilterInput!]
or: [ItemSupplierListItemFilterInput!]
"Id of the item supplier"
id: ComparableLieferantenArtikelKeyOperationFilterInput
"Id of the item"
itemId: ComparableArtikelKeyOperationFilterInput
"Id of the supplier"
supplierId: ComparableLieferantKeyOperationFilterInput
"Name of the supplier"
supplierName: StringOperationFilterInput
"Currency used by the supplier"
supplierCurrency: StringOperationFilterInput
"Indicates if the supplier supports dropshipping."
isDropshippingSupported: ComparableBooleanOperationFilterInput
"The delivery time of the supplier."
supplierDeliveryTimeInDays: ComparableNullableOfInt32OperationFilterInput
"Name of the item at the supplier (max 255 characters)."
supplierItemName: StringOperationFilterInput
"Item number at the supplier (max 255 characters)."
supplierItemNumber: StringOperationFilterInput
"Delivery period as text (max 255 characters)."
deliveryPeriod: StringOperationFilterInput
"Stock level of the item at the supplier."
stockLevel: ComparableDecimalOperationFilterInput
"Average delivery time based on historical data."
averageDeliveryTime: ComparableDecimalOperationFilterInput
"Date when the stock level was last updated."
stockLevelLastModified: ComparableNullableOfDateTimeOperationFilterInput
"Net purchase price of the item at the supplier."
netPurchasePrice: ComparableDecimalOperationFilterInput
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: ComparableNullableOfInt32OperationFilterInput
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: ComparableNullableOfInt32OperationFilterInput
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: ComparableBooleanOperationFilterInput
"Indicates if this supplier is the default supplier for the item."
isDefaultSupplier: ComparableBooleanOperationFilterInput
"Indicates if this supplier is the default dropshipping supplier for the item."
isDefaultDropshippingSupplier: ComparableBooleanOperationFilterInput
"Description of the packaging unit."
packageUnitDescription: StringOperationFilterInput
"Quantity per packaging unit."
packageUnitQuantity: ComparableNullableOfDecimalOperationFilterInput
"Additional notes (max 512 characters)."
notes: StringOperationFilterInput
"VAT rate of the item at the supplier."
vatRate: ComparableDecimalOperationFilterInput
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: ComparableBooleanOperationFilterInput
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: ComparableBooleanOperationFilterInput
"Purchase interval for this item at the supplier."
purchaseInterval: ComparableDecimalOperationFilterInput
}
"Model Class: ItemSupplierListItem"
input ItemSupplierListItemSortInput {
"Id of the item supplier"
id: LieferantenArtikelKeySortInput @cost(weight: "10")
"Id of the item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Id of the supplier"
supplierId: LieferantKeySortInput @cost(weight: "10")
"Name of the supplier"
supplierName: SortEnumType @cost(weight: "10")
"Currency used by the supplier"
supplierCurrency: SortEnumType @cost(weight: "10")
"Indicates if the supplier supports dropshipping."
isDropshippingSupported: SortEnumType @cost(weight: "10")
"The delivery time of the supplier."
supplierDeliveryTimeInDays: SortEnumType @cost(weight: "10")
"Name of the item at the supplier (max 255 characters)."
supplierItemName: SortEnumType @cost(weight: "10")
"Item number at the supplier (max 255 characters)."
supplierItemNumber: SortEnumType @cost(weight: "10")
"Delivery period as text (max 255 characters)."
deliveryPeriod: SortEnumType @cost(weight: "10")
"Stock level of the item at the supplier."
stockLevel: SortEnumType @cost(weight: "10")
"Average delivery time based on historical data."
averageDeliveryTime: SortEnumType @cost(weight: "10")
"Date when the stock level was last updated."
stockLevelLastModified: SortEnumType @cost(weight: "10")
"Net purchase price of the item at the supplier."
netPurchasePrice: SortEnumType @cost(weight: "10")
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: SortEnumType @cost(weight: "10")
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: SortEnumType @cost(weight: "10")
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: SortEnumType @cost(weight: "10")
"Indicates if this supplier is the default supplier for the item."
isDefaultSupplier: SortEnumType @cost(weight: "10")
"Indicates if this supplier is the default dropshipping supplier for the item."
isDefaultDropshippingSupplier: SortEnumType @cost(weight: "10")
"Description of the packaging unit."
packageUnitDescription: SortEnumType @cost(weight: "10")
"Quantity per packaging unit."
packageUnitQuantity: SortEnumType @cost(weight: "10")
"Additional notes (max 512 characters)."
notes: SortEnumType @cost(weight: "10")
"VAT rate of the item at the supplier."
vatRate: SortEnumType @cost(weight: "10")
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: SortEnumType @cost(weight: "10")
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: SortEnumType @cost(weight: "10")
"Purchase interval for this item at the supplier."
purchaseInterval: SortEnumType @cost(weight: "10")
}
"Single row of the item type information"
input ItemTypeListItemFilterInput {
and: [ItemTypeListItemFilterInput!]
or: [ItemTypeListItemFilterInput!]
"Item id"
id: ComparableArtikelKeyOperationFilterInput
"Indicates whether the item is managed as a stock item."
isStockItem: ComparableBooleanOperationFilterInput
"Indicates whether the item currently has a positive stock quantity."
hasStock: ComparableBooleanOperationFilterInput
"Indicates whether the item requires serial number tracking."
isSerialNumberItem: ComparableBooleanOperationFilterInput
"Indicates whether the item can be divided into partial quantities."
isDivisibleStock: ComparableBooleanOperationFilterInput
"Indicates whether the item has an expiration or best-before date (MHD)."
stockHasExpirationDate: ComparableBooleanOperationFilterInput
"Indicates whether the item is managed as a batch or lot item."
stockIsBatch: ComparableBooleanOperationFilterInput
"Indicates whether the item is a bill of materials (BOM \/ Stückliste)."
isBillOfMaterials: ComparableBooleanOperationFilterInput
"Indicates whether the item is used as a component within a bill of materials."
isBillOfMaterialsComponent: ComparableBooleanOperationFilterInput
"Indicates whether the item is a parent of a variation combination."
isVariationCombinationParent: ComparableBooleanOperationFilterInput
"Indicates whether the item is a child (variant) of a variation combination."
isVariationCombinationChild: ComparableBooleanOperationFilterInput
"Indicates whether the item has variations defined."
hasVariations: ComparableBooleanOperationFilterInput
"Indicates whether the item represents a voucher."
isVoucher: ComparableBooleanOperationFilterInput
"Indicates whether the item is a packaging item."
isPackaging: ComparableBooleanOperationFilterInput
"Indicates whether the item has a configuration attached."
hasConfigurationGroup: ComparableBooleanOperationFilterInput
"Indicates whether the item is a configuration component."
isConfigurationComponent: ComparableBooleanOperationFilterInput
}
"Single row of the item type information"
input ItemTypeListItemSortInput {
"Item id"
id: ArtikelKeySortInput @cost(weight: "10")
"Indicates whether the item is managed as a stock item."
isStockItem: SortEnumType @cost(weight: "10")
"Indicates whether the item currently has a positive stock quantity."
hasStock: SortEnumType @cost(weight: "10")
"Indicates whether the item requires serial number tracking."
isSerialNumberItem: SortEnumType @cost(weight: "10")
"Indicates whether the item can be divided into partial quantities."
isDivisibleStock: SortEnumType @cost(weight: "10")
"Indicates whether the item has an expiration or best-before date (MHD)."
stockHasExpirationDate: SortEnumType @cost(weight: "10")
"Indicates whether the item is managed as a batch or lot item."
stockIsBatch: SortEnumType @cost(weight: "10")
"Indicates whether the item is a bill of materials (BOM \/ Stückliste)."
isBillOfMaterials: SortEnumType @cost(weight: "10")
"Indicates whether the item is used as a component within a bill of materials."
isBillOfMaterialsComponent: SortEnumType @cost(weight: "10")
"Indicates whether the item is a parent of a variation combination."
isVariationCombinationParent: SortEnumType @cost(weight: "10")
"Indicates whether the item is a child (variant) of a variation combination."
isVariationCombinationChild: SortEnumType @cost(weight: "10")
"Indicates whether the item has variations defined."
hasVariations: SortEnumType @cost(weight: "10")
"Indicates whether the item represents a voucher."
isVoucher: SortEnumType @cost(weight: "10")
"Indicates whether the item is a packaging item."
isPackaging: SortEnumType @cost(weight: "10")
"Indicates whether the item has a configuration attached."
hasConfigurationGroup: SortEnumType @cost(weight: "10")
"Indicates whether the item is a configuration component."
isConfigurationComponent: SortEnumType @cost(weight: "10")
}
input KategorieKeySortInput {
kKategorie: SortEnumType @cost(weight: "10")
}
"Represents a unique key for identifying a customer in the JTL system."
input KundeKeySortInput {
"Gets the unique identifier for the customer."
kKunde: SortEnumType @cost(weight: "10")
"Gets a value indicating whether the customer key represents an existing customer."
isExisting: SortEnumType @cost(weight: "10")
}
input KundenGruppeKeySortInput {
kKundenGruppe: SortEnumType @cost(weight: "10")
}
input KundenKategorieKeySortInput {
kKundenKategorie: SortEnumType @cost(weight: "10")
}
"Represents a language item in the system"
input LanguageItemFilterInput {
and: [LanguageItemFilterInput!]
or: [LanguageItemFilterInput!]
"The two-letter ISO code of the language"
languageIso2: StringOperationFilterInput
"The name of the language in the Accept-Language header"
name: StringOperationFilterInput
"The culture ISO code of the language"
cultureIso: StringOperationFilterInput
"The three-letter ISO code of the language"
languageIso3: StringOperationFilterInput
}
"Represents a language item in the system"
input LanguageItemSortInput {
"The two-letter ISO code of the language"
languageIso2: SortEnumType @cost(weight: "10")
"The name of the language in the Accept-Language header"
name: SortEnumType @cost(weight: "10")
"The culture ISO code of the language"
cultureIso: SortEnumType @cost(weight: "10")
"The three-letter ISO code of the language"
languageIso3: SortEnumType @cost(weight: "10")
}
input LhmKeySortInput {
kLhm: SortEnumType @cost(weight: "10")
}
"Represents a unique key for identifying a lhm type in the JTL system."
input LhmTypeKeySortInput {
"Gets the unique identifier for the lhm type."
kLHMTyp: SortEnumType @cost(weight: "10")
}
input LieferantKeySortInput {
kLieferant: SortEnumType @cost(weight: "10")
}
"LieferArtikel Schlüssel"
input LieferantenArtikelKeySortInput {
"Der Interne Named Key"
kLiefArtikel: SortEnumType @cost(weight: "10")
}
"Locks a bin location, preventing stock movements. - Request"
input LockBinLocationCommandRequestInput {
"Unique identifier of the bin location to lock."
binLocationId: ID!
}
"Locks a bin location for available stock, preventing it from being used for stock allocation. - Request"
input LockBinLocationForAvailableStockCommandRequestInput {
"Unique identifier of the bin location to lock for available stock."
binLocationId: ID!
}
"A lot size for a production item. It defines the quantity of a production item that is produced in one lot."
input LotSizeFilterInput {
and: [LotSizeFilterInput!]
or: [LotSizeFilterInput!]
"The ID of this lot size."
id: ComparableLotSizeKeyOperationFilterInput
"The ID of the production item of this lot size."
productionItemId: ComparableProdItemKeyOperationFilterInput
"The quantity of the production item that is produced in one lot."
quantity: ComparableInt32OperationFilterInput
}
input LotSizeKeySortInput {
kLotSize: SortEnumType @cost(weight: "10")
}
"A lot size for a production item. It defines the quantity of a production item that is produced in one lot."
input LotSizeSortInput {
"The ID of this lot size."
id: LotSizeKeySortInput @cost(weight: "10")
"The ID of the production item of this lot size."
productionItemId: ProdItemKeySortInput @cost(weight: "10")
"The quantity of the production item that is produced in one lot."
quantity: SortEnumType @cost(weight: "10")
}
"Single Row of the manufacturer overview"
input ManufacturerListItemFilterInput {
and: [ManufacturerListItemFilterInput!]
or: [ManufacturerListItemFilterInput!]
"Id of the manufacturer."
id: ComparableHerstellerKeyOperationFilterInput
"Default manufacturer Name"
name: StringOperationFilterInput
}
"Single Row of the manufacturer overview"
input ManufacturerListItemSortInput {
"Id of the manufacturer."
id: HerstellerKeySortInput @cost(weight: "10")
"Sortnumber of the manufacturer."
sortNumber: SortEnumType @cost(weight: "10")
"Default manufacturer Name"
name: SortEnumType @cost(weight: "10")
}
"Single row of the external document overview list."
input MarketplaceExternalDocumentListItemFilterInput {
and: [MarketplaceExternalDocumentListItemFilterInput!]
or: [MarketplaceExternalDocumentListItemFilterInput!]
"Type of the external document."
documentType: ComparableMarketplaceExternalDocumentTypeOperationFilterInput
"Name of the shop."
shopName: StringOperationFilterInput
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Document number."
documentNumber: StringOperationFilterInput
"Invoice date."
invoiceDate: ComparableNullableOfDateTimeOperationFilterInput
}
"Single row of the external document overview list."
input MarketplaceExternalDocumentListItemSortInput {
"Type of the external document."
documentType: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Invoice date."
invoiceDate: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Gross total amount."
grossTotal: SortEnumType @cost(weight: "10")
"Document number."
documentNumber: SortEnumType @cost(weight: "10")
"Currency code."
currency: SortEnumType @cost(weight: "10")
}
"Single row of the notification detail overview list."
input MarketplaceNotificationDetailListItemSortInput {
"Detail code of the notification."
code: SortEnumType @cost(weight: "10")
"Detailed message of the notification."
message: SortEnumType @cost(weight: "10")
}
"Single Row of the notification overview list."
input MarketplaceNotificationListItemFilterInput {
and: [MarketplaceNotificationListItemFilterInput!]
or: [MarketplaceNotificationListItemFilterInput!]
"Severity level of the notification."
severity: ComparableMarketplaceNotificationSeverityOperationFilterInput
"Type of the notification."
notificationType: ComparableMarketplaceNotificationTypeOperationFilterInput
"Whether the notification has been read."
isRead: ComparableBooleanOperationFilterInput
"Optional display name of the shop."
shopName: StringOperationFilterInput
"Optional title of the associated offer."
offerTitle: StringOperationFilterInput
}
"Single Row of the notification overview list."
input MarketplaceNotificationListItemSortInput {
"Creation timestamp."
creationDate: SortEnumType @cost(weight: "10")
"Severity level of the notification."
severity: SortEnumType @cost(weight: "10")
"Type of the notification."
notificationType: SortEnumType @cost(weight: "10")
"Name of the marketplace channel."
channel: SortEnumType @cost(weight: "10")
"Optional display name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Whether the notification has been read."
isRead: SortEnumType @cost(weight: "10")
"Event identifier that triggered this notification."
eventId: SortEnumType @cost(weight: "10")
"Optional short message summarizing the notification."
shortMessage: SortEnumType @cost(weight: "10")
}
"Single row of the marketplace offer overview list."
input MarketplaceOfferListItemFilterInput {
and: [MarketplaceOfferListItemFilterInput!]
or: [MarketplaceOfferListItemFilterInput!]
"Combined lifecycle and action status of the offer."
offerStatus: ComparableMarketplaceOfferViewStatusOperationFilterInput
"Type of the offer."
offerType: ComparableMarketplaceOfferTypeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
"ID of the seller."
shopScxId: ComparableScxShopKeyOperationFilterInput
"ID of the channel."
channelId: ComparableScxChannelKeyOperationFilterInput
"Whether the offer is currently listed."
isListed: ComparableBooleanOperationFilterInput
"Whether the offer is external."
isExtern: ComparableBooleanOperationFilterInput
"Stock keeping unit."
sku: StringOperationFilterInput
"Product number of the article."
productNumber: StringOperationFilterInput
"Title of the offer."
offerTitle: StringOperationFilterInput
"Display name of the sales channel."
channelName: StringOperationFilterInput
"Name of the shop."
shopName: StringOperationFilterInput
"Whether automatic stock updates are enabled for this seller."
stockUpdateEnabled: ComparableBooleanOperationFilterInput
}
"Single row of the marketplace offer overview list."
input MarketplaceOfferListItemSortInput {
"Title of the offer."
offerTitle: SortEnumType @cost(weight: "10")
"Combined lifecycle and action status of the offer."
offerStatus: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
channelName: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Stock keeping unit."
sku: SortEnumType @cost(weight: "10")
"Product number of the article."
productNumber: SortEnumType @cost(weight: "10")
"Current quantity."
quantity: SortEnumType @cost(weight: "10")
"Net price of the offer."
netPrice: SortEnumType @cost(weight: "10")
"Timestamp since the offer is active."
activeSince: SortEnumType @cost(weight: "10")
"Timestamp of the last upload."
lastUpload: SortEnumType @cost(weight: "10")
"Whether the offer is currently listed."
isListed: SortEnumType @cost(weight: "10")
}
"Single row of the order cancellation request upload overview list."
input MarketplaceOrderCancellationRequestUploadListItemFilterInput {
and: [MarketplaceOrderCancellationRequestUploadListItemFilterInput!]
or: [MarketplaceOrderCancellationRequestUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the cancellation request upload."
status: ComparableMarketplaceOrderCancellationRequestUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single row of the order cancellation request upload overview list."
input MarketplaceOrderCancellationRequestUploadListItemSortInput {
"Status of the cancellation request upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
}
"Single Row of the order cancellation upload overview list."
input MarketplaceOrderCancellationUploadListItemFilterInput {
and: [MarketplaceOrderCancellationUploadListItemFilterInput!]
or: [MarketplaceOrderCancellationUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the cancellation upload."
status: ComparableMarketplaceOrderCancellationUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single Row of the order cancellation upload overview list."
input MarketplaceOrderCancellationUploadListItemSortInput {
"Status of the cancellation upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
}
"Single Row of the payment upload overview list."
input MarketplacePaymentUploadListItemFilterInput {
and: [MarketplacePaymentUploadListItemFilterInput!]
or: [MarketplacePaymentUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the payment upload."
status: ComparableMarketplacePaymentUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single Row of the payment upload overview list."
input MarketplacePaymentUploadListItemSortInput {
"Status of the payment upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Number of payment upload attempts."
paymentUploadCount: SortEnumType @cost(weight: "10")
}
"Single row of the return upload line item overview list."
input MarketplaceReturnUploadLineItemListItemSortInput {
"Quantity of the return line item."
quantity: SortEnumType @cost(weight: "10")
"SKU of the item."
sku: SortEnumType @cost(weight: "10")
"Name of the return line item."
name: SortEnumType @cost(weight: "10")
}
"Single Row of the return upload overview list."
input MarketplaceReturnUploadListItemFilterInput {
and: [MarketplaceReturnUploadListItemFilterInput!]
or: [MarketplaceReturnUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Return number."
returnNumber: StringOperationFilterInput
"Status of the return upload."
status: ComparableMarketplaceReturnUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single Row of the return upload overview list."
input MarketplaceReturnUploadListItemSortInput {
"Status of the return upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Number of return upload attempts."
returnUploadCount: SortEnumType @cost(weight: "10")
}
"Single row of the shipping information upload overview list."
input MarketplaceShippingInformationUploadListItemFilterInput {
and: [MarketplaceShippingInformationUploadListItemFilterInput!]
or: [MarketplaceShippingInformationUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the shipping information upload."
status: ComparableMarketplaceShippingInformationUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single row of the shipping information upload overview list."
input MarketplaceShippingInformationUploadListItemSortInput {
"Status of the shipping information upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Upload attempt count."
uploadCount: SortEnumType @cost(weight: "10")
}
"Single row of the payment methods overview table"
input PaymentMethodFilterInput {
and: [PaymentMethodFilterInput!]
or: [PaymentMethodFilterInput!]
"Unique identifier of the payment method"
id: ComparableZahlungsartKeyOperationFilterInput
"Name of the payment method"
name: StringOperationFilterInput
"G\/L account associated with the payment method"
generalLedgerAccount: StringOperationFilterInput
"Indicates whether the payment method is active"
isActive: ComparableBooleanOperationFilterInput
"Indicates whether this is the default payment method"
isDefault: ComparableBooleanOperationFilterInput
"Indicates whether the payment method is a debit type"
isDebit: ComparableBooleanOperationFilterInput
"Indicates whether dunning is active for this payment method"
isDunningActive: ComparableBooleanOperationFilterInput
"Indicates whether shipping is allowed before payment is received"
canShipBeforePayment: ComparableBooleanOperationFilterInput
"Number of days for cash discount"
cashDiscountDays: ComparableNullableOfInt32OperationFilterInput
"Value of the cash discount"
cashDiscountValue: ComparableNullableOfDecimalOperationFilterInput
"Payment option associated with the payment method"
paymentOption: StringOperationFilterInput
}
"Single row of the payment methods overview table"
input PaymentMethodSortInput {
"Unique identifier of the payment method"
id: ZahlungsartKeySortInput @cost(weight: "10")
"Name of the payment method"
name: SortEnumType @cost(weight: "10")
"G\/L account associated with the payment method"
generalLedgerAccount: SortEnumType @cost(weight: "10")
"Indicates whether the payment method is active"
isActive: SortEnumType @cost(weight: "10")
"Indicates whether this is the default payment method"
isDefault: SortEnumType @cost(weight: "10")
"Indicates whether the payment method is a debit type"
isDebit: SortEnumType @cost(weight: "10")
"Indicates whether dunning is active for this payment method"
isDunningActive: SortEnumType @cost(weight: "10")
"Indicates whether shipping is allowed before payment is received"
canShipBeforePayment: SortEnumType @cost(weight: "10")
"Number of days for cash discount"
cashDiscountDays: SortEnumType @cost(weight: "10")
"Value of the cash discount"
cashDiscountValue: SortEnumType @cost(weight: "10")
"Payment option associated with the payment method"
paymentOption: SortEnumType @cost(weight: "10")
}
"A pick list with its positions"
input PickListFilterInput {
and: [PickListFilterInput!]
or: [PickListFilterInput!]
"Id of the Warehouse"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Pick list status value"
status: ComparableInt32OperationFilterInput
"Pick list number"
pickListNumber: StringOperationFilterInput
}
"A pick list with its positions"
input PickListSortInput {
"Pick list number"
pickListNumber: SortEnumType @cost(weight: "10")
"Pick list status value"
status: SortEnumType @cost(weight: "10")
}
input PlattformKeySortInput {
kPlattform: SortEnumType @cost(weight: "10")
}
"Der Schlüssel eines Produktionsartikels."
input ProdItemKeySortInput {
"Der eindeutige Bezeichner eines Produktionsartikels."
kArtikel: SortEnumType @cost(weight: "10")
}
"Single row of product group information."
input ProductGroupsListItemFilterInput {
and: [ProductGroupsListItemFilterInput!]
or: [ProductGroupsListItemFilterInput!]
"Product group id"
id: ComparableWarengruppeKeyOperationFilterInput
"The name of the product group"
name: StringOperationFilterInput
}
"Single row of product group information."
input ProductGroupsListItemSortInput {
"Product group id"
id: WarengruppeKeySortInput @cost(weight: "10")
"The name of the product group"
name: SortEnumType @cost(weight: "10")
}
"A production item."
input ProductionItemFilterInput {
and: [ProductionItemFilterInput!]
or: [ProductionItemFilterInput!]
"The ID of this production item."
id: ComparableProdItemKeyOperationFilterInput
"The ID of the item underlying this production item."
itemId: ComparableArtikelKeyOperationFilterInput
"Defines the type of lot size configuration for this production item."
lotType: ComparableLotTypeOperationFilterInput
"Defines the type of manufacturing of this production item."
productionType: ComparableProductionTypeOperationFilterInput
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateKey: ComparableVorlagenSetKeyOperationFilterInput
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no item label for each produced unit should be printed on completion."
singleItemLabelTemplateKey: ComparableVorlagenSetKeyOperationFilterInput
"The timestamp when this production item was created."
createDate: ComparableDateTimeOffsetOperationFilterInput
"The timestamp when this production item was last modified."
updateDate: ComparableDateTimeOffsetOperationFilterInput
"The ID of the user who last modified this production item, or NULL if this production item has not been modified yet."
updateUserId: ComparableBenutzerKeyOperationFilterInput
}
"A production item."
input ProductionItemSortInput {
"The ID of this production item."
id: ProdItemKeySortInput @cost(weight: "10")
"The ID of the item underlying this production item."
itemId: ArtikelKeySortInput @cost(weight: "10")
"Defines the type of lot size configuration for this production item."
lotType: SortEnumType @cost(weight: "10")
"Defines the type of manufacturing of this production item."
productionType: SortEnumType @cost(weight: "10")
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateKey: VorlagenSetKeySortInput @cost(weight: "10")
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no item label for each produced unit should be printed on completion."
singleItemLabelTemplateKey: VorlagenSetKeySortInput @cost(weight: "10")
"The timestamp when this production item was created."
createDate: SortEnumType @cost(weight: "10")
"The timestamp when this production item was last modified."
updateDate: SortEnumType @cost(weight: "10")
"The ID of the user who last modified this production item, or NULL if this production item has not been modified yet."
updateUserId: BenutzerKeySortInput @cost(weight: "10")
}
"A production order."
input ProductionOrderFilterInput {
and: [ProductionOrderFilterInput!]
or: [ProductionOrderFilterInput!]
"The ID of the production order."
id: ComparableProductionOrderKeyOperationFilterInput
"The ID of the production item to be produced by this production order."
productionItemId: ComparableProdItemKeyOperationFilterInput
"The ID of the bill of material used to produce the production item."
billOfMaterialId: ComparableBillOfMaterialKeyOperationFilterInput
"The ID of the disposition from which the production order originates."
dispositionId: ComparableDispositionKeyOperationFilterInput
"Planned number of lots to be produced."
lotCount: ComparableInt32OperationFilterInput
"Planned size of the lots to be produced."
lotSize: ComparableDecimalOperationFilterInput
"Planned total quantity to be produced."
targetTotalQuantity: ComparableDecimalOperationFilterInput
"Actual total quantity produced."
actualQuantity: ComparableDecimalOperationFilterInput
"Indicates whether it is allowed for this order to have a total quantity below the lot size (true) or not (false)."
isTargetTotalQuantityBelowLotSizeAllowed: ComparableBooleanOperationFilterInput
"Progress of the production order."
progress: ComparableDecimalOperationFilterInput
"Planned start time of the production order."
targetStartTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Planned completion time of the production order."
targetCompletionTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Actual (reported) start time of the production order."
actualStartTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Actual (reported) completion time of the production order."
actualCompletionTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The project number associated with the production order."
projectNumber: StringOperationFilterInput
"The reference number associated with the underlying order for this production order."
referenceNumber: StringOperationFilterInput
"The issue number of the production order."
issueNumber: StringOperationFilterInput
"The date when the production order was issued."
issueDate: ComparableDateTimeOffsetOperationFilterInput
"Additional note on the order that will be displayed during production."
notice: StringOperationFilterInput
"The timestamp when the production order was released."
releaseTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Planned delivery date."
deliveryTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The ID of the user who created the production order."
creationUserId: ComparableBenutzerKeyOperationFilterInput
"The ID of the user who released the production order."
releaseUserId: ComparableBenutzerKeyOperationFilterInput
"The ID of the user who last modified the production order."
lastModificationUserId: ComparableBenutzerKeyOperationFilterInput
"The timestamp of the last modification of the production order."
lastModificationTimestamp: ComparableDateTimeOffsetOperationFilterInput
"The ID type of the resource (workbench-types only) which is allowed to produce this production order."
resourceTypeId: ComparableResourceTypeKeyOperationFilterInput
"The ID of the workbench resource onto which the production order was assigned."
workbenchResourceId: ComparableWorkbenchResourceKeyOperationFilterInput
}
input ProductionOrderKeySortInput {
kProductionOrder: SortEnumType @cost(weight: "10")
}
"A production order."
input ProductionOrderSortInput {
"The ID of the production order."
id: ProductionOrderKeySortInput @cost(weight: "10")
"The ID of the production item to be produced by this production order."
productionItemId: ProdItemKeySortInput @cost(weight: "10")
"The ID of the bill of material used to produce the production item."
billOfMaterialId: BillOfMaterialKeySortInput @cost(weight: "10")
"The issue number of the production order."
issueNumber: SortEnumType @cost(weight: "10")
"The date when the production order was issued."
issueDate: SortEnumType @cost(weight: "10")
"Planned start time of the production order."
targetStartTimestamp: SortEnumType @cost(weight: "10")
"Planned completion time of the production order."
targetCompletionTimestamp: SortEnumType @cost(weight: "10")
"Actual (reported) start time of the production order."
actualStartTimestamp: SortEnumType @cost(weight: "10")
"Actual (reported) completion time of the production order."
actualCompletionTimestamp: SortEnumType @cost(weight: "10")
"Planned delivery date."
deliveryTimestamp: SortEnumType @cost(weight: "10")
"The timestamp when the production order was released."
releaseTimestamp: SortEnumType @cost(weight: "10")
"Progress of the production order."
progress: SortEnumType @cost(weight: "10")
"The project number associated with the production order."
projectNumber: SortEnumType @cost(weight: "10")
"The reference number associated with the underlying order for this production order."
referenceNumber: SortEnumType @cost(weight: "10")
"The ID type of the resource (workbench-types only) which is allowed to produce this production order."
resourceTypeId: ResourceTypeKeySortInput @cost(weight: "10")
"The ID of the workbench resource onto which the production order was assigned."
workbenchResourceId: WorkbenchResourceKeySortInput @cost(weight: "10")
"The ID of the user who created the production order."
creationUserId: BenutzerKeySortInput @cost(weight: "10")
"The timestamp of the last modification of the production order."
lastModificationTimestamp: SortEnumType @cost(weight: "10")
}
"Provides paged access to stock entries filtered by warehouse, bin location, or article."
input QueryStockFilterInput {
and: [QueryStockFilterInput!]
or: [QueryStockFilterInput!]
"Unique identifier of the stock entry."
stockEntryId: ComparableWarenLagerEingangKeyOperationFilterInput
"Warehouse that owns the stock entry."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Bin location containing the stock entry."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Article stored in the stock entry."
articleId: ComparableArtikelKeyOperationFilterInput
"Available quantity (fAnzahlAktuell)."
availableQuantity: ComparableDecimalOperationFilterInput
"Quantity reserved for pick positions (fAnzahlReserviertPickpos)."
reservedQuantity: ComparableDecimalOperationFilterInput
"Batch\/charge number, empty when not tracked."
batchNumber: StringOperationFilterInput
"Best-before date (MHD) if tracked."
bestBeforeDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Serial number associated with the stock entry."
serialNumber: StringOperationFilterInput
}
"Single Row of the serial number query"
input QueryStockItemFilterInput {
and: [QueryStockItemFilterInput!]
or: [QueryStockItemFilterInput!]
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Id of the item."
itemId: ComparableArtikelKeyOperationFilterInput
}
"Single Row of the serial number query"
input QueryStockItemSortInput {
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Id of the item."
itemId: ArtikelKeySortInput @cost(weight: "10")
"Total quantity of this item at this storage location."
quantityTotal: SortEnumType @cost(weight: "10")
"Comment1"
comment1: SortEnumType @cost(weight: "10")
"Comment2"
comment2: SortEnumType @cost(weight: "10")
}
"Provides paged access to stock entries filtered by warehouse, bin location, or article."
input QueryStockSortInput {
"Unique identifier of the stock entry."
stockEntryId: WarenLagerEingangKeySortInput @cost(weight: "10")
"Warehouse that owns the stock entry."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Bin location containing the stock entry."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Article stored in the stock entry."
articleId: ArtikelKeySortInput @cost(weight: "10")
"Available quantity (fAnzahlAktuell)."
availableQuantity: SortEnumType @cost(weight: "10")
"Quantity reserved for pick positions (fAnzahlReserviertPickpos)."
reservedQuantity: SortEnumType @cost(weight: "10")
"Batch\/charge number, empty when not tracked."
batchNumber: SortEnumType @cost(weight: "10")
"Best-before date (MHD) if tracked."
bestBeforeDate: SortEnumType @cost(weight: "10")
"Serial number associated with the stock entry."
serialNumber: SortEnumType @cost(weight: "10")
}
input RechnungKeySortInput {
kRechnung: SortEnumType @cost(weight: "10")
}
input RechnungPositionKeySortInput {
kRechnungPosition: SortEnumType @cost(weight: "10")
}
input RechnungStornogrundKeySortInput {
kRechnungStornogrund: SortEnumType @cost(weight: "10")
}
"Releases an existing production order. - Request"
input ReleaseProductionOrderCommandRequestInput {
"The ID of the production order to be released."
productionOrderId: ID!
}
"Removes bin locations from a warehouse zone. - Request"
input RemoveBinLocationsFromZoneCommandRequestInput {
"The zone to remove bin locations from."
zoneId: ID!
"Bin locations to remove from the zone."
binLocationIds: [ID]!
}
"Removes the item assignment from the specified marketplace offers. - Request"
input RemoveItemFromMarketplaceOfferCommandRequestInput {
"Marketplace offer keys identifying the offers from which the item assignment should be removed."
offerKeys: [ID]!
"If true, related marketplace assignment data is removed from items as well."
removeDataFromItem: Boolean!
}
"Reset the upload counter for marketplace invoice correction PDFs. - Request"
input ResetMarketplaceInvoiceCorrectionPdfUploadCounterCommandRequestInput {
"The invoice correction PDF upload queue entries for which the upload counter should be reset."
documentUploadQueueKeys: [ID]!
}
"Reset the upload counter for marketplace invoice corrections. - Request"
input ResetMarketplaceInvoiceCorrectionUploadCounterCommandRequestInput {
"The invoice corrections for which the upload counter should be reset."
orderKeys: [ID]!
}
"Resets PDF generation for marketplace invoices\/invoice corrections so they can be reprinted and uploaded again. - Request"
input ResetMarketplaceInvoicePdfPrintingCommandRequestInput {
"Upload document IDs of the invoices\/invoice corrections to reset PDF generation."
documentUploadQueueKeys: [ID]!
}
"Reset the upload counter for marketplace order cancellation uploads. - Request"
input ResetMarketplaceOrderCancellationUploadCounterCommandRequestInput {
"Marketplace order keys of cancellation uploads whose counter should be reset."
orderKeys: [ID]!
}
"Reset the upload counter for marketplace payment uploads. - Request"
input ResetMarketplacePaymentUploadCounterCommandRequestInput {
"Marketplace order keys of payment uploads whose counter should be reset."
orderKeys: [ID]!
}
"Reset the upload counter for marketplace return uploads. - Request"
input ResetMarketplaceReturnUploadCounterCommandRequestInput {
"Marketplace order keys of return uploads whose counter should be reset."
orderKeys: [ID]!
}
"Reset the upload counter for marketplace shipping information uploads. - Request"
input ResetMarketplaceShippingInformationUploadCounterCommandRequestInput {
"Marketplace order shipping keys of shipping information uploads whose counter should be reset."
orderShippingKeys: [ID]!
}
"Represents a resource category"
input ResourceCategoryFilterInput {
and: [ResourceCategoryFilterInput!]
or: [ResourceCategoryFilterInput!]
"This resource category's unqiue ID."
id: ComparableResourceCategoryKeyOperationFilterInput
"The resource category's name."
name: StringOperationFilterInput
"Specifies whether this resource category is visible to users."
isVisible: ComparableBooleanOperationFilterInput
"Specifies whether this resource category is enabled for use."
isEnabled: ComparableBooleanOperationFilterInput
}
"Ein Schlüssel für eine Ressourcenkategorie."
input ResourceCategoryKeySortInput {
"Der durch diesen Schlüssel beschriebene global eindeutige Bezeichner."
value: SortEnumType @cost(weight: "10")
}
"Represents a resource category"
input ResourceCategorySortInput {
"This resource category's unqiue ID."
id: ResourceCategoryKeySortInput @cost(weight: "10")
"The resource category's name."
name: SortEnumType @cost(weight: "10")
"Specifies whether this resource category is visible to users."
isVisible: SortEnumType @cost(weight: "10")
"Specifies whether this resource category is enabled for use."
isEnabled: SortEnumType @cost(weight: "10")
}
input ResourceTypeKeySortInput {
kResourceType: SortEnumType @cost(weight: "10")
}
input RueckhaltegrundKeySortInput {
kRueckhalteGrund: SortEnumType @cost(weight: "10")
}
"Single row of the sales channels overview table"
input SalesChannelFilterInput {
and: [SalesChannelFilterInput!]
or: [SalesChannelFilterInput!]
"Unique identifier of the sales channel"
id: ComparableShopKeyOperationFilterInput
"Name of the sales channel"
name: StringOperationFilterInput
}
"Single row of the sales channels overview table"
input SalesChannelSortInput {
"Unique identifier of the sales channel"
id: ShopKeySortInput @cost(weight: "10")
"Name of the sales channel"
name: SortEnumType @cost(weight: "10")
}
input SalesInvoiceCancellationInternalFilterInput {
and: [SalesInvoiceCancellationInternalFilterInput!]
or: [SalesInvoiceCancellationInternalFilterInput!]
"Sales order identifier"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales invoice identifier"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Company identifier"
companyId: ComparableFirmaKeyOperationFilterInput
"Customer identifier"
customerId: ComparableKundeKeyOperationFilterInput
"Platform identifier"
platformId: ComparablePlattformKeyOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Sales invoice cancellation date"
salesInvoiceCancellationDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"External order number"
externalOrderNumber: StringOperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Date when the order was created in the ERP system"
createdInErpDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Tax setting"
taxSetting: ComparableInt32OperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Currency conversion factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Departure country currency ISO code"
departureCountryCurrencyIso: StringOperationFilterInput
"Departure country currency conversion factor"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"Service date"
serviceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Last shipping date"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Platform identifier"
platformName: StringOperationFilterInput
"Shipment method identifier"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"Value date"
valueDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Customer VAT identifier"
customerVatIdNumber: StringOperationFilterInput
"Sales invoice VAT identifier"
salesInvoiceVatIdNumber: StringOperationFilterInput
"Departure country ISO code"
departureCountryIso: StringOperationFilterInput
"Total gross amount"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Customer number"
salesInvoiceCustomerNumber: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableInt32OperationFilterInput
"Payment status"
paymentStatus: ComparableNullableOfInt32OperationFilterInput
"Invoice payment method identifier"
invoicePaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Payment method identifier"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Payment method"
paymentMethodName: StringOperationFilterInput
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: StringOperationFilterInput
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: ComparableNullableOfDecimalOperationFilterInput
"Shipment company name"
shipmentAddressCompany: StringOperationFilterInput
"Shipment salutation"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment street address"
shipmentAddressStreet: StringOperationFilterInput
"Shipment postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment city"
shipmentAddressCity: StringOperationFilterInput
"Shipment country"
shipmentAddressCountry: StringOperationFilterInput
"Shipment phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment fax number"
shipmentAddressFaxNumber: StringOperationFilterInput
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment country ISO code"
shipmentAddressCountryIso: StringOperationFilterInput
"Shipment VAT identifier"
shipmentAddressVatIdNumber: StringOperationFilterInput
"Sales invoice company name"
billingAddressCompany: StringOperationFilterInput
"Sales invoice salutation"
billingAddressSalutation: StringOperationFilterInput
"Sales invoice title"
billingAddressTitle: StringOperationFilterInput
"Sales invoice first name"
billingAddressFirstName: StringOperationFilterInput
"Sales invoice last name"
billingAddressLastName: StringOperationFilterInput
"Sales invoice street address"
billingAddressStreet: StringOperationFilterInput
"Sales invoice postal code"
billingAddressPostalCode: StringOperationFilterInput
"Sales invoice city"
billingAddressCity: StringOperationFilterInput
"Sales invoice country"
billingAddressCountry: StringOperationFilterInput
"Sales invoice phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Sales invoice fax number"
billingAddressFaxNumber: StringOperationFilterInput
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Sales invoice country ISO code"
billingAddressCountryIso: StringOperationFilterInput
"Customer company name"
customerDefaultBillingAddressCompany: StringOperationFilterInput
"Customer salutation"
customerDefaultBillingAddressSalutation: StringOperationFilterInput
"Customer title"
customerDefaultBillingAddressTitle: StringOperationFilterInput
"Customer first name"
customerDefaultBillingAddressFirstName: StringOperationFilterInput
"Customer last name"
customerDefaultBillingAddressLastName: StringOperationFilterInput
"Customer street address"
customerDefaultBillingAddressStreet: StringOperationFilterInput
"Customer postal code"
customerDefaultBillingAddressPostalCode: StringOperationFilterInput
"Customer city"
customerDefaultBillingAddressCity: StringOperationFilterInput
"Customer country"
customerDefaultBillingAddressCountry: StringOperationFilterInput
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerDefaultBillingAddressFaxNumber: StringOperationFilterInput
"Customer address country ISO code"
customerDefaultBillingAddressCountryIso: StringOperationFilterInput
"Customer email address"
customerDefaultBillingAddressEmailAddress: StringOperationFilterInput
"Customer address VAT identifier"
customerDefaultBillingAddressVatIdNumber: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer group identifier"
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Customer payment due date in days"
customerPaymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Deposit information"
deposit: StringOperationFilterInput
"Delivery note count for drop shipping"
dropShippingDeliveryNoteCount: ComparableInt32OperationFilterInput
}
input SalesInvoiceCancellationInternalSortInput {
"Sales order identifier"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales invoice identifier"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Company identifier"
companyId: FirmaKeySortInput @cost(weight: "10")
"Customer identifier"
customerId: KundeKeySortInput @cost(weight: "10")
"Platform identifier"
platformId: PlattformKeySortInput @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Sales invoice cancellation date"
salesInvoiceCancellationDate: SortEnumType @cost(weight: "10")
"External order number"
externalOrderNumber: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Date when the order was created in the ERP system"
createdInErpDate: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Currency conversion factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Departure country currency ISO code"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Departure country currency conversion factor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Last shipping date"
lastShippingDate: SortEnumType @cost(weight: "10")
"Platform identifier"
platformName: SortEnumType @cost(weight: "10")
"Shipment method identifier"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Value date"
valueDate: SortEnumType @cost(weight: "10")
"Customer VAT identifier"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice VAT identifier"
salesInvoiceVatIdNumber: SortEnumType @cost(weight: "10")
"Departure country ISO code"
departureCountryIso: SortEnumType @cost(weight: "10")
"Total gross amount"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount"
totalNetAmount: SortEnumType @cost(weight: "10")
"Customer number"
salesInvoiceCustomerNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Payment status"
paymentStatus: SortEnumType @cost(weight: "10")
"Invoice payment method identifier"
invoicePaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Payment method identifier"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Payment method"
paymentMethodName: SortEnumType @cost(weight: "10")
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Shipment company name"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment salutation"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment street address"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment country"
shipmentAddressCountry: SortEnumType @cost(weight: "10")
"Shipment phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment fax number"
shipmentAddressFaxNumber: SortEnumType @cost(weight: "10")
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment country ISO code"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipment VAT identifier"
shipmentAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice company name"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Sales invoice salutation"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Sales invoice title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Sales invoice first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Sales invoice last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Sales invoice street address"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Sales invoice postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Sales invoice city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Sales invoice country"
billingAddressCountry: SortEnumType @cost(weight: "10")
"Sales invoice phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Sales invoice fax number"
billingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Sales invoice country ISO code"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer company name"
customerDefaultBillingAddressCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerDefaultBillingAddressSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerDefaultBillingAddressTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerDefaultBillingAddressFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerDefaultBillingAddressLastName: SortEnumType @cost(weight: "10")
"Customer street address"
customerDefaultBillingAddressStreet: SortEnumType @cost(weight: "10")
"Customer postal code"
customerDefaultBillingAddressPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerDefaultBillingAddressCity: SortEnumType @cost(weight: "10")
"Customer country"
customerDefaultBillingAddressCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerDefaultBillingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Customer address country ISO code"
customerDefaultBillingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer email address"
customerDefaultBillingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer address VAT identifier"
customerDefaultBillingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer group identifier"
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Customer payment due date in days"
customerPaymentDueDateInDays: SortEnumType @cost(weight: "10")
"Deposit information"
deposit: SortEnumType @cost(weight: "10")
"Delivery note count for drop shipping"
dropShippingDeliveryNoteCount: SortEnumType @cost(weight: "10")
}
"Single sales invoice cancellation reason"
input SalesInvoiceCancellationReasonFilterInput {
and: [SalesInvoiceCancellationReasonFilterInput!]
or: [SalesInvoiceCancellationReasonFilterInput!]
"Unique identifier of the sales invoice cancellation reason"
id: ComparableRechnungStornogrundKeyOperationFilterInput
"Name of the cancellation reason"
name: StringOperationFilterInput
"Indicates whether a comment is required when using this cancellation reason"
isCommentRequired: ComparableBooleanOperationFilterInput
}
"Single sales invoice cancellation reason"
input SalesInvoiceCancellationReasonSortInput {
"Unique identifier of the sales invoice cancellation reason"
id: RechnungStornogrundKeySortInput @cost(weight: "10")
"Name of the cancellation reason"
name: SortEnumType @cost(weight: "10")
"Indicates whether a comment is required when using this cancellation reason"
isCommentRequired: SortEnumType @cost(weight: "10")
}
input SalesInvoiceCorrectionInternalFilterInput {
and: [SalesInvoiceCorrectionInternalFilterInput!]
or: [SalesInvoiceCorrectionInternalFilterInput!]
"Sales order identifier"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales invoice correction identifier"
salesInvoiceCorrectionId: ComparableGutschriftKeyOperationFilterInput
"Customer identifier"
customerId: ComparableKundeKeyOperationFilterInput
"Company identifier"
companyId: ComparableFirmaKeyOperationFilterInput
"Sales invoice identifier"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Platform identifier"
platformId: ComparablePlattformKeyOperationFilterInput
"Cancelled sales invoice identifier"
cancelledSalesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Sales invoice payment method identifier"
salesInvoicePaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Sales invoice correction payment method identifier"
salesInvoiceCorrectionPaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Sales invoice correction number"
salesInvoiceCorrectionNumber: StringOperationFilterInput
"Sales invoice correction date"
salesInvoiceCorrectionDate: ComparableDateTimeOffsetOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Sales invoice date"
salesInvoiceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"External order number"
externalOrderNumber: StringOperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Date when the order was created in the ERP system"
createdInErpDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Currency conversion factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Departure country currency ISO code"
departureCountryCurrencyIso: StringOperationFilterInput
"Departure country currency conversion factor"
departureCountryCurrencyFactor: ComparableNullableOfDecimalOperationFilterInput
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: StringOperationFilterInput
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: ComparableNullableOfDecimalOperationFilterInput
"Shipment type"
salesOrderShippingMethodId: ComparableVersandartKeyOperationFilterInput
"Shipment type"
salesInvoiceShippingMethodId: ComparableVersandartKeyOperationFilterInput
"Service date"
serviceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Delivery date"
deliveryDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Total gross amount"
totalGrossAmount: ComparableDecimalOperationFilterInput
"Sales order total gross amount"
salesOrderTotalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Sales order total net amount"
salesOrderTotalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Platform identifier"
platformIdentifier: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Shipment company name"
shipmentCompany: StringOperationFilterInput
"Shipment salutation"
shipmentSalutation: StringOperationFilterInput
"Shipment title"
shipmentTitle: StringOperationFilterInput
"Shipment first name"
shipmentFirstName: StringOperationFilterInput
"Shipment last name"
shipmentLastName: StringOperationFilterInput
"Shipment street address"
shipmentStreet: StringOperationFilterInput
"Shipment postal code"
shipmentPostalCode: StringOperationFilterInput
"Shipment city"
shipmentCity: StringOperationFilterInput
"Shipment country"
shipmentCountry: StringOperationFilterInput
"Shipment phone number"
shipmentPhoneNumber: StringOperationFilterInput
"Shipment fax number"
shipmentFaxNumber: StringOperationFilterInput
"Shipment additional address line"
shipmentAdditionalAddressLine: StringOperationFilterInput
"Shipment country ISO code"
shipmentCountryIso: StringOperationFilterInput
"Shipment VAT identifier"
shipmentVatIdNumber: StringOperationFilterInput
"Sales order customer VAT identifier"
salesOrderCustomerVatIdNumber: StringOperationFilterInput
"Sales invoice company name"
salesInvoiceCompany: StringOperationFilterInput
"Sales invoice salutation"
salesInvoiceSalutation: StringOperationFilterInput
"Sales invoice title"
salesInvoiceTitle: StringOperationFilterInput
"Sales invoice first name"
salesInvoiceFirstName: StringOperationFilterInput
"Sales invoice last name"
salesInvoiceLastName: StringOperationFilterInput
"Sales invoice street address"
salesInvoiceStreet: StringOperationFilterInput
"Sales invoice postal code"
salesInvoicePostalCode: StringOperationFilterInput
"Sales invoice city"
salesInvoiceCity: StringOperationFilterInput
"Sales invoice country"
salesInvoiceCountry: StringOperationFilterInput
"Sales invoice phone number"
salesInvoicePhoneNumber: StringOperationFilterInput
"Sales invoice fax number"
salesInvoiceFaxNumber: StringOperationFilterInput
"Sales invoice additional address line"
salesInvoiceAdditionalAddressLine: StringOperationFilterInput
"Sales invoice country ISO code"
salesInvoiceIso: StringOperationFilterInput
"Customer company name"
customerCompany: StringOperationFilterInput
"Customer salutation"
customerSalutation: StringOperationFilterInput
"Customer title"
customerTitle: StringOperationFilterInput
"Customer first name"
customerFirstName: StringOperationFilterInput
"Customer last name"
customerLastName: StringOperationFilterInput
"Customer street address"
customerStreet: StringOperationFilterInput
"Customer postal code"
customerPostalCode: StringOperationFilterInput
"Customer city"
customerCity: StringOperationFilterInput
"Customer country"
customerCountry: StringOperationFilterInput
"Customer phone number"
customerPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerFaxNumber: StringOperationFilterInput
"Customer address country ISO code"
customerAddressIso: StringOperationFilterInput
"Customer email address"
customerAddressEmailAddress: StringOperationFilterInput
"Customer address VAT identifier"
customerAddressVatIdNumber: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer group identifier"
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Customer payment due date in days"
customerPaymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Last shipping date"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Tax setting"
taxSetting: ComparableNullableOfInt32OperationFilterInput
"VAT identifier"
salesOrderVatIdNumber: StringOperationFilterInput
"Departure country ISO code"
departureCountryIso: StringOperationFilterInput
"Payment method"
paymentMethod: StringOperationFilterInput
"Customer VAT identifier"
customerVatIdNumber: StringOperationFilterInput
"VAT identifier"
salesInvoiceVatIdNumber: StringOperationFilterInput
"Customer number"
salesInvoiceCustomerNumber: StringOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Payment method"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Indicates if this is a storno (cancellation)"
isCancelled: StringOperationFilterInput
"Deposit information"
deposit: StringOperationFilterInput
"Sales invoice identifier"
salesInvoiceId2: ComparableRechnungKeyOperationFilterInput
"Delivery note count"
dropShippingDeliveryNoteCount: ComparableInt32OperationFilterInput
}
input SalesInvoiceCorrectionInternalSortInput {
"Sales order identifier"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales invoice correction identifier"
salesInvoiceCorrectionId: GutschriftKeySortInput @cost(weight: "10")
"Customer identifier"
customerId: KundeKeySortInput @cost(weight: "10")
"Company identifier"
companyId: FirmaKeySortInput @cost(weight: "10")
"Sales invoice identifier"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Platform identifier"
platformId: PlattformKeySortInput @cost(weight: "10")
"Cancelled sales invoice identifier"
cancelledSalesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Sales invoice payment method identifier"
salesInvoicePaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Sales invoice correction payment method identifier"
salesInvoiceCorrectionPaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Sales invoice correction number"
salesInvoiceCorrectionNumber: SortEnumType @cost(weight: "10")
"Sales invoice correction date"
salesInvoiceCorrectionDate: SortEnumType @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Sales invoice date"
salesInvoiceDate: SortEnumType @cost(weight: "10")
"External order number"
externalOrderNumber: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Date when the order was created in the ERP system"
createdInErpDate: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Currency conversion factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Departure country currency ISO code"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Departure country currency conversion factor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Shipment type"
salesOrderShippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Shipment type"
salesInvoiceShippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Delivery date"
deliveryDate: SortEnumType @cost(weight: "10")
"Total gross amount"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Sales order total gross amount"
salesOrderTotalGrossAmount: SortEnumType @cost(weight: "10")
"Sales order total net amount"
salesOrderTotalNetAmount: SortEnumType @cost(weight: "10")
"Platform identifier"
platformIdentifier: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Shipment company name"
shipmentCompany: SortEnumType @cost(weight: "10")
"Shipment salutation"
shipmentSalutation: SortEnumType @cost(weight: "10")
"Shipment title"
shipmentTitle: SortEnumType @cost(weight: "10")
"Shipment first name"
shipmentFirstName: SortEnumType @cost(weight: "10")
"Shipment last name"
shipmentLastName: SortEnumType @cost(weight: "10")
"Shipment street address"
shipmentStreet: SortEnumType @cost(weight: "10")
"Shipment postal code"
shipmentPostalCode: SortEnumType @cost(weight: "10")
"Shipment city"
shipmentCity: SortEnumType @cost(weight: "10")
"Shipment country"
shipmentCountry: SortEnumType @cost(weight: "10")
"Shipment phone number"
shipmentPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment fax number"
shipmentFaxNumber: SortEnumType @cost(weight: "10")
"Shipment additional address line"
shipmentAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment country ISO code"
shipmentCountryIso: SortEnumType @cost(weight: "10")
"Shipment VAT identifier"
shipmentVatIdNumber: SortEnumType @cost(weight: "10")
"Sales order customer VAT identifier"
salesOrderCustomerVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice company name"
salesInvoiceCompany: SortEnumType @cost(weight: "10")
"Sales invoice salutation"
salesInvoiceSalutation: SortEnumType @cost(weight: "10")
"Sales invoice title"
salesInvoiceTitle: SortEnumType @cost(weight: "10")
"Sales invoice first name"
salesInvoiceFirstName: SortEnumType @cost(weight: "10")
"Sales invoice last name"
salesInvoiceLastName: SortEnumType @cost(weight: "10")
"Sales invoice street address"
salesInvoiceStreet: SortEnumType @cost(weight: "10")
"Sales invoice postal code"
salesInvoicePostalCode: SortEnumType @cost(weight: "10")
"Sales invoice city"
salesInvoiceCity: SortEnumType @cost(weight: "10")
"Sales invoice country"
salesInvoiceCountry: SortEnumType @cost(weight: "10")
"Sales invoice phone number"
salesInvoicePhoneNumber: SortEnumType @cost(weight: "10")
"Sales invoice fax number"
salesInvoiceFaxNumber: SortEnumType @cost(weight: "10")
"Sales invoice additional address line"
salesInvoiceAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Sales invoice country ISO code"
salesInvoiceIso: SortEnumType @cost(weight: "10")
"Customer company name"
customerCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerLastName: SortEnumType @cost(weight: "10")
"Customer street address"
customerStreet: SortEnumType @cost(weight: "10")
"Customer postal code"
customerPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerCity: SortEnumType @cost(weight: "10")
"Customer country"
customerCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerFaxNumber: SortEnumType @cost(weight: "10")
"Customer address country ISO code"
customerAddressIso: SortEnumType @cost(weight: "10")
"Customer email address"
customerAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer address VAT identifier"
customerAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer group identifier"
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Customer payment due date in days"
customerPaymentDueDateInDays: SortEnumType @cost(weight: "10")
"Last shipping date"
lastShippingDate: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"VAT identifier"
salesOrderVatIdNumber: SortEnumType @cost(weight: "10")
"Departure country ISO code"
departureCountryIso: SortEnumType @cost(weight: "10")
"Payment method"
paymentMethod: SortEnumType @cost(weight: "10")
"Customer VAT identifier"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"VAT identifier"
salesInvoiceVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
salesInvoiceCustomerNumber: SortEnumType @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Payment method"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Indicates if this is a storno (cancellation)"
isCancelled: SortEnumType @cost(weight: "10")
"Deposit information"
deposit: SortEnumType @cost(weight: "10")
"Sales invoice identifier"
salesInvoiceId2: RechnungKeySortInput @cost(weight: "10")
"Delivery note count"
dropShippingDeliveryNoteCount: SortEnumType @cost(weight: "10")
}
input SalesInvoiceCorrectionLineItemInternalFilterInput {
and: [SalesInvoiceCorrectionLineItemInternalFilterInput!]
or: [SalesInvoiceCorrectionLineItemInternalFilterInput!]
"Sales invoice correction line item identifier"
salesInvoiceCorrectionLineItemId: ComparableGutschriftPosKeyOperationFilterInput
"Sales order line item identifier"
salesOrderLineItemId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales price gross"
salesPriceGross: ComparableDecimalOperationFilterInput
"Discount amount"
discount: ComparableDecimalOperationFilterInput
"Sales price net"
salesPriceNet: ComparableDecimalOperationFilterInput
"Quantity"
quantity: ComparableDecimalOperationFilterInput
"Sales invoice correction line item name"
lineItemName: StringOperationFilterInput
"Stock keeping unit"
sku: StringOperationFilterInput
"Value added tax rate"
taxRate: ComparableDecimalOperationFilterInput
"Sales order item purchase price net"
salesOrderLineItemPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Item purchase price net"
itemPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Tax class identifier"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Line item type"
lineItemType: ComparableNullableOfByteOperationFilterInput
"Item identifier"
itemId: ComparableArtikelKeyOperationFilterInput
"Sales order parts list identifier"
billOfMaterialsSalesOrderLineItemId: ComparableVerkaufAuftragPositionKeyOperationFilterInput
"Parent item identifier"
parentItemId: ComparableArtikelKeyOperationFilterInput
"Taric code"
taric: StringOperationFilterInput
"Item weight"
itemWeight: ComparableNullableOfDecimalOperationFilterInput
"Item volume"
itemVolume: ComparableNullableOfDecimalOperationFilterInput
"Product group identifier"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Product group name"
productGroupName: StringOperationFilterInput
"Warehouse identifier"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Sales invoice line item identifier"
salesInvoiceLineItemId: ComparableRechnungPositionKeyOperationFilterInput
}
input SalesInvoiceCorrectionLineItemInternalSortInput {
"Sales invoice correction line item identifier"
salesInvoiceCorrectionLineItemId: GutschriftPosKeySortInput @cost(weight: "10")
"Sales order line item identifier"
salesOrderLineItemId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales price gross"
salesPriceGross: SortEnumType @cost(weight: "10")
"Discount amount"
discount: SortEnumType @cost(weight: "10")
"Sales price net"
salesPriceNet: SortEnumType @cost(weight: "10")
"Quantity"
quantity: SortEnumType @cost(weight: "10")
"Sales invoice correction line item name"
lineItemName: SortEnumType @cost(weight: "10")
"Stock keeping unit"
sku: SortEnumType @cost(weight: "10")
"Value added tax rate"
taxRate: SortEnumType @cost(weight: "10")
"Sales order item purchase price net"
salesOrderLineItemPurchasePriceNet: SortEnumType @cost(weight: "10")
"Item purchase price net"
itemPurchasePriceNet: SortEnumType @cost(weight: "10")
"Tax class identifier"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Line item type"
lineItemType: SortEnumType @cost(weight: "10")
"Item identifier"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Sales order parts list identifier"
billOfMaterialsSalesOrderLineItemId: VerkaufAuftragPositionKeySortInput @cost(weight: "10")
"Parent item identifier"
parentItemId: ArtikelKeySortInput @cost(weight: "10")
"Taric code"
taric: SortEnumType @cost(weight: "10")
"Item weight"
itemWeight: SortEnumType @cost(weight: "10")
"Item volume"
itemVolume: SortEnumType @cost(weight: "10")
"Product group identifier"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Product group name"
productGroupName: SortEnumType @cost(weight: "10")
"Warehouse identifier"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Sales invoice line item identifier"
salesInvoiceLineItemId: RechnungPositionKeySortInput @cost(weight: "10")
}
"Single row of the invoice corrections overview table"
input SalesInvoiceCorrectionListItemFilterInput {
and: [SalesInvoiceCorrectionListItemFilterInput!]
or: [SalesInvoiceCorrectionListItemFilterInput!]
"Unique identifier of the invoice correction"
id: ComparableGutschriftKeyOperationFilterInput
"Entry number of the invoice correction"
salesInvoiceCorrectionNumber: StringOperationFilterInput
"Entry number of the related invoice"
salesInvoiceNumber: StringOperationFilterInput
"Number of the related customer"
customerNumber: StringOperationFilterInput
"Total gross amount of the invoice correction"
totalGrossAmount: ComparableDecimalOperationFilterInput
"Total net amount of the invoice correction"
totalNetAmount: ComparableDecimalOperationFilterInput
"The revenue account of the invoice correction"
revenueAccount: StringOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Name of the customer group"
customerGroupName: StringOperationFilterInput
"Date when the invoice correction was created"
salesInvoiceCorrectionDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice correction was first printed"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice correction was first sent via e-mail"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Comment of the related invoice"
salesInvoiceComment: StringOperationFilterInput
"Date when the invoice correction was cancelled"
cancelledDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Name of the user who cancelled the invoice correction"
cancellationUserName: StringOperationFilterInput
"Cancellation reason"
cancellationReason: StringOperationFilterInput
"Cancellation comment"
cancellationComment: StringOperationFilterInput
"Short text of the invoice collection"
shortText: StringOperationFilterInput
"Billing address company"
billingAddressCompany: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street"
billingAddressStreet: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address fax number"
billingAddressFax: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"Billing address additional company line"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address state"
billingAddressState: StringOperationFilterInput
"Shipment address company"
shipmentAddressCompany: StringOperationFilterInput
"Shipment address first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street"
shipmentAddressStreet: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address fax number"
shipmentAddressFax: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address state"
shipmentAddressState: StringOperationFilterInput
"Created by user ID"
createdByUserId: ComparableBenutzerKeyOperationFilterInput
"Status text of the invoice correction"
status: StringOperationFilterInput
"CompanyId"
companyId: ComparableFirmaKeyOperationFilterInput
"Comment of the sales invoice correction"
comment: StringOperationFilterInput
"eBay user name"
ebayUsername: StringOperationFilterInput
}
"Single row of the invoice corrections overview table"
input SalesInvoiceCorrectionListItemSortInput {
"Unique identifier of the invoice correction"
id: GutschriftKeySortInput @cost(weight: "10")
"Entry number of the invoice correction"
salesInvoiceCorrectionNumber: SortEnumType @cost(weight: "10")
"Entry number of the related invoice"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Number of the related customer"
customerNumber: SortEnumType @cost(weight: "10")
"Total gross amount of the invoice correction"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount of the invoice correction"
totalNetAmount: SortEnumType @cost(weight: "10")
"The revenue account of the invoice correction"
revenueAccount: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Name of the customer group"
customerGroupName: SortEnumType @cost(weight: "10")
"Date when the invoice correction was created"
salesInvoiceCorrectionDate: SortEnumType @cost(weight: "10")
"Date when the invoice correction was first printed"
printDate: SortEnumType @cost(weight: "10")
"Date when the invoice correction was first sent via e-mail"
mailDate: SortEnumType @cost(weight: "10")
"Comment of the related invoice"
salesInvoiceComment: SortEnumType @cost(weight: "10")
"Date when the invoice correction was cancelled"
cancelledDate: SortEnumType @cost(weight: "10")
"Name of the user who cancelled the invoice correction"
cancellationUserName: SortEnumType @cost(weight: "10")
"Cancellation reason"
cancellationReason: SortEnumType @cost(weight: "10")
"Cancellation comment"
cancellationComment: SortEnumType @cost(weight: "10")
"Short text of the invoice collection"
shortText: SortEnumType @cost(weight: "10")
"Billing address company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax number"
billingAddressFax: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Billing address additional company line"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address state"
billingAddressState: SortEnumType @cost(weight: "10")
"Shipment address company"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment address first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax number"
shipmentAddressFax: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address state"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Created by user ID"
createdByUserId: BenutzerKeySortInput @cost(weight: "10")
"Status text of the invoice correction"
status: SortEnumType @cost(weight: "10")
"CompanyId"
companyId: FirmaKeySortInput @cost(weight: "10")
"Comment of the sales invoice correction"
comment: SortEnumType @cost(weight: "10")
"eBay user name"
ebayUsername: SortEnumType @cost(weight: "10")
}
input SalesInvoiceInternalFilterInput {
and: [SalesInvoiceInternalFilterInput!]
or: [SalesInvoiceInternalFilterInput!]
"Sales order ID"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales invoice ID"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"Platform ID"
platformId: ComparablePlattformKeyOperationFilterInput
"Payment method ID"
salesInvoicePaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Company ID"
companyId: ComparableFirmaKeyOperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableInt32OperationFilterInput
"Payment status"
paymentStatus: ComparableNullableOfByteOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Sales invoice date"
salesInvoiceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"External order number"
externalOrderNumber: StringOperationFilterInput
"Shipment type"
shipmentType: ComparableNullableOfInt32OperationFilterInput
"Value date"
valueDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Tax setting"
taxSetting: ComparableInt32OperationFilterInput
"Customer VAT ID"
customerVatIdNumber: StringOperationFilterInput
"Sales invoice VAT ID"
salesInvoiceVatIdNumber: StringOperationFilterInput
"Departure country ISO"
departureCountryIso: StringOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Service date"
serviceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Customer number"
salesInvoiceCustomerNumber: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Currency ISO"
currencyIso: StringOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Departure country currency ISO"
departureCountryCurrencyIso: StringOperationFilterInput
"Departure country currency factor"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"Total gross amount"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Last shipping"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Created in ERP date"
createdInErpDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Platform identifier"
platformIdentifier: StringOperationFilterInput
"Payment method"
paymentMethod: StringOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Shipment company"
shipmentAddressCompany: StringOperationFilterInput
"Shipment salutation"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment street"
shipmentAddressStreet: StringOperationFilterInput
"Shipment postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment city"
shipmentAddressCity: StringOperationFilterInput
"Shipment country"
shipmentAddressCountry: StringOperationFilterInput
"Shipment phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment fax number"
shipmentAddressFaxNumber: StringOperationFilterInput
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment country ISO"
shipmentAddressCountryIso: StringOperationFilterInput
"Shipment VAT ID"
shipmentAddressVatIdNumber: StringOperationFilterInput
"Sales order shipment country ISO"
salesOrderShipmentCountryIso: StringOperationFilterInput
"Sales invoice company"
billingAddressCompany: StringOperationFilterInput
"Sales invoice salutation"
billingAddressSalutation: StringOperationFilterInput
"Sales invoice title"
billingAddressTitle: StringOperationFilterInput
"Sales invoice first name"
billingAddressFirstName: StringOperationFilterInput
"Sales invoice last name"
billingAddressLastName: StringOperationFilterInput
"Sales invoice street"
billingAddressStreet: StringOperationFilterInput
"Sales invoice postal code"
billingAddressPostalCode: StringOperationFilterInput
"Sales invoice city"
billingAddressCity: StringOperationFilterInput
"Sales invoice country"
billingAddressCountry: StringOperationFilterInput
"Sales invoice phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Sales invoice fax number"
billingAddressFaxNumber: StringOperationFilterInput
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Sales invoice ISO"
billingAddressCountryIso: StringOperationFilterInput
"Customer company"
customerDefaultBillingAddressCompany: StringOperationFilterInput
"Customer salutation"
customerDefaultBillingAddressSalutation: StringOperationFilterInput
"Customer title"
customerDefaultBillingAddressTitle: StringOperationFilterInput
"Customer first name"
customerDefaultBillingAddressFirstName: StringOperationFilterInput
"Customer last name"
customerDefaultBillingAddressLastName: StringOperationFilterInput
"Customer street"
customerDefaultBillingAddressStreet: StringOperationFilterInput
"Customer postal code"
customerDefaultBillingAddressPostalCode: StringOperationFilterInput
"Customer city"
customerDefaultBillingAddressCity: StringOperationFilterInput
"Customer country"
customerDefaultBillingAddressCountry: StringOperationFilterInput
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerDefaultBillingAddressFaxNumber: StringOperationFilterInput
"Customer address ISO"
customerDefaultBillingAddressCountryIso: StringOperationFilterInput
"Customer address email address"
customerDefaultBillingAddressEmailAddress: StringOperationFilterInput
"Customer address VAT ID"
customerDefaultBillingAddressVatIdNumber: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer group ID"
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Customer payment due date in days"
customerPaymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Deposit"
deposit: StringOperationFilterInput
"Cancelled sales invoice ID"
cancelledSalesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Delivery note count"
dropShippingDeliveryNoteCount: ComparableInt32OperationFilterInput
}
input SalesInvoiceInternalSortInput {
"Sales order ID"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales invoice ID"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"Platform ID"
platformId: PlattformKeySortInput @cost(weight: "10")
"Payment method ID"
salesInvoicePaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Payment status"
paymentStatus: SortEnumType @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Sales invoice date"
salesInvoiceDate: SortEnumType @cost(weight: "10")
"External order number"
externalOrderNumber: SortEnumType @cost(weight: "10")
"Shipment type"
shipmentType: SortEnumType @cost(weight: "10")
"Value date"
valueDate: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"Customer VAT ID"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice VAT ID"
salesInvoiceVatIdNumber: SortEnumType @cost(weight: "10")
"Departure country ISO"
departureCountryIso: SortEnumType @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Customer number"
salesInvoiceCustomerNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Currency ISO"
currencyIso: SortEnumType @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Departure country currency ISO"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Departure country currency factor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Total gross amount"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount"
totalNetAmount: SortEnumType @cost(weight: "10")
"Last shipping"
lastShippingDate: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Created in ERP date"
createdInErpDate: SortEnumType @cost(weight: "10")
"Platform identifier"
platformIdentifier: SortEnumType @cost(weight: "10")
"Payment method"
paymentMethod: SortEnumType @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Shipment company"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment salutation"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment country"
shipmentAddressCountry: SortEnumType @cost(weight: "10")
"Shipment phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment fax number"
shipmentAddressFaxNumber: SortEnumType @cost(weight: "10")
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment country ISO"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipment VAT ID"
shipmentAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Sales order shipment country ISO"
salesOrderShipmentCountryIso: SortEnumType @cost(weight: "10")
"Sales invoice company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Sales invoice salutation"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Sales invoice title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Sales invoice first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Sales invoice last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Sales invoice street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Sales invoice postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Sales invoice city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Sales invoice country"
billingAddressCountry: SortEnumType @cost(weight: "10")
"Sales invoice phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Sales invoice fax number"
billingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Sales invoice ISO"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer company"
customerDefaultBillingAddressCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerDefaultBillingAddressSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerDefaultBillingAddressTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerDefaultBillingAddressFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerDefaultBillingAddressLastName: SortEnumType @cost(weight: "10")
"Customer street"
customerDefaultBillingAddressStreet: SortEnumType @cost(weight: "10")
"Customer postal code"
customerDefaultBillingAddressPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerDefaultBillingAddressCity: SortEnumType @cost(weight: "10")
"Customer country"
customerDefaultBillingAddressCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerDefaultBillingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Customer address ISO"
customerDefaultBillingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer address email address"
customerDefaultBillingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer address VAT ID"
customerDefaultBillingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer group ID"
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Customer payment due date in days"
customerPaymentDueDateInDays: SortEnumType @cost(weight: "10")
"Deposit"
deposit: SortEnumType @cost(weight: "10")
"Cancelled sales invoice ID"
cancelledSalesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Delivery note count"
dropShippingDeliveryNoteCount: SortEnumType @cost(weight: "10")
}
input SalesInvoiceLineItemInternalFilterInput {
and: [SalesInvoiceLineItemInternalFilterInput!]
or: [SalesInvoiceLineItemInternalFilterInput!]
"Sales invoice identifier"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Sales invoice position identifier"
salesInvoicePositionId: ComparableRechnungPositionKeyOperationFilterInput
"Sales order identifier"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Item identifier"
itemId: ComparableArtikelKeyOperationFilterInput
"Parts list line item identifier"
billOfMaterialsSalesInvoiceLineItemId: ComparableRechnungPositionKeyOperationFilterInput
"Sales invoice line item identifier"
salesInvoiceLineItemId: ComparableRechnungPositionKeyOperationFilterInput
"Sales price gross"
salesPriceGross: ComparableDecimalOperationFilterInput
"Sales price net"
salesPriceNet: ComparableDecimalOperationFilterInput
"Invoice line item purchase price net"
purchasePriceNet: ComparableDecimalOperationFilterInput
"Item purchase price net"
itemPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Invoice line item quantity"
quantity: ComparableDecimalOperationFilterInput
"Invoice line item name"
name: StringOperationFilterInput
"Stock keeping unit"
sku: StringOperationFilterInput
"Invoice line item Tax rate"
taxRate: ComparableDecimalOperationFilterInput
"Tax class identifier"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Invoice line item type"
invoiceLineItemType: ComparableByteOperationFilterInput
"Parent item identifier"
parentItemId: ComparableArtikelKeyOperationFilterInput
"Taric code"
taric: StringOperationFilterInput
"Item weight"
itemWeight: ComparableNullableOfDecimalOperationFilterInput
"Item volume"
itemVolume: ComparableNullableOfDecimalOperationFilterInput
"Product group identifier"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Product group name"
productGroupName: StringOperationFilterInput
"Warehouse identifier"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
input SalesInvoiceLineItemInternalSortInput {
"Sales invoice identifier"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Sales invoice position identifier"
salesInvoicePositionId: RechnungPositionKeySortInput @cost(weight: "10")
"Sales order identifier"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Item identifier"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Parts list line item identifier"
billOfMaterialsSalesInvoiceLineItemId: RechnungPositionKeySortInput @cost(weight: "10")
"Sales invoice line item identifier"
salesInvoiceLineItemId: RechnungPositionKeySortInput @cost(weight: "10")
"Sales price gross"
salesPriceGross: SortEnumType @cost(weight: "10")
"Sales price net"
salesPriceNet: SortEnumType @cost(weight: "10")
"Invoice line item purchase price net"
purchasePriceNet: SortEnumType @cost(weight: "10")
"Item purchase price net"
itemPurchasePriceNet: SortEnumType @cost(weight: "10")
"Invoice line item quantity"
quantity: SortEnumType @cost(weight: "10")
"Invoice line item name"
name: SortEnumType @cost(weight: "10")
"Stock keeping unit"
sku: SortEnumType @cost(weight: "10")
"Invoice line item Tax rate"
taxRate: SortEnumType @cost(weight: "10")
"Tax class identifier"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Invoice line item type"
invoiceLineItemType: SortEnumType @cost(weight: "10")
"Parent item identifier"
parentItemId: ArtikelKeySortInput @cost(weight: "10")
"Taric code"
taric: SortEnumType @cost(weight: "10")
"Item weight"
itemWeight: SortEnumType @cost(weight: "10")
"Item volume"
itemVolume: SortEnumType @cost(weight: "10")
"Product group identifier"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Product group name"
productGroupName: SortEnumType @cost(weight: "10")
"Warehouse identifier"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
"Single row of the sales invoices overview table"
input SalesInvoiceListItemFilterInput {
and: [SalesInvoiceListItemFilterInput!]
or: [SalesInvoiceListItemFilterInput!]
"Unique identifier of the sales invoice"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Created by user ID"
createdByUserId: ComparableBenutzerKeyOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Company ID"
companyId: ComparableFirmaKeyOperationFilterInput
"Company name"
companyName: StringOperationFilterInput
"The VAT ID of the merchant’s company that is shown on the invoice"
vatIdNumber: StringOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Indicates if dunning is blocked"
isDunningBlocked: ComparableBooleanOperationFilterInput
"Date when the invoice was created"
salesInvoiceDate: ComparableDateTimeOffsetOperationFilterInput
"Value date of the invoice"
valueDate: ComparableDateTimeOffsetOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Shipping method ID"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"Shipping method name"
shippingMethodName: StringOperationFilterInput
"Indicates if the invoice is a draft"
isDraft: ComparableBooleanOperationFilterInput
"Language ID"
languageId: ComparableSpracheKeyOperationFilterInput
"Tax setting value"
taxSetting: ComparableSalesInvoiceTaxSettingOperationFilterInput
"Indicates intra-community delivery"
isIntraCommunityDelivery: ComparableBooleanOperationFilterInput
"Indicates VAT exemption"
isExemptFromVat: ComparableBooleanOperationFilterInput
"Ebay username"
ebayUsername: StringOperationFilterInput
"Sales channel name"
salesChannelName: StringOperationFilterInput
"Indicates if invoice is external"
isExternalSalesInvoice: ComparableBooleanOperationFilterInput
"Indicates whether to print an existing invoice again"
printExistingSalesInvoice: ComparableBooleanOperationFilterInput
"Date when the invoice was paid"
paymentDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice was printed"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice was sent via e-mail"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Indicates if the invoice has been dunned"
isDunned: ComparableBooleanOperationFilterInput
"Open amount still to pay"
stillToPay: ComparableDecimalOperationFilterInput
"Amount already paid"
alreadyPaidAmount: ComparableDecimalOperationFilterInput
"Indicates if the invoice is completely paid"
isCompletelyPaid: ComparableBooleanOperationFilterInput
"Internal comment"
comment: StringOperationFilterInput
"Additional comment"
customerComment: StringOperationFilterInput
"Total gross amount of credits related to this invoice"
salesInvoiceCorrectionTotalGrossAmount: ComparableDecimalOperationFilterInput
"Indicates if a sales invoice correction exists"
hasSalesInvoiceCorrection: ComparableBooleanOperationFilterInput
"Payment status of the invoice"
paymentStatus: ComparableInvoicePaymentStatusOperationFilterInput
"Shipment address company"
shipmentAddressCompanyName: StringOperationFilterInput
"Shipment address form of address"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment address title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment address first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street"
shipmentAddressStreet: StringOperationFilterInput
"The additional address line of the shipment address"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: StringOperationFilterInput
"Shipment address fax"
shipmentAddressFaxNumber: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"The additional company line of the shipment address"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address post ID"
shipmentAddressPostId: StringOperationFilterInput
"Shipment address state"
shipmentAddressState: StringOperationFilterInput
"Shipment address country ISO code"
shipmentAddressCountryIso: StringOperationFilterInput
"Billing address company name"
billingAddressCompanyName: StringOperationFilterInput
"The salutation of the billing address"
billingAddressSalutation: StringOperationFilterInput
"Billing address title"
billingAddressTitle: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street"
billingAddressStreet: StringOperationFilterInput
"The additional address line of the billing address"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: StringOperationFilterInput
"Billing address fax number"
billingAddressFaxNumber: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"The additional company line of the billing address"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address post ID"
billingAddressPostId: StringOperationFilterInput
"Billing address state"
billingAddressState: StringOperationFilterInput
"Billing address country ISO code"
billingAddressCountryIso: StringOperationFilterInput
"Total gross amount of the invoice"
totalGrossAmount: ComparableDecimalOperationFilterInput
"Total gross amount in shipping country currency"
shippingCountryTotalGrossAmount: ComparableDecimalOperationFilterInput
"Total net amount of the invoice"
totalNetAmount: ComparableDecimalOperationFilterInput
"Total net amount in shipping country currency"
shippingCountryTotalNetAmount: ComparableDecimalOperationFilterInput
"Name of the user who created the invoice"
createdByUserName: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Customer group name"
customerGroupName: StringOperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Payment due date"
paymentDueDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Dunning level"
dunningLevel: ComparableNullableOfInt32OperationFilterInput
"Date of last dunning"
dunningDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Indicates if the invoice is archived"
isArchived: ComparableBooleanOperationFilterInput
"Process colour code"
processColourCode: ComparableInt32OperationFilterInput
"Process colour name"
processColourName: StringOperationFilterInput
"Platform type"
platformType: ComparableInt32OperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Indicates if the invoice has been corrected"
isCorrected: ComparableBooleanOperationFilterInput
"Indicates if the invoice is cancelled"
isCancelled: ComparableBooleanOperationFilterInput
"Date when the invoice was cancelled"
cancelledDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Cancellation comment"
cancellationComment: StringOperationFilterInput
"Name of the user who cancelled the invoice"
cancellationUserName: StringOperationFilterInput
"Cancellation reason"
cancellationReason: StringOperationFilterInput
"Related sales order ID"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"External sales order number"
externalSalesOrderNumber: StringOperationFilterInput
"Service date from (Leistungsdatum von) of the invoice"
serviceDateFrom: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Service date to (Leistungsdatum bis) of the invoice"
serviceDateTo: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date of last shipping related to the invoice"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
}
"Single row of the sales invoices overview table"
input SalesInvoiceListItemSortInput {
"Unique identifier of the sales invoice"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Created by user ID"
createdByUserId: BenutzerKeySortInput @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"Company name"
companyName: SortEnumType @cost(weight: "10")
"The VAT ID of the merchant’s company that is shown on the invoice"
vatIdNumber: SortEnumType @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Indicates if dunning is blocked"
isDunningBlocked: SortEnumType @cost(weight: "10")
"Date when the invoice was created"
salesInvoiceDate: SortEnumType @cost(weight: "10")
"Value date of the invoice"
valueDate: SortEnumType @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Shipping method ID"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Shipping method name"
shippingMethodName: SortEnumType @cost(weight: "10")
"Indicates if the invoice is a draft"
isDraft: SortEnumType @cost(weight: "10")
"Language ID"
languageId: SpracheKeySortInput @cost(weight: "10")
"Tax setting value"
taxSetting: SortEnumType @cost(weight: "10")
"Indicates intra-community delivery"
isIntraCommunityDelivery: SortEnumType @cost(weight: "10")
"Indicates VAT exemption"
isExemptFromVat: SortEnumType @cost(weight: "10")
"Ebay username"
ebayUsername: SortEnumType @cost(weight: "10")
"Sales channel name"
salesChannelName: SortEnumType @cost(weight: "10")
"Indicates if invoice is external"
isExternalSalesInvoice: SortEnumType @cost(weight: "10")
"Indicates whether to print an existing invoice again"
printExistingSalesInvoice: SortEnumType @cost(weight: "10")
"Date when the invoice was paid"
paymentDate: SortEnumType @cost(weight: "10")
"Date when the invoice was printed"
printDate: SortEnumType @cost(weight: "10")
"Date when the invoice was sent via e-mail"
mailDate: SortEnumType @cost(weight: "10")
"Indicates if the invoice has been dunned"
isDunned: SortEnumType @cost(weight: "10")
"Open amount still to pay"
stillToPay: SortEnumType @cost(weight: "10")
"Amount already paid"
alreadyPaidAmount: SortEnumType @cost(weight: "10")
"Indicates if the invoice is completely paid"
isCompletelyPaid: SortEnumType @cost(weight: "10")
"Internal comment"
comment: SortEnumType @cost(weight: "10")
"Additional comment"
customerComment: SortEnumType @cost(weight: "10")
"Total gross amount of credits related to this invoice"
salesInvoiceCorrectionTotalGrossAmount: SortEnumType @cost(weight: "10")
"Indicates if a sales invoice correction exists"
hasSalesInvoiceCorrection: SortEnumType @cost(weight: "10")
"Payment status of the invoice"
paymentStatus: SortEnumType @cost(weight: "10")
"Shipment address company"
shipmentAddressCompanyName: SortEnumType @cost(weight: "10")
"Shipment address form of address"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment address title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment address first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"The additional address line of the shipment address"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax"
shipmentAddressFaxNumber: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"The additional company line of the shipment address"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address post ID"
shipmentAddressPostId: SortEnumType @cost(weight: "10")
"Shipment address state"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Shipment address country ISO code"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Billing address company name"
billingAddressCompanyName: SortEnumType @cost(weight: "10")
"The salutation of the billing address"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Billing address title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"The additional address line of the billing address"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax number"
billingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"The additional company line of the billing address"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address post ID"
billingAddressPostId: SortEnumType @cost(weight: "10")
"Billing address state"
billingAddressState: SortEnumType @cost(weight: "10")
"Billing address country ISO code"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Total gross amount of the invoice"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total gross amount in shipping country currency"
shippingCountryTotalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount of the invoice"
totalNetAmount: SortEnumType @cost(weight: "10")
"Total net amount in shipping country currency"
shippingCountryTotalNetAmount: SortEnumType @cost(weight: "10")
"Name of the user who created the invoice"
createdByUserName: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Customer group name"
customerGroupName: SortEnumType @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Payment due date"
paymentDueDate: SortEnumType @cost(weight: "10")
"Dunning level"
dunningLevel: SortEnumType @cost(weight: "10")
"Date of last dunning"
dunningDate: SortEnumType @cost(weight: "10")
"Indicates if the invoice is archived"
isArchived: SortEnumType @cost(weight: "10")
"Process colour code"
processColourCode: SortEnumType @cost(weight: "10")
"Process colour name"
processColourName: SortEnumType @cost(weight: "10")
"Platform type"
platformType: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Indicates if the invoice has been corrected"
isCorrected: SortEnumType @cost(weight: "10")
"Indicates if the invoice is cancelled"
isCancelled: SortEnumType @cost(weight: "10")
"Date when the invoice was cancelled"
cancelledDate: SortEnumType @cost(weight: "10")
"Cancellation comment"
cancellationComment: SortEnumType @cost(weight: "10")
"Name of the user who cancelled the invoice"
cancellationUserName: SortEnumType @cost(weight: "10")
"Cancellation reason"
cancellationReason: SortEnumType @cost(weight: "10")
"Related sales order ID"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"External sales order number"
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Service date from (Leistungsdatum von) of the invoice"
serviceDateFrom: SortEnumType @cost(weight: "10")
"Service date to (Leistungsdatum bis) of the invoice"
serviceDateTo: SortEnumType @cost(weight: "10")
"Date of last shipping related to the invoice"
lastShippingDate: SortEnumType @cost(weight: "10")
}
"Single row of the salesorder overview table"
input SalesOrderListItemFilterInput {
and: [SalesOrderListItemFilterInput!]
or: [SalesOrderListItemFilterInput!]
"Sales order id"
id: ComparableVerkaufAuftragKeyOperationFilterInput
"The SalesOrder AccountsReceivableNumber"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Assigned user ID"
assignedUserId: ComparableBenutzerKeyOperationFilterInput
"Company name"
companyName: StringOperationFilterInput
"Created by user ID"
createdByUserId: ComparableBenutzerKeyOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"The SalesOrder CustomerNumber"
customerNumber: StringOperationFilterInput
"The SalesOrder DeliveryCompleteStatus"
deliveryCompleteStatus: ComparableDeliveryCompleteStatusOperationFilterInput
"The SalesOrder CountryISO"
departureCountryIso: StringOperationFilterInput
"The SalesOrder CurrencyFactor"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"The SalesOrder CurrencyISO"
departureCountryCurrencyIso: StringOperationFilterInput
"The SalesOrder EbayUsername"
ebayUsername: StringOperationFilterInput
"The SalesOrder"
estimatedDeliveryDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The SalesOrder ExternalInvoiceType"
externalSalesInvoiceType: ComparableExternalSalesInvoiceTypeOperationFilterInput
"The SalesOrder"
externalSalesOrderNumber: StringOperationFilterInput
"The SalesOrder ExtraWeight"
extraWeight: ComparableDecimalOperationFilterInput
"SpacialTaxTreatment IntraCommunityDelivery"
isIntraCommunityDelivery: ComparableBooleanOperationFilterInput
"Indicates if the order is cancelled"
isCancelled: ComparableBooleanOperationFilterInput
"Indicates if the order is pending"
isPending: ComparableBooleanOperationFilterInput
"Item description type"
itemDescriptionType: ComparableItemDescriptionTypeOperationFilterInput
"Language ISO code"
languageIso: StringOperationFilterInput
"The latest SalesOrder ShippingDate"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The SalesOrder NeedsOnlineSynchronization"
needsOnlineSynchronisation: ComparableBooleanOperationFilterInput
"On hold reason ID"
onHoldReasonId: ComparableRueckhaltegrundKeyOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Process colour code"
processColourCode: ComparableNullableOfInt32OperationFilterInput
"Process colour name"
processColourName: StringOperationFilterInput
"Process status name"
processStatusName: StringOperationFilterInput
"Read only type indicator"
readOnlyType: ComparableReadOnlyTypeOperationFilterInput
"The date when the order was created"
salesOrderDate: ComparableDateTimeOffsetOperationFilterInput
"The SalesOrder SalesOrderNumber"
salesOrderNumber: StringOperationFilterInput
"Sales order status"
salesOrderStatus: ComparableByteOperationFilterInput
"Shipping method ID"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"The SalesOrder ShippingPriority"
shippingPriority: ComparableInt32OperationFilterInput
"The SalesOrder ShopPaymentModule"
shopPaymentModule: StringOperationFilterInput
"The SalesOrder TaxSetting"
taxSetting: ComparableNullableOfTaxSettingOperationFilterInput
"The total gross amount of the order"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"SpacialTaxTreatment VATFree"
isExemptFromVat: ComparableBooleanOperationFilterInput
"The company ID"
companyId: ComparableFirmaKeyOperationFilterInput
"The internet order ID"
onlineSalesOrderId: ComparableNullableOfInt32OperationFilterInput
"Comment\/Annotation"
comment: StringOperationFilterInput
"Print date"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Mail date"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Payment mail date"
paymentMailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date of payment"
dateOfPayment: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Payment date"
paymentDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"On hold reason name"
onHoldReasonName: StringOperationFilterInput
"Sales invoice status"
salesInvoiceStatus: ComparableInvoiceStatusOperationFilterInput
"Billing address company"
billingAddressCompany: StringOperationFilterInput
"Billing address additional company line"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address salutation"
billingAddressSalutation: StringOperationFilterInput
"Billing address title"
billingAddressTitle: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street"
billingAddressStreet: StringOperationFilterInput
"Billing address additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: StringOperationFilterInput
"Billing address fax"
billingAddressFax: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"Billing address post ID"
billingAddressPostId: StringOperationFilterInput
"Billing address state"
billingAddressState: StringOperationFilterInput
"Billing address country ISO"
billingAddressCountryIso: StringOperationFilterInput
"Shipment address company"
shipmentAddressCompany: StringOperationFilterInput
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address salutation"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment address title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment address first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street"
shipmentAddressStreet: StringOperationFilterInput
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: StringOperationFilterInput
"Shipment address fax"
shipmentAddressFax: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"Shipment address post ID"
shipmentAddressPostId: StringOperationFilterInput
"Shipment address state"
shipmentAddressState: StringOperationFilterInput
"Shipment address country ISO"
shipmentAddressCountryIso: StringOperationFilterInput
"Assigned user name"
assignedUserName: StringOperationFilterInput
"Sales channel name"
salesChannelName: StringOperationFilterInput
"Customer group name"
customerGroupName: StringOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Shipping method name"
shippingMethodName: StringOperationFilterInput
"Shipping country total gross amount"
shippingCountryTotalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Customer comment"
customerComment: StringOperationFilterInput
"Payment reference"
paymentReference: StringOperationFilterInput
"Credits total gross amount"
salesInvoiceCorrectionTotalGrossAmount: ComparableDecimalOperationFilterInput
"Already paid amount"
alreadyPaidAmount: ComparableDecimalOperationFilterInput
"Still to pay amount"
stillToPay: ComparableNullableOfDecimalOperationFilterInput
"Total net amount"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"WMS locked"
wmsLocked: ComparableNullableOfByteOperationFilterInput
"WMS partial shipment"
wmsPartialShipment: ComparableNullableOfInt32OperationFilterInput
"WMS pre picking"
wmsPrePicking: ComparableNullableOfInt32OperationFilterInput
"Payment status"
paymentStatus: ComparableInvoicePaymentStatusOperationFilterInput
"Delivery status"
deliveryStatus: ComparableDeliveryStatusOperationFilterInput
"Platform type"
platformType: ComparableInt32OperationFilterInput
"Sales invoice numbers"
salesInvoiceNumbers: StringOperationFilterInput
"Cancelled date"
cancelledDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Cancellation comment"
cancellationComment: StringOperationFilterInput
"Cancellation user name"
cancellationUserName: StringOperationFilterInput
"Cancellation reason"
cancellationReason: StringOperationFilterInput
"Amazon user ID"
amazonUserId: ComparableNullableOfInt32OperationFilterInput
"Created by user name"
createdByUserName: StringOperationFilterInput
}
"Single row of the salesorder overview table"
input SalesOrderListItemSortInput {
"Sales order id"
id: VerkaufAuftragKeySortInput @cost(weight: "10")
"The SalesOrder AccountsReceivableNumber"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Assigned user ID"
assignedUserId: BenutzerKeySortInput @cost(weight: "10")
"Company name"
companyName: SortEnumType @cost(weight: "10")
"Created by user ID"
createdByUserId: BenutzerKeySortInput @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"The SalesOrder CustomerNumber"
customerNumber: SortEnumType @cost(weight: "10")
"The SalesOrder DeliveryCompleteStatus"
deliveryCompleteStatus: SortEnumType @cost(weight: "10")
"The SalesOrder CountryISO"
departureCountryIso: SortEnumType @cost(weight: "10")
"The SalesOrder CurrencyFactor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"The SalesOrder CurrencyISO"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"The SalesOrder EbayUsername"
ebayUsername: SortEnumType @cost(weight: "10")
"The SalesOrder"
estimatedDeliveryDate: SortEnumType @cost(weight: "10")
"The SalesOrder ExternalInvoiceType"
externalSalesInvoiceType: SortEnumType @cost(weight: "10")
"The SalesOrder"
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"The SalesOrder ExtraWeight"
extraWeight: SortEnumType @cost(weight: "10")
"SpacialTaxTreatment IntraCommunityDelivery"
isIntraCommunityDelivery: SortEnumType @cost(weight: "10")
"Indicates if the order is cancelled"
isCancelled: SortEnumType @cost(weight: "10")
"Indicates if the order is pending"
isPending: SortEnumType @cost(weight: "10")
"Item description type"
itemDescriptionType: SortEnumType @cost(weight: "10")
"Language ISO code"
languageIso: SortEnumType @cost(weight: "10")
"The latest SalesOrder ShippingDate"
lastShippingDate: SortEnumType @cost(weight: "10")
"The SalesOrder NeedsOnlineSynchronization"
needsOnlineSynchronisation: SortEnumType @cost(weight: "10")
"On hold reason ID"
onHoldReasonId: RueckhaltegrundKeySortInput @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Process colour code"
processColourCode: SortEnumType @cost(weight: "10")
"Process colour name"
processColourName: SortEnumType @cost(weight: "10")
"Process status name"
processStatusName: SortEnumType @cost(weight: "10")
"Read only type indicator"
readOnlyType: SortEnumType @cost(weight: "10")
"The date when the order was created"
salesOrderDate: SortEnumType @cost(weight: "10")
"The SalesOrder SalesOrderNumber"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Sales order status"
salesOrderStatus: SortEnumType @cost(weight: "10")
"Shipping method ID"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"The SalesOrder ShippingPriority"
shippingPriority: SortEnumType @cost(weight: "10")
"The SalesOrder ShopPaymentModule"
shopPaymentModule: SortEnumType @cost(weight: "10")
"The SalesOrder TaxSetting"
taxSetting: SortEnumType @cost(weight: "10")
"The total gross amount of the order"
totalGrossAmount: SortEnumType @cost(weight: "10")
"SpacialTaxTreatment VATFree"
isExemptFromVat: SortEnumType @cost(weight: "10")
"The company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"The internet order ID"
onlineSalesOrderId: SortEnumType @cost(weight: "10")
"Comment\/Annotation"
comment: SortEnumType @cost(weight: "10")
"Print date"
printDate: SortEnumType @cost(weight: "10")
"Mail date"
mailDate: SortEnumType @cost(weight: "10")
"Payment mail date"
paymentMailDate: SortEnumType @cost(weight: "10")
"Date of payment"
dateOfPayment: SortEnumType @cost(weight: "10")
"Payment date"
paymentDate: SortEnumType @cost(weight: "10")
"On hold reason name"
onHoldReasonName: SortEnumType @cost(weight: "10")
"Sales invoice status"
salesInvoiceStatus: SortEnumType @cost(weight: "10")
"Billing address company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Billing address additional company line"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address salutation"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Billing address title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Billing address additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax"
billingAddressFax: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Billing address post ID"
billingAddressPostId: SortEnumType @cost(weight: "10")
"Billing address state"
billingAddressState: SortEnumType @cost(weight: "10")
"Billing address country ISO"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipment address company"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address salutation"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment address title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment address first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax"
shipmentAddressFax: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"Shipment address post ID"
shipmentAddressPostId: SortEnumType @cost(weight: "10")
"Shipment address state"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Shipment address country ISO"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Assigned user name"
assignedUserName: SortEnumType @cost(weight: "10")
"Sales channel name"
salesChannelName: SortEnumType @cost(weight: "10")
"Customer group name"
customerGroupName: SortEnumType @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Shipping method name"
shippingMethodName: SortEnumType @cost(weight: "10")
"Shipping country total gross amount"
shippingCountryTotalGrossAmount: SortEnumType @cost(weight: "10")
"Customer comment"
customerComment: SortEnumType @cost(weight: "10")
"Payment reference"
paymentReference: SortEnumType @cost(weight: "10")
"Credits total gross amount"
salesInvoiceCorrectionTotalGrossAmount: SortEnumType @cost(weight: "10")
"Already paid amount"
alreadyPaidAmount: SortEnumType @cost(weight: "10")
"Still to pay amount"
stillToPay: SortEnumType @cost(weight: "10")
"Total net amount"
totalNetAmount: SortEnumType @cost(weight: "10")
"WMS locked"
wmsLocked: SortEnumType @cost(weight: "10")
"WMS partial shipment"
wmsPartialShipment: SortEnumType @cost(weight: "10")
"WMS pre picking"
wmsPrePicking: SortEnumType @cost(weight: "10")
"Payment status"
paymentStatus: SortEnumType @cost(weight: "10")
"Delivery status"
deliveryStatus: SortEnumType @cost(weight: "10")
"Platform type"
platformType: SortEnumType @cost(weight: "10")
"Sales invoice numbers"
salesInvoiceNumbers: SortEnumType @cost(weight: "10")
"Cancelled date"
cancelledDate: SortEnumType @cost(weight: "10")
"Cancellation comment"
cancellationComment: SortEnumType @cost(weight: "10")
"Cancellation user name"
cancellationUserName: SortEnumType @cost(weight: "10")
"Cancellation reason"
cancellationReason: SortEnumType @cost(weight: "10")
"Amazon user ID"
amazonUserId: SortEnumType @cost(weight: "10")
"Created by user name"
createdByUserName: SortEnumType @cost(weight: "10")
}
"Single row of the sales quotation overview table"
input SalesQuotationListItemFilterInput {
and: [SalesQuotationListItemFilterInput!]
or: [SalesQuotationListItemFilterInput!]
"Sales quotation unique identifier"
id: ComparableVerkaufAuftragKeyOperationFilterInput
"Assigned user ID"
assignedUserId: ComparableBenutzerKeyOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"Shipping method ID"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"Company (firm) ID"
companyId: ComparableFirmaKeyOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Official sales quotation number"
salesQuotationNumber: StringOperationFilterInput
"External reference number for the quotation"
externalSalesQuotationNumber: StringOperationFilterInput
"Name of the platform where the quotation originated"
platformName: StringOperationFilterInput
"Internal comments or remarks"
comment: StringOperationFilterInput
"ISO currency code used for the quotation"
currencyIso: StringOperationFilterInput
"Exchange rate factor for the currency"
currencyFactor: ComparableDecimalOperationFilterInput
"Date when the quotation was printed"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the quotation was sent via email"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Display text for the current process status"
processStatusName: StringOperationFilterInput
"Additional weight calculated for the quotation"
extraWeight: ComparableDecimalOperationFilterInput
"Total shipping weight"
shippingWeight: ComparableDecimalOperationFilterInput
"Date and time when the quotation was created"
salesQuotationDate: ComparableDateTimeOffsetOperationFilterInput
"ISO code of the departure\/shipping country"
departureCountryIso: StringOperationFilterInput
"Name of the departure\/shipping country"
departureCountryName: StringOperationFilterInput
"Currency ISO code of the departure country"
departureCountryCurrencyIso: StringOperationFilterInput
"Currency exchange factor of the departure country"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"Billing address company"
billingAddressCompany: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street and house number"
billingAddressStreet: StringOperationFilterInput
"Billing address additional address line (e.g., apartment, suite)"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address fax number"
billingAddressFax: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"Billing address additional company information line"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address state or province"
billingAddressState: StringOperationFilterInput
"Shipment address company name"
shipmentAddressCompany: StringOperationFilterInput
"Shipment address contact first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address contact last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street and house number"
shipmentAddressStreet: StringOperationFilterInput
"Shipment address additional address line (e.g., apartment, suite)"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address fax number"
shipmentAddressFax: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"Shipment address additional company information line"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address state or province"
shipmentAddressState: StringOperationFilterInput
"Name of the user currently assigned to this quotation"
assignedUserName: StringOperationFilterInput
"Name of the user who originally created the quotation"
createdByUserName: StringOperationFilterInput
"Display name of the company"
companyName: StringOperationFilterInput
"Name of the sales channel or shop"
salesChannelName: StringOperationFilterInput
"Name of the assigned customer group"
customerGroupName: StringOperationFilterInput
"Display name of the selected payment method"
paymentMethodName: StringOperationFilterInput
"Display name of the selected shipping method"
shippingMethodName: StringOperationFilterInput
"Unique customer business number"
customerNumber: StringOperationFilterInput
"Total gross amount in the system's base currency"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount in the system's base currency"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Total gross amount converted to the shipping country's currency"
shippingCountryTotalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount converted to the shipping country's currency"
shippingCountryTotalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Additional customer-related notes or miscellaneous instructions"
customerComment: StringOperationFilterInput
"ARGB or numeric color code for process highlighting"
processColourCode: ComparableNullableOfInt32OperationFilterInput
"Descriptive name of the assigned process color"
processColourName: StringOperationFilterInput
}
"Single row of the sales quotation overview table"
input SalesQuotationListItemSortInput {
"Sales quotation unique identifier"
id: VerkaufAuftragKeySortInput @cost(weight: "10")
"Assigned user ID"
assignedUserId: BenutzerKeySortInput @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"Shipping method ID"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Company (firm) ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Official sales quotation number"
salesQuotationNumber: SortEnumType @cost(weight: "10")
"External reference number for the quotation"
externalSalesQuotationNumber: SortEnumType @cost(weight: "10")
"Name of the platform where the quotation originated"
platformName: SortEnumType @cost(weight: "10")
"Internal comments or remarks"
comment: SortEnumType @cost(weight: "10")
"ISO currency code used for the quotation"
currencyIso: SortEnumType @cost(weight: "10")
"Exchange rate factor for the currency"
currencyFactor: SortEnumType @cost(weight: "10")
"Date when the quotation was printed"
printDate: SortEnumType @cost(weight: "10")
"Date when the quotation was sent via email"
mailDate: SortEnumType @cost(weight: "10")
"Display text for the current process status"
processStatusName: SortEnumType @cost(weight: "10")
"Additional weight calculated for the quotation"
extraWeight: SortEnumType @cost(weight: "10")
"Total shipping weight"
shippingWeight: SortEnumType @cost(weight: "10")
"Date and time when the quotation was created"
salesQuotationDate: SortEnumType @cost(weight: "10")
"ISO code of the departure\/shipping country"
departureCountryIso: SortEnumType @cost(weight: "10")
"Name of the departure\/shipping country"
departureCountryName: SortEnumType @cost(weight: "10")
"Currency ISO code of the departure country"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Currency exchange factor of the departure country"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Billing address company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street and house number"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Billing address additional address line (e.g., apartment, suite)"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax number"
billingAddressFax: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Billing address additional company information line"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address state or province"
billingAddressState: SortEnumType @cost(weight: "10")
"Shipment address company name"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment address contact first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address contact last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street and house number"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment address additional address line (e.g., apartment, suite)"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax number"
shipmentAddressFax: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"Shipment address additional company information line"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address state or province"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Name of the user currently assigned to this quotation"
assignedUserName: SortEnumType @cost(weight: "10")
"Name of the user who originally created the quotation"
createdByUserName: SortEnumType @cost(weight: "10")
"Display name of the company"
companyName: SortEnumType @cost(weight: "10")
"Name of the sales channel or shop"
salesChannelName: SortEnumType @cost(weight: "10")
"Name of the assigned customer group"
customerGroupName: SortEnumType @cost(weight: "10")
"Display name of the selected payment method"
paymentMethodName: SortEnumType @cost(weight: "10")
"Display name of the selected shipping method"
shippingMethodName: SortEnumType @cost(weight: "10")
"Unique customer business number"
customerNumber: SortEnumType @cost(weight: "10")
"Total gross amount in the system's base currency"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount in the system's base currency"
totalNetAmount: SortEnumType @cost(weight: "10")
"Total gross amount converted to the shipping country's currency"
shippingCountryTotalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount converted to the shipping country's currency"
shippingCountryTotalNetAmount: SortEnumType @cost(weight: "10")
"Additional customer-related notes or miscellaneous instructions"
customerComment: SortEnumType @cost(weight: "10")
"ARGB or numeric color code for process highlighting"
processColourCode: SortEnumType @cost(weight: "10")
"Descriptive name of the assigned process color"
processColourName: SortEnumType @cost(weight: "10")
}
"Single Row of the serial number query"
input SerialNumberListItemFilterInput {
and: [SerialNumberListItemFilterInput!]
or: [SerialNumberListItemFilterInput!]
"Id of the Warehouse."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Id of the item."
itemId: ComparableArtikelKeyOperationFilterInput
"Serial numbers of the item."
serialNumber: StringOperationFilterInput
"Indicates if the serial number is active."
isActive: ComparableBooleanOperationFilterInput
}
"Single Row of the serial number query"
input SerialNumberListItemSortInput {
"Id of the Warehouse."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Id of the item."
itemId: ArtikelKeySortInput @cost(weight: "10")
"Serial numbers of the item."
serialNumber: SortEnumType @cost(weight: "10")
"Indicates if the serial number is active."
isActive: SortEnumType @cost(weight: "10")
}
"Sets the maximum stock quantity for the specified marketplace offers. - Request"
input SetMarketplaceOfferMaxQuantityCommandRequestInput {
"Marketplace offer keys to update."
offerKeys: [ID]!
"Maximum stock quantity to set for each specified marketplace offer."
maxQuantity: Decimal!
}
"Sets the minimum stock quantity for the specified marketplace offers. - Request"
input SetMarketplaceOfferMinQuantityCommandRequestInput {
"Marketplace offer keys to update."
offerKeys: [ID]!
"Minimum stock quantity to set for each specified marketplace offer."
minQuantity: Decimal!
}
"Single row of the shipping boxes overview list."
input ShippingBoxListItemFilterInput {
and: [ShippingBoxListItemFilterInput!]
or: [ShippingBoxListItemFilterInput!]
"Shipping box identifier."
id: ComparableLhmKeyOperationFilterInput
"Display name of the shipping box."
displayId: StringOperationFilterInput
"Box type identifier (nullable in DB)."
typeId: ComparableLhmTypeKeyOperationFilterInput
"Assigned bin location (can be 0 or null in DB)."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Parent warehouse."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Lock status (false=unlocked, true=locked). Nullable in database."
locked: ComparableBooleanOperationFilterInput
}
"Single row of the shipping boxes overview list."
input ShippingBoxListItemSortInput {
"Shipping box identifier."
id: LhmKeySortInput @cost(weight: "10")
"Display name of the shipping box."
displayId: SortEnumType @cost(weight: "10")
"Box type identifier (nullable in DB)."
typeId: LhmTypeKeySortInput @cost(weight: "10")
"Lock status (false=unlocked, true=locked). Nullable in database."
locked: SortEnumType @cost(weight: "10")
}
"Reference data describing an available shipping box type."
input ShippingBoxTypeFilterInput {
and: [ShippingBoxTypeFilterInput!]
or: [ShippingBoxTypeFilterInput!]
"Box type identifier."
value: ComparableLhmTypeKeyOperationFilterInput
"Display name for the box type."
name: StringOperationFilterInput
}
"Reference data describing an available shipping box type."
input ShippingBoxTypeSortInput {
"Box type identifier."
value: LhmTypeKeySortInput @cost(weight: "10")
"Display name for the box type."
name: SortEnumType @cost(weight: "10")
}
"Single row of the shipping class overview"
input ShippingClassListItemFilterInput {
and: [ShippingClassListItemFilterInput!]
or: [ShippingClassListItemFilterInput!]
"ShippingClass id"
id: ComparableVersandklasseKeyOperationFilterInput
}
"Single row of the shipping class overview"
input ShippingClassListItemSortInput {
"ShippingClass id"
id: VersandklasseKeySortInput @cost(weight: "10")
}
"Single Row of the shipping method lookup"
input ShippingMethodLookupItemFilterInput {
and: [ShippingMethodLookupItemFilterInput!]
or: [ShippingMethodLookupItemFilterInput!]
"Id of the shipping method."
id: ComparableVersandartKeyOperationFilterInput
"Default Category Name"
name: StringOperationFilterInput
"Is the shipping method active"
isActive: ComparableBooleanOperationFilterInput
}
"Single Row of the shipping method lookup"
input ShippingMethodLookupItemSortInput {
"Id of the shipping method."
id: VersandartKeySortInput @cost(weight: "10")
"Default Category Name"
name: SortEnumType @cost(weight: "10")
"Is the shipping method active"
isActive: SortEnumType @cost(weight: "10")
}
input ShopKeySortInput {
kShop: SortEnumType @cost(weight: "10")
}
input SpracheKeySortInput {
kSprache: SortEnumType @cost(weight: "10")
}
input SteuerklasseKeySortInput {
kSteuerklasse: SortEnumType @cost(weight: "10")
}
input SteuerschluesselKeySortInput {
kSteuerschluessel: SortEnumType @cost(weight: "10")
}
"Provides paged access to stock movement history entries filtered by warehouse and optional criteria."
input StockMovementHistoryItemFilterInput {
and: [StockMovementHistoryItemFilterInput!]
or: [StockMovementHistoryItemFilterInput!]
"Article number (cArtNr)."
articleNumber: StringOperationFilterInput
"Article display name."
articleName: StringOperationFilterInput
"Movement quantity."
quantity: ComparableDecimalOperationFilterInput
"Best-before date (MHD), if tracked."
bestBeforeDate: ComparableNullableOfDateTimeOperationFilterInput
"Batch\/charge number."
batchNumber: StringOperationFilterInput
"First serial number linked to the movement."
serialNumber: StringOperationFilterInput
"Count of serial numbers linked to the movement."
serialNumberCount: ComparableInt32OperationFilterInput
"Source bin location name."
sourceBinLocation: StringOperationFilterInput
"Target bin location name."
targetBinLocation: StringOperationFilterInput
"Source shipping box display ID."
sourceBoxDisplayId: StringOperationFilterInput
"Target shipping box display ID."
targetBoxDisplayId: StringOperationFilterInput
"Transfer type key (kBuchungsArt)."
transferTypeId: ComparableNullableOfInt32OperationFilterInput
"Transfer type name."
transferTypeName: StringOperationFilterInput
"User name."
userName: StringOperationFilterInput
"Movement timestamp."
timestamp: ComparableDateTimeOperationFilterInput
"Movement comment."
comment: StringOperationFilterInput
}
"Provides paged access to stock movement history entries filtered by warehouse and optional criteria."
input StockMovementHistoryItemSortInput {
"Article number (cArtNr)."
articleNumber: SortEnumType @cost(weight: "10")
"Article display name."
articleName: SortEnumType @cost(weight: "10")
"Movement quantity."
quantity: SortEnumType @cost(weight: "10")
"Best-before date (MHD), if tracked."
bestBeforeDate: SortEnumType @cost(weight: "10")
"Batch\/charge number."
batchNumber: SortEnumType @cost(weight: "10")
"First serial number linked to the movement."
serialNumber: SortEnumType @cost(weight: "10")
"Count of serial numbers linked to the movement."
serialNumberCount: SortEnumType @cost(weight: "10")
"Source bin location name."
sourceBinLocation: SortEnumType @cost(weight: "10")
"Target bin location name."
targetBinLocation: SortEnumType @cost(weight: "10")
"Source shipping box display ID."
sourceBoxDisplayId: SortEnumType @cost(weight: "10")
"Target shipping box display ID."
targetBoxDisplayId: SortEnumType @cost(weight: "10")
"Transfer type key (kBuchungsArt)."
transferTypeId: SortEnumType @cost(weight: "10")
"Transfer type name."
transferTypeName: SortEnumType @cost(weight: "10")
"User name."
userName: SortEnumType @cost(weight: "10")
"Movement timestamp."
timestamp: SortEnumType @cost(weight: "10")
"Movement comment."
comment: SortEnumType @cost(weight: "10")
}
"Single Row of the stock reservations query"
input StockReservationListItemFilterInput {
and: [StockReservationListItemFilterInput!]
or: [StockReservationListItemFilterInput!]
"Id of the item"
itemId: ComparableArtikelKeyOperationFilterInput
"Id of the sales order"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Id of the customer"
customerId: ComparableKundeKeyOperationFilterInput
"Creation date of the reservation"
createdAt: ComparableDateTimeOffsetOperationFilterInput
"Reserved amount"
amount: ComparableDecimalOperationFilterInput
}
"Single Row of the stock reservations query"
input StockReservationListItemSortInput {
"Id of the item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Id of the sales order"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Id of the customer"
customerId: KundeKeySortInput @cost(weight: "10")
"Reserved amount"
amount: SortEnumType @cost(weight: "10")
"Creation date of the reservation"
createdAt: SortEnumType @cost(weight: "10")
"eBay item identifier"
ebayItemId: SortEnumType @cost(weight: "10")
"Sales platform"
platform: SortEnumType @cost(weight: "10")
}
"Single Row of the storage location query"
input StorageLocationListItemFilterInput {
and: [StorageLocationListItemFilterInput!]
or: [StorageLocationListItemFilterInput!]
"Id of the storage location."
id: ComparableWarenLagerPlatzKeyOperationFilterInput
"Default storage location name"
name: StringOperationFilterInput
}
"Single Row of the storage location query"
input StorageLocationListItemSortInput {
"Id of the storage location."
id: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Default storage location name"
name: SortEnumType @cost(weight: "10")
}
input StringOperationFilterInput {
and: [StringOperationFilterInput!]
or: [StringOperationFilterInput!]
eq: String @cost(weight: "10")
neq: String @cost(weight: "10")
contains: String @cost(weight: "20")
ncontains: String @cost(weight: "20")
in: [String] @cost(weight: "10")
nin: [String] @cost(weight: "10")
startsWith: String @cost(weight: "20")
nstartsWith: String @cost(weight: "20")
endsWith: String @cost(weight: "20")
nendsWith: String @cost(weight: "20")
}
"Single row of the supplier overview table"
input SupplierFilterInput {
and: [SupplierFilterInput!]
or: [SupplierFilterInput!]
"Unique identifier of the supplier"
id: ComparableLieferantKeyOperationFilterInput
"Name of the supplier"
name: StringOperationFilterInput
"Is drop shipping supplier"
canDropship: ComparableBooleanOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
}
"Single row of the supplier overview table"
input SupplierSortInput {
"Unique identifier of the supplier"
id: LieferantKeySortInput @cost(weight: "10")
"Name of the supplier"
name: SortEnumType @cost(weight: "10")
"Is drop shipping supplier"
canDropship: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
}
"Represents a tax class in the system"
input TaxClassFilterInput {
and: [TaxClassFilterInput!]
or: [TaxClassFilterInput!]
"The unique identifier of the tax class"
id: ComparableSteuerklasseKeyOperationFilterInput
"Indicates if this tax class is the standard tax class"
isStandard: ComparableBooleanOperationFilterInput
"The name of the tax class"
name: StringOperationFilterInput
"The type of the tax class"
taxType: ComparableTaxTypeOperationFilterInput
}
"Represents a tax class in the system"
input TaxClassSortInput {
"The unique identifier of the tax class"
id: SteuerklasseKeySortInput @cost(weight: "10")
"Indicates if this tax class is the standard tax class"
isStandard: SortEnumType @cost(weight: "10")
"The name of the tax class"
name: SortEnumType @cost(weight: "10")
"The type of the tax class"
taxType: SortEnumType @cost(weight: "10")
}
"Represents a tax code in the system"
input TaxCodeFilterInput {
and: [TaxCodeFilterInput!]
or: [TaxCodeFilterInput!]
"The unique identifier of the tax code"
id: ComparableSteuerschluesselKeyOperationFilterInput
"The cash discount account of the tax code"
cashDiscountAccount: StringOperationFilterInput
"The general ledger account of the tax code"
generalLedgerAccount: StringOperationFilterInput
"Indicates if this tax code is automatic"
isAutomatic: ComparableBooleanOperationFilterInput
"The name of the tax code"
name: StringOperationFilterInput
"The number of the tax code"
number: ComparableNullableOfInt32OperationFilterInput
}
"Represents a tax code in the system"
input TaxCodeSortInput {
"The unique identifier of the tax code"
id: SteuerschluesselKeySortInput @cost(weight: "10")
"The cash discount account of the tax code"
cashDiscountAccount: SortEnumType @cost(weight: "10")
"The general ledger account of the tax code"
generalLedgerAccount: SortEnumType @cost(weight: "10")
"Indicates if this tax code is automatic"
isAutomatic: SortEnumType @cost(weight: "10")
"The name of the tax code"
name: SortEnumType @cost(weight: "10")
"The number of the tax code"
number: SortEnumType @cost(weight: "10")
}
"Triggers stock synchronisation for the specified marketplace offers. - Request"
input TriggerMarketplaceStockSynchronisationCommandRequestInput {
"Marketplace offer keys to include in the next stock synchronisation."
offerKeys: [ID]!
}
"Unlocks a bin location for available stock, allowing it to be used for stock allocation. - Request"
input UnlockBinLocationForAvailableStockCommandRequestInput {
"Unique identifier of the bin location to unlock for available stock."
binLocationId: ID!
}
input UpdateAttributeSalesChannelValuesInput {
"Identifies the saleschannel for this attributevalue"
salesChannelId: ID!
"Contains the values for a saleschannel"
values: [UpdateAttributeValueInput]
}
input UpdateAttributeValueInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Value of this attribute as string. Please consider the Attribute Type for correct formatting."
value: String!
}
input UpdateAttributeValuesInput {
"Identifies the attribute"
attributeId: ID!
"Defines the default values for the attribute and item in different languages."
defaultValues: [UpdateAttributeValueInput]
"Contains all values for saleschannels for this attribute and item"
salesChannelValues: [UpdateAttributeSalesChannelValuesInput]
}
"Updates metadata of an existing bin location (name, type, sort order). - Request"
input UpdateBinLocationMetadataCommandRequestInput {
"Unique identifier of the bin location to update."
binLocationId: ID!
"New name for the bin location (must be unique within the warehouse, max 50 chars, no apostrophes)."
name: String
"New type for the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: Int
"New sort order."
sort: Int
}
"Updates a new Category - Request"
input UpdateCategoryCommandRequestInput {
"The category to update"
id: ID!
"The parent category of the category."
parentId: ID
"The sort number of the category."
sortNumber: Int
"The category name."
name: String
}
"Updates a customer - Request"
input UpdateCustomerCommandRequestInput {
"Id of the customer."
customerId: ID!
"Id of the company the customer belongs to. Optional — if omitted, the existing company assignment is left unchanged."
companyId: ID
"Customer group for the customer to be in."
customerGroupId: ID
"The customers category ID."
customerCategoryId: ID
"The customers preferred payment method ID."
paymentMethodId: ID
"The accounts receivable number of the customer."
accountsReceivableNumber: Int
"The customer's date of birth."
birthday: DateTime
"The customer's commercial register number."
commercialRegisterNumber: String
"Number of the customer. If no number is given when posting a customer, the number will be generated automatically."
customerNumber: String
"The customers ebay name."
ebayName: String
"The customers homepage URL."
homepage: String
"The source of initial contact. This could be for example a specific sales channel, a convention or a marketing campaign."
initialContact: String
"States if a customer is from a cash-register or point of sale and if their data should be synchronized with JTL-POS, for example."
isCashRegisterBased: Boolean
"The customer's locked status."
isLocked: Boolean
"The customer's preferred language in ISO format (e.g. \"de\", \"en\")."
languageIso: String
"The customer's tax identification number."
taxIdentificationNumber: String
"Addresses of the customer."
addresses: [UpdateUpdateCustomerAddressInput]
"Settings relevant to payment for the customer."
paymentSettings: UpdateUpdateCustomerPaymentSettingsInput
"The date and time of the customer's creation."
createdDate: DateTime
}
input UpdateCustomerGroupSurchargeInput {
"Id of the customergroup"
customerGroupId: ID!
"Surcharge for that customergroup"
surcharge: Decimal
"Defines if the surcharges will be synchronized to online saleschannels. Does not apply for the default customer group surcharges, which are always synchronized when not overriden."
isActive: Boolean
}
"Defines a default description of an item in a specific language. This description is used as a fallback when no more specific platform or sales channel descriptions are available."
input UpdateDefaultDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the actual description data such as name, short and long description as well as SEO-relevant information."
descriptionData: UpdateDescriptionDataInput!
}
"Defines the actual description data of an item. This structure contains all textual information of an item including SEO-relevant metadata for online shops."
input UpdateDescriptionDataInput {
"The name of the item as displayed in the user interface or shop."
itemName: String
"Short description of the item for overview displays and search results."
shortDescription: String
"Detailed description of the item with comprehensive product information and properties."
description: String
"Meta description for search engine optimization (SEO) that is displayed in search results."
metaDescription: String
"Meta keywords for search engine optimization to improve discoverability of the item."
metaKeywords: String
"HTML title tag for the item that is displayed in the browser tab and search results."
titleTag: String
"URL path for the item to create SEO-friendly and speaking URLs."
urlPath: String
}
input UpdateDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Name of the Variation in the specific language"
name: String!
}
input UpdateEbayImagesInput {
"Unique ID to identify an ebay account."
ebayAccountId: ID!
"List of images assigned to the platform."
images: [UpdateItemImageInput]
}
input UpdateItemAttributesInput {
"Contains all attribute values assigned to the item"
values: [UpdateAttributeValuesInput]
}
"Defines the category assignments of an item for creation. This structure manages all categories to which an item can be assigned and enables hierarchical classification for better organization and navigation."
input UpdateItemCategoriesInput {
"Contains all categories to which the item is assigned. An item can be assigned to multiple categories simultaneously to enable flexible categorization and better discoverability."
categories: [UpdateItemCategoryInput]
}
"Defines a single category assignment for an item. This structure represents the link between an item and a specific category in the hierarchical category system of the ERP system."
input UpdateItemCategoryInput {
"Unique key of the category that identifies the specific category to which the item should be assigned. This key establishes the connection to the category data."
categoryId: ID!
}
"Defines a single custom field value for an item. This structure connects a custom field definition with its actual value for a specific item."
input UpdateItemCustomFieldValueInput {
"Unique identifier of the custom field definition. References the custom field that was previously created in the system."
fieldId: ID!
"The actual value stored in this custom field. The format and content depend on the custom field type definition (text, number, date, etc.)."
value: String!
"The culture name (e.g., \"en-US\", \"de-DE\") associated with the custom field value. This is important for localized fields where the value may vary based on the user's language or region. When returning those values from the server side this Format is always InvariantCulture. When sending values to the server side the culture name is optional and if not provided, it will be treated as InvariantCulture. Otherwise this value initializes a CultureInfo Object."
valueCultureName: String!
}
"Defines custom fields for an item to store additional, user-defined information. Custom fields allow flexible extension of item data beyond standard properties and can be used for special business requirements, integrations, or custom workflows."
input UpdateItemCustomFieldsInput {
"List of custom field values assigned to the item. Each entry represents a custom field with its corresponding value."
fieldValues: [UpdateItemCustomFieldValueInput!]!
}
"Defines customer group-specific prices for an item. This structure enables differentiated pricing by customer groups, allowing different price levels for different customer segments."
input UpdateItemCustomerGroupPricesInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers)."
customerGroupId: ID!
"List of prices for this customer group - can contain different tier prices or volume discounts."
prices: [UpdateItemPriceInput!]!
}
"Defines a customer group-specific special price for an item. This structure represents a single promotional price for a specific customer group in a sales channel."
input UpdateItemCustomerGroupSpecialPriceInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers) for which this special price applies."
customerGroupId: ID!
"Net special price for this customer group without taxes. Setting this to null will deactivate the special price for this customer group."
netPrice: Decimal
"Indicates whether this special price is active for this customer group. Automatically set to false when NetPrice is set to null."
isActive: Boolean
}
"Defines customer-specific prices for an item. This structure enables individual price agreements for specific customers that can deviate from standard or customer group prices."
input UpdateItemCustomerPricesInput {
"Key of the customer that identifies the specific customer for whom these individual prices apply."
customerId: ID!
"List of individual prices for this customer - can contain different tier prices or special conditions."
prices: [UpdateItemPriceInput!]!
}
"Defines the collection of all descriptions of an item for creation. This structure manages default, platform, and sales channel-specific item descriptions for different languages and distribution channels."
input UpdateItemDescriptionsInput {
"Default descriptions of the item. This is used when no more specific platform or sales channel descriptions are available and serves as a fallback description."
defaultDescriptions: [UpdateDefaultDescriptionInput]
"List of sales channel-specific descriptions for sales platforms like JTL-Shop. Enables individual customization of item descriptions for specific sales channels."
salesChannelDescriptions: [UpdateSalesChannelDescriptionInput]
"List of platform-specific descriptions for non-sales platforms like print. Allows different descriptions for various output platforms."
platformDescriptions: [UpdatePlatformDescriptionInput]
}
"Defines a single feature assignment for an item. This structure represents the link between an item and a specific feature value from the feature system, allowing detailed product characterization."
input UpdateItemFeatureInput {
"Unique key of the feature value that identifies the specific feature characteristic to be assigned to the item. This key establishes the connection to a predefined feature value in the feature system."
featureId: ID!
}
"Defines the feature assignments of an item. This structure manages all features (characteristics\/attributes) that describe specific properties or attributes of an item, such as color, size, material, or other custom characteristics used for product differentiation and filtering."
input UpdateItemFeaturesInput {
"Contains all features assigned to the item. Each feature represents a specific characteristic or attribute that describes the item in more detail, enabling better product differentiation and advanced filtering capabilities."
features: [UpdateItemFeatureInput]
}
"Defines various identifiers of an item for creation. This structure includes all relevant markings and numbers used for unique identification of an item."
input UpdateItemIdentifiersInput {
"Unique item number (Stock Keeping Unit) - the user-assigned main identification of the item."
sku: String
"Amazon FNSKU (Fulfillment Network Stock Keeping Unit) - used by Amazon for inventory management."
amazonFnsku: String
"GTIN (Global Trade Item Number, formerly EAN) - internationally standardized product identification for global trade."
gtin: String
"Manufacturer's item number - the official product number assigned by the manufacturer."
manufacturerNumber: String
"ISBN (International Standard Book Number) - mainly used for books and other publications."
isbn: String
"Taric code - customs tariff number for international trade and customs processing."
tariccode: String
"UPC (Universal Product Code) - barcode standard mainly used in North America."
upc: String
"UN number - used for marking dangerous goods in transport."
unNumber: String
"Hazard number - identifies the type of danger for hazardous goods in transport."
hazardNumber: String
"Own identifier - user-defined internal identification for company-specific purposes."
ownIdentifier: String
"Default ASIN (Amazon Standard Identification Number) - primary Amazon product identification."
defaultAsin: String
"JTL-Fulfillment-SKU (JFSKU) - unique identifier in the JTL Fulfillment Network (FFN) for item identification."
jfsku: String
}
input UpdateItemImageInput {
"Unique ID to identify an image."
blobIdentifier: UUID!
"Sortnumber of the image."
sortNumber: Int!
"Declares the main image of the item. Typically it is the image with sortnumber 1."
isMainImage: Boolean!
}
input UpdateItemImagesInput {
"List of default images assigned to the item."
defaultImages: [UpdateItemImageInput]
"List of images assigned to different platforms."
platformImages: [UpdatePlatformImagesInput]
"List of images assigned to different saleschannels."
saleschannelImages: [UpdateSaleschannelImagesInput]
"List of images assigned to different eBay accounts."
ebayImages: [UpdateEbayImagesInput]
}
"Defines the physical dimensions and weight specifications of an item for creation. This structure includes all relevant measurements for storage, shipping and product presentation and is used for shipping cost calculations and storage space optimizations."
input UpdateItemMeasurementsInput {
"Height of the item in the configured unit of measurement (usually centimeters or millimeters)."
height: Decimal
"Length of the item in the configured unit of measurement (usually centimeters or millimeters)."
length: Decimal
"Shipping weight of the item for shipping cost calculation in the configured weight unit (usually kilograms or grams). May differ from the actual item weight."
shippingWeight: Decimal
"Actual weight of the item without packaging in the configured weight unit (usually kilograms or grams)."
weight: Decimal
"Width of the item in the configured unit of measurement (usually centimeters or millimeters)."
width: Decimal
}
"Defines a single price with tiering options and discount possibilities. This structure forms the basis for complex price structures with volume discounts and percentage price reductions from the standard price."
input UpdateItemPriceInput {
"Minimum quantity from which this price applies - enables tier prices based on order quantity (e.g., from 10 pieces)."
fromQuantity: Int!
"Net price for this price tier without taxes - the actual selling price for the specified quantity tier."
netPrice: Decimal
"Percentage discount on the standard price - indicates by what percentage the standard price is reduced for this price tier. Used as an alternative to NetPrice."
reduceStandardPriceByPercent: Decimal
}
"Defines the complete price structure of an item for creation. This structure includes all price information for different sales channels, customer groups and individual customer prices as well as basic price information."
input UpdateItemPricesInput {
"Indicates whether discounts should be ignored for this item. When set to true, no automatic discounts will be applied to the item prices."
ignoreDiscounts: Boolean
"Net sales price of the item without taxes and discounts - the basic selling price of the item."
salesPriceNet: Decimal
"Manufacturer's suggested retail price (MSRP) - the selling price recommended by the manufacturer."
suggestedRetailPrice: Decimal
"Net purchase price without taxes - the price at which the item was purchased."
purchasePriceNet: Decimal
"eBay-specific selling price - special price for eBay sales."
ebayPrice: Decimal
"Amazon-specific selling price - special price for Amazon sales."
amazonPrice: Decimal
"List of sales channel-specific prices - enables different pricing for various sales channels or shops."
salesChannelPrices: [UpdateItemSaleschannelPricesInput]
"List of customer-specific prices - allows individual price agreements for specific customers."
customerPrices: [UpdateItemCustomerPricesInput]
"List of default prices for different customer groups - these prices serve as fallback when no more specific prices are defined."
defaultPrices: [UpdateItemCustomerGroupPricesInput]
}
"Defines sales channel-specific special prices for an item. This structure enables different promotional pricing for a specific sales channel or shop with customer group-related special price structures."
input UpdateItemSalesChannelSpecialPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this special price structure applies."
salesChannelId: ID!
"List of special prices for different customer groups within this sales channel - enables differentiated promotional pricing by customer groups."
specialPrices: [UpdateItemCustomerGroupSpecialPriceInput!]!
}
"Updates the active sales channels for a set of items - Request"
input UpdateItemSalesChannelsCommandRequestInput {
"The items to update."
itemKeys: [ID]!
"The sales channels to activate for the item set."
activateSalesChannels: [ID]
"The sales channels to deactivate for the item set."
deactivateSalesChannels: [ID]
"Should sales channel update be applied to child items."
applyToChildItems: Boolean
}
"Defines sales channel-specific prices for an item. This structure enables different pricing for various sales channels or shops with customer group-related price structures."
input UpdateItemSaleschannelPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this price structure applies."
saleschannelId: ID!
"List of prices for different customer groups within this sales channel - enables differentiated pricing by customer groups."
customerGroupPrices: [UpdateItemCustomerGroupPricesInput!]!
"Indicates whether this sales channel is active for the item - determines whether the item can be sold in this sales channel."
isActive: Boolean
}
"Defines the special prices (promotional prices) structure of an item. This structure includes time-based and stock-based special pricing for different sales channels and customer groups, as well as Amazon-specific special prices."
input UpdateItemSpecialPricesInput {
"Indicates whether special prices are active for this item. When set to true, the special price rules defined below will be applied according to their conditions."
isActive: Boolean
"Date from which the special price becomes active. The special price will only be valid from this date onwards."
startDate: DateTime
"Date until which the special price remains active. The special price will expire after this date. Only evaluated if IsEndDateActive is true."
endDate: DateTime
"Indicates whether the end date should be considered. If false, the special price has no expiration date."
isEndDateActive: Boolean
"Minimum stock quantity that must be available for the special price to remain active. Only evaluated if IsStockRestrictionActive is true."
minimumStockQuantity: Int
"Indicates whether the stock restriction should be applied. When true, the special price is only active if the stock level is greater than or equal to MinimumStockQuantity. Can only be activated for items that use stock management."
isStockRestrictionActive: Boolean
"List of sales channel-specific special prices - enables different promotional pricing for various sales channels or shops with customer group differentiation."
salesChannelSpecialPrices: [UpdateItemSalesChannelSpecialPricesInput]
}
"Defines the storage and inventory management constraints of an item. This structure includes settings for negative stock handling, inventory management, serial numbers, batch tracking, and best-before date management."
input UpdateItemStorageConstraintsInput {
"Allows selling a higher quantity of the item than is actually in stock. This global setting must be activated first before platform-specific or sales channel-specific negative stock settings can be enabled."
allowNegativeStock: Boolean
"List of platform-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific platforms (e.g., eBay, Amazon). AllowNegativeStock must be activated as well for these settings to take effect."
itemPlatformNegativeStocks: [UpdateNegativeStockPlatformInput]
"List of sales channel-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific sales channels or shops. AllowNegativeStock must be activated as well for these settings to take effect."
itemSalesChannelNegativeStocks: [UpdateNegativeStockSalesChannelInput]
"Item buffer quantity - defines a safety stock buffer that is reserved and not available for sale. This helps prevent overselling and ensures availability for important orders."
buffer: Int
"Global minimum stock level across all warehouses. When the total stock falls below this value, the item is flagged for reordering. Used for automatic order suggestions and low-stock warnings."
globalMinimumStockLevel: Decimal
"Indicates whether the item uses batch management. When enabled, the item requires batch numbers to be assigned for each stock movement to enable tracking and traceability."
hasBatch: Boolean
"Determines if the item is working with inventory management. When active, stock levels are tracked and managed; when inactive, the item is treated as always available regardless of stock levels."
isInventoryManagementActive: Boolean
"Determines if the item is working with best-before date (MHD - Mindesthaltbarkeitsdatum) management. When enabled, stock items must have an assigned best-before date for tracking perishable goods."
isBestBeforeManaged: Boolean
"Determines if the item can be sold in split quantities (fractional units). When enabled, stock can be managed in decimal quantities (e.g., 2.5 pieces) instead of only whole numbers."
isStockDivisible: Boolean
"Determines the type of serial number processing. Defines whether serial numbers are inactive, active, or tracked for this item."
serialNumberType: SerialNumberType
}
input UpdateItemSupplierInput {
"Id of the supplier"
supplierId: ID!
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Stock level of the item at the supplier."
stockLevel: Decimal
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"VAT rate of the item at the supplier."
vatRate: Decimal
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal
"Scale prices defined by the supplier for this item."
scalePrices: [UpdateSupplierPriceInput]
}
input UpdateItemSuppliersInput {
"Sets the default supplier for the item."
defaultSupplier: ID
"Sets the default supplier for dropshipping for the item."
defaultDropshippingSupplier: ID
"Assigned suppliers for the item"
suppliers: [UpdateItemSupplierInput]
}
"Defines the item unit pricing settings for creation and modification. This structure includes all relevant information about the sales unit, packaging unit, inner quantity and base price details for an item."
input UpdateItemUnitPricingInput {
"Id of the sales unit in which the item is sold (e.g. piece or box)."
salesUnitId: ID
"Id of the packaging unit of the item."
packagingUnitId: ID
"The amount of content for one piece of the sales unit, relative to the inner quantity unit."
innerQuantity: Decimal
"The measurement unit for the inner quantity (e.g. kg or liter)."
innerQuantityUnitId: ID
"Indicates whether the base price should be automatically calculated and displayed."
isBasePriceDeclared: Boolean
"The measurement unit to which the base price refers (e.g. per liter or per 100 grams)."
basePriceReferenceUnitId: ID
"The reference amount used when calculating the base price (e.g. 1 for per liter, 100 for per 100 grams)."
basePriceReferenceAmount: Decimal
}
input UpdateItemVariationsInput {
"Contains all Variations"
variations: [UpdateVariationInput]
}
"Defines negative stock settings for a specific platform. This structure enables individual configuration of negative stock handling per platform (e.g., eBay, Amazon), allowing overselling for specific marketplaces when the global AllowNegativeStock is enabled."
input UpdateNegativeStockPlatformInput {
"Key of the platform that identifies the specific marketplace or platform (e.g., eBay, Amazon) for which this negative stock setting applies."
platformId: ID!
"Determines if negative stock is allowed for this platform. When true, orders can be accepted even when the item is out of stock on this specific marketplace."
isNegativeStockAllowed: Boolean!
}
"Defines negative stock settings for a specific sales channel. This structure enables individual configuration of negative stock handling per sales channel, allowing overselling for specific online shops when the global AllowNegativeStock is enabled."
input UpdateNegativeStockSalesChannelInput {
"Key of the sales channel that identifies the specific shop or sales channel for which this negative stock setting applies."
salesChannelId: ID!
"Determines if negative stock is allowed for this sales channel. When true, orders can be accepted even when the item is out of stock in this specific channel."
isNegativeStockAllowed: Boolean!
}
"Defines a platform-specific description of an item. This enables different descriptions for various output platforms like print or other non-sales platforms."
input UpdatePlatformDescriptionInput {
"Unique key of the platform for which this description is intended (e.g., print, labels)."
platformId: ID!
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the platform-specific description data with all relevant texts and SEO information."
descriptionData: UpdateDescriptionDataInput!
}
input UpdatePlatformImagesInput {
"Unique ID to identify a platform."
platformId: ID!
"List of images assigned to the platform."
images: [UpdateItemImageInput]
}
"Defines a product group"
input UpdateProductGroupInput {
"The id of the product group"
id: ID!
"The new name of the product group"
name: String!
}
"Update the properties of product groups. - Request"
input UpdateProductGroupsCommandRequestInput {
"Product groups to update."
productGroups: [UpdateProductGroupInput!]!
}
"Defines a sales channel-specific description of an item. This enables individual customization of item descriptions for specific sales channels or shops."
input UpdateSalesChannelDescriptionInput {
"Unique key of the sales channel or shop for which this description is intended."
salesChannelId: ID!
"ISO2 language code that determines the language for this sales channel-specific description."
languageIso: String!
"Contains the sales channel-specific description data with all relevant texts and SEO information."
descriptionData: UpdateDescriptionDataInput!
}
input UpdateSalesChannelSurchargeInput {
"Id of the saleschannel"
salesChannelId: ID!
"Contains the surcharges for that saleschannel and customergroup"
surcharges: [UpdateCustomerGroupSurchargeInput!]!
}
"Modifies an existing sales order. - Request"
input UpdateSalesOrderCommandRequestInput {
"Unique ID of the sales order to be modified."
salesOrderId: ID!
"Unique ID of the company."
companyId: ID
"The ID of the customer associated with the sales order."
customerId: ID
"SalesOrderBillingAddress"
billingAddress: UpdateUpdateSalesOrderAddressInput
"SalesOrderBillingAddress"
shipmentAddress: UpdateUpdateSalesOrderAddressInput
"The ID of the shipping method for the sales order."
shippingMethodId: ID
"The ID of the payment method for the sales order."
paymentMethodId: ID
"The line items included in the sales order."
lineItems: [UpdateUpdateSalesOrderLineItemInput]
}
input UpdateSaleschannelImagesInput {
"Unique ID to identify a saleschannel."
saleschannelId: ID!
"List of images assigned to the platform."
images: [UpdateItemImageInput]
}
"Updates mutable metadata of an existing shipping box. TypeId is immutable (Rule SB-3). - Request"
input UpdateShippingBoxMetadataCommandRequestInput {
"The shipping box to update."
shippingBoxId: ID!
"New display name (omit to keep existing)."
displayId: String!
"Replacement attribute list (omit to keep existing)."
attributes: [String!]!
}
input UpdateSupplierPriceInput {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal
}
"Updates an existing tax class - Request"
input UpdateTaxClassCommandRequestInput {
"The ID of the tax class to update"
id: ID!
"Whether this tax class is the standard tax class. Setting this to true will set all other tax classes to non-standard."
isStandard: Boolean
"The name of the tax class"
name: String
"The type of the tax class"
taxType: TaxType
}
"Updates an existing tax code - Request"
input UpdateTaxCodeCommandRequestInput {
"The ID of the tax code to update"
id: ID!
"The cash discount account of the tax code"
cashDiscountAccount: String
"The general ledger account of the tax code"
generalLedgerAccount: String
"Whether this tax code is automatic"
isAutomatic: Boolean
"The name of the tax code"
name: String
"The number of the tax code. Can only be changed when the tax code is not referenced."
number: Int
}
input UpdateUpdateCustomerAddressInput {
"Unique identifier for the address."
customerAddressId: ID
"Type of the address (shipment, billing, etc.)."
addressType: CustomerAddressType
"Name of the street (including number)."
street: String
"Additional address information."
additionalAddressLine: String
"City name of the customer."
city: String
"Postal code of the customer."
postalCode: String
"Name of the state."
state: String
"ISO code of the country (2 letter code, e.g. DE, AT, CH)."
countryIso: String
"The customers email address."
emailAddress: String
"The customers phone number."
phoneNumber: String
"The customers mobile phone number."
mobilePhoneNumber: String
"The customers fax number."
faxNumber: String
"The customers VAT ID."
vatId: String
"The customers salutation (e.g. Mr., Mrs., etc.)"
salutation: String
"The customers title (e.g. Dr., Prof., etc.)"
title: String
"The customers first name"
firstName: String
"The customers last name"
lastName: String
"The customers company name"
companyName: String
"The customers company extension"
additionalCompanyLine: String
"Indicates whether this is the default address."
isDefaultAddress: Boolean
}
input UpdateUpdateCustomerPaymentSettingsInput {
"The customers credit limit."
creditLimit: Int
"Payment target (in days)."
paymentDueDateInDays: Int
"The customers discount percentage."
discount: Decimal
"Whether the customer is blocked for dunning notices."
isDunningBlocked: Boolean
}
"address details for the sales order."
input UpdateUpdateSalesOrderAddressInput {
"The SalesOrderAddress Salutation"
salutation: String
"The SalesOrderAddress Title"
title: String
"The SalesOrderAddress FirstName"
firstName: String
"The SalesOrderAddress LastName"
lastName: String
"The SalesOrderAddress Company"
company: String
"The SalesOrderAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesOrderAddress Street"
street: String
"The SalesOrderAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesOrderAddress City"
city: String
"The SalesOrderAddress PostalCode"
postalCode: String
"The SalesOrderAddress State"
state: String
"The SalesOrderAddress CountryISO"
countryIso: String
"The SalesOrderAddress PostId"
postId: String
"The SalesOrderAddress EmailAddress"
emailAddress: String
"The SalesOrderAddress PhoneNumber"
phoneNumber: String
"The SalesOrderAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesOrderAddress Fax"
fax: String
"The SalesOrderAddress VAT ID"
vatId: String
}
"Line item details for the sales order line item to be modified."
input UpdateUpdateSalesOrderLineItemInput {
"Unique ID of the sales order line item to be modified."
salesOrderLineItemId: ID
"The SalesOrderLineItem TaxClassId"
taxClassId: ID
"The SalesOrderLineItem TaxCodeId"
taxCodeId: ID
"The discount of the line item."
discountPercent: Decimal
"Unique ID to identify an item."
itemId: ID
"Name of the position."
name: String
"The SalesOrderLineItem Note"
note: String
"The quantity of the line item."
quantity: Decimal
"The net sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales order line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesOrderLineItem LineItemType"
type: LineItemType
}
input UpdateVariationInput {
"Id of the Variation"
variationId: ID!
"Position of this Variation in the List"
position: Int
"Descriptions of this Variation in multiple Languages"
descriptions: [UpdateDescriptionInput]
"Values for this Variation"
values: [UpdateVariationValueInput]
"Type of the Variation"
variationType: VariationType
}
input UpdateVariationValueInput {
"Id of the VariationValue"
variationValueId: ID!
"Itemnumber for this variationvalue"
itemNumber: String
"GTIN for this variationvalue"
gtin: String
"Offset for the weight of this variationvalue"
weightOffset: Decimal
"Descriptions of this VariationValue in multiple Languages"
descriptions: [UpdateDescriptionInput]
"Surcharges of this VariationValue"
surcharges: UpdateVariationValueSurchargesInput
"Position of this VariationValue in the List"
position: Int
"Image for this variation value. This image will be used as the main image for the variation combination if this variation value is part of it and the variation combination doesn't have its own image."
image: ID
}
input UpdateVariationValueSurchargesInput {
"Default Surcharge if there is none specified for a specific saleschannel + customergroup"
defaultSurchargeNet: Decimal
"Default Surcharges for specific customergroups in general, independent of saleschannel"
customerGroupSurcharges: [UpdateCustomerGroupSurchargeInput]
"Surcharge for specific saleschannels + customergroups"
salesChannelSurcharges: [UpdateSalesChannelSurchargeInput]
}
"Updates mutable metadata (code, description, type) of an existing warehouse zone. - Request"
input UpdateWarehouseZoneMetadataCommandRequestInput {
"The zone to update."
zoneId: ID!
"New zone short code (omit to keep existing)."
code: String!
"New zone type (omit to keep existing)."
zoneType: Int!
"New zone description (omit to keep existing)."
description: String!
}
input VerkaufAuftragKeySortInput {
kAuftrag: SortEnumType @cost(weight: "10")
}
input VerkaufAuftragPositionKeySortInput {
kAuftragPosition: SortEnumType @cost(weight: "10")
}
input VersandartKeySortInput {
kVersandart: SortEnumType @cost(weight: "10")
}
input VersandklasseKeySortInput {
kVersandklasse: SortEnumType @cost(weight: "10")
}
input VorlagenSetKeySortInput {
kVorlagenset: SortEnumType @cost(weight: "10")
}
input WaehrungKeySortInput {
kWaehrung: SortEnumType @cost(weight: "10")
}
"Single Row of the warehouse query"
input WarehouseListItemFilterInput {
and: [WarehouseListItemFilterInput!]
or: [WarehouseListItemFilterInput!]
"Id of the warehouse."
id: ComparableWarenlagerKeyOperationFilterInput
"Default warehouse name"
name: StringOperationFilterInput
"Describes if the warehouse is active"
active: ComparableBooleanOperationFilterInput
}
"Single Row of the warehouse query"
input WarehouseListItemSortInput {
"Id of the warehouse."
id: WarenlagerKeySortInput @cost(weight: "10")
"Default warehouse name"
name: SortEnumType @cost(weight: "10")
"Describes if the warehouse is active"
active: SortEnumType @cost(weight: "10")
}
"Single row of the warehouse zones overview list."
input WarehouseZoneListItemFilterInput {
and: [WarehouseZoneListItemFilterInput!]
or: [WarehouseZoneListItemFilterInput!]
"Unique zone identifier."
zoneId: ComparableWarenLagerBereichKeyOperationFilterInput
"Zone short code."
code: StringOperationFilterInput
"Warehouse that owns this zone."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Zone type enum value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: ComparableInt32OperationFilterInput
}
"Single row of the warehouse zones overview list."
input WarehouseZoneListItemSortInput {
"Unique zone identifier."
zoneId: WarenLagerBereichKeySortInput @cost(weight: "10")
"Zone short code."
code: SortEnumType @cost(weight: "10")
"Zone type enum value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: SortEnumType @cost(weight: "10")
}
input WarenLagerBereichKeySortInput {
kLagerBereich: SortEnumType @cost(weight: "10")
}
input WarenLagerEingangKeySortInput {
kWarenLagerEingang: SortEnumType @cost(weight: "10")
}
input WarenLagerPlatzKeySortInput {
kWarenLagerPlatz: SortEnumType @cost(weight: "10")
}
input WarengruppeKeySortInput {
kWarengruppe: SortEnumType @cost(weight: "10")
}
input WarenlagerKeySortInput {
kWarenlager: SortEnumType @cost(weight: "10")
}
"Represents a workbench resource."
input WorkbenchResourceFilterInput {
and: [WorkbenchResourceFilterInput!]
or: [WorkbenchResourceFilterInput!]
"This workbench resource's unique ID."
id: ComparableWorkbenchResourceKeyOperationFilterInput
"This workbench resource's unique number."
number: StringOperationFilterInput
"This workbench resource's name."
name: StringOperationFilterInput
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ComparableResourceTypeKeyOperationFilterInput
"The name of the host assigned to this workbench resource."
hostName: StringOperationFilterInput
"The ID of the warehouse assigned to this workbench resource."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
input WorkbenchResourceKeySortInput {
kWorkbenchResource: SortEnumType @cost(weight: "10")
}
"Represents a workbench resource."
input WorkbenchResourceSortInput {
"This workbench resource's unique ID."
id: WorkbenchResourceKeySortInput @cost(weight: "10")
"This workbench resource's unique number."
number: SortEnumType @cost(weight: "10")
"This workbench resource's name."
name: SortEnumType @cost(weight: "10")
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ResourceTypeKeySortInput @cost(weight: "10")
"The name of the host assigned to this workbench resource."
hostName: SortEnumType @cost(weight: "10")
"The ID of the warehouse assigned to this workbench resource."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
"Represents a workbench resource type"
input WorkbenchResourceTypeFilterInput {
and: [WorkbenchResourceTypeFilterInput!]
or: [WorkbenchResourceTypeFilterInput!]
"This workbench resource type's unqiue ID."
id: ComparableResourceTypeKeyOperationFilterInput
"The workbench resource type's name."
name: StringOperationFilterInput
}
"Represents a workbench resource type"
input WorkbenchResourceTypeSortInput {
"This workbench resource type's unqiue ID."
id: ResourceTypeKeySortInput @cost(weight: "10")
"The workbench resource type's name."
name: SortEnumType @cost(weight: "10")
}
input ZahlungsartKeySortInput {
kZahlungsart: SortEnumType @cost(weight: "10")
}
"Represents a bin location assigned to a warehouse zone."
input ZoneBinLocationItemFilterInput {
and: [ZoneBinLocationItemFilterInput!]
or: [ZoneBinLocationItemFilterInput!]
"Zone identifier."
zoneId: ComparableWarenLagerBereichKeyOperationFilterInput
"Bin location identifier."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
}
"Represents a bin location assigned to a warehouse zone."
input ZoneBinLocationItemSortInput {
"Zone identifier."
zoneId: WarenLagerBereichKeySortInput @cost(weight: "10")
"Bin location identifier."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
}
"Reference data describing an available warehouse zone type."
input ZoneTypeFilterInput {
and: [ZoneTypeFilterInput!]
or: [ZoneTypeFilterInput!]
"Zone type numeric value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
value: ComparableInt32OperationFilterInput
"Display name for the zone type."
name: StringOperationFilterInput
}
"Reference data describing an available warehouse zone type."
input ZoneTypeSortInput {
"Zone type numeric value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
value: SortEnumType @cost(weight: "10")
"Display name for the zone type."
name: SortEnumType @cost(weight: "10")
}
input ZustandKeySortInput {
kZustand: SortEnumType @cost(weight: "10")
}
"Sales order address type enumeration."
enum AddressType {
"Shipment address"
SHIPMENT_ADDRESS
"Billing address"
BILLING_ADDRESS
"Other address"
OTHER
}
"Defines when a policy shall be executed."
enum ApplyPolicy {
"Before the resolver was executed."
BEFORE_RESOLVER
"After the resolver was executed."
AFTER_RESOLVER
"The policy is applied in the validation step before the execution."
VALIDATION
}
"The state of a bill of materials."
enum BillOfMaterialsState {
"The bill of materials is a draft. It can still be modified. It cannot be produced yet."
DRAFT
"The bill of materials is the one used by default for production. It can no longer be modified. It can be produced."
DEFAULT
"The bill of materials has been archived. It can no longer be modified. It can no longer be produced."
ARCHIVED
"The bill of materials is an alternative to the default bill of materials. It can no longer be modified. It can be produced."
ALTERNATIVE
"The bill of materials is used to customize a production order. It can no longer be modified. It can only be produced in connection with the production order for which it was created."
PRODUCTION_ORDER_CUSTOMIZATION
"The bill of materials is marked as deleted. Bills of materials marked as deleted can generally no longer be retrieved."
DELETED
}
"Type of bill of materials item."
enum BillOfMaterialsType {
"None"
NONE
"BillOfMaterials"
BILL_OF_MATERIALS
"Component"
COMPONENT
}
"Defines requirements for the production input of a bill of materials component regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum ComponentPostingsInventoryAccountingDataRequirements {
"Any requirements for the production input of a bill of materials component are specified by the containing bill of materials."
INHERITED
"For the production input of a bill of materials component, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of a bill of materials component, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Type of configuration item."
enum ConfigurationItemType {
"None"
NONE
"ConfigurationItem"
CONFIGURATION_ITEM
"Component"
COMPONENT
}
"Defines requirements for the production input of a bill of materials component regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum CreateComponentPostingsInventoryAccountingDataRequirements {
"Any requirements for the production input of a bill of materials component are specified by the containing bill of materials."
INHERITED
"For the production input of a bill of materials component, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of a bill of materials component, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Defines requirements for the production input of all components of a bill of materials regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum CreateOverallComponentPostingsInventoryAccountingDataRequirements {
"For the production input of all components of a bill of materials, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of all components of a bill of materials, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Indicates how a product’s shelf life end date is calculated after completing a lot."
enum CreateShelfLifeEndDateGenerationMode {
"The product’s shelf life end date is based on the earliest shelf life end date of the components used."
EARLIEST
"The product’s shelf life end date is based on the latest shelf life end date of the components used."
LATEST
"The product’s shelf life end date is based on the production date plus a separately configurable time span."
PRODUCTION_DATE
}
enum CustomFieldReferenceType {
"Item\/Product (Artikel)"
ITEM
"Category (Kategorie)"
CATEGORY
"Customer (Kunde)"
CUSTOMER
"Sales Order (Auftrag)"
SALES_ORDER
"Company (Firma)"
COMPANY
"Production Order"
PRODUCTION_ORDER
"Operations"
OPERATIONS
}
enum CustomFieldType {
"No specific type (Kein)"
NONE
"Integer number (Ganzzahl)"
INTEGER
"Floating point number (FliesskommaZahl)"
FLOATING_POINT_NUMBER
"Free text"
FREE_TEXT
"Boolean checkbox"
CHECKBOX
"Selection list"
LIST
"Website URL"
URL
"Email address"
E_MAIL
"Phone number (TelNr)"
PHONE_NUMBER
"Country ISO code (LandIso)"
COUNTRY_ISO
"Price\/Currency (Preis)"
PRICE
"Date (Datum)"
DATE
"Short text (KurzText)"
SHORT_TEXT
}
"The type of customer address."
enum CustomerAddressType {
"Address to which the goods are sent."
SHIPMENT_ADDRESS
"Address used for invoicing and payment documents."
BILLING_ADDRESS
"Address without direct relation to delivery or billing."
OTHER
}
"""
Search fields available for customer quick search.
Values correspond to nId in tKunde_suche.
"""
enum CustomerSearchField {
"Customer name (first name + last name permutations)."
NAME
"Company name."
COMPANY_NAME
"Additional company line."
ADDITIONAL_COMPANY_LINE
"Email address."
EMAIL_ADDRESS
"eBay user name."
EBAY_NAME
"Phone number."
PHONE_NUMBER
"VAT identification number."
VAT_ID
"Street address."
STREET
"City."
CITY
"Postal code."
POSTAL_CODE
"Customer number."
CUSTOMER_NUMBER
"Mobile phone number."
MOBILE_PHONE_NUMBER
}
"The type of search operator used for customer quick search."
enum CustomerSearchOperator {
"Matches values that start with the search term."
STARTS_WITH
"Matches values that contain the search term."
CONTAINS
}
"Status of delivery completion for a sales order"
enum DeliveryCompleteStatus {
"The order is not completely delivered."
DELIVERY_NOT_COMPLETE
"The order is delivered with a delivery note."
DELIVERY_COMPLETE
"The order has been delivered without a delivery note."
DELIVERY_COMPLETE_WITHOUT_DELIVERY_NOTE
}
"Status of a delivery"
enum DeliveryStatus {
"Cancelled"
CANCELLED
"Open"
OPEN
"PartiallyOnDeliveryNote"
PARTIALLY_ON_DELIVERY_NOTE
"CompletelyOnDeliveryNote"
COMPLETELY_ON_DELIVERY_NOTE
"PartiallyShipped"
PARTIALLY_SHIPPED
"CompletelyShipped"
COMPLETELY_SHIPPED
"Credited"
CREDITED
"CompletedWithoutShipment"
COMPLETED_WITHOUT_SHIPMENT
}
enum ExpiredComponentsUsage {
"The use of components with expired best-before date is not permitted."
NOT_PERMITTED
"The use of components with expired best-before date is permitted."
PERMITTED
}
"Type of external sales invoice"
enum ExternalSalesInvoiceType {
"None"
NONE
"NoInvoiceNoOutput"
NO_INVOICE_NO_OUTPUT
"NoInvoice"
NO_INVOICE
}
"Payment status of the invoice"
enum InvoicePaymentStatus {
"The invoice is unpaid."
UNPAID
"The invoice is partially paid."
PARTIALLY_PAID
"The invoice is completely paid."
COMPLETELY_PAID
"The payment status cannot be determined."
NOT_DETERMINABLE
}
"Status of a sales invoice"
enum InvoiceStatus {
"Not invoiced"
NOT_INVOICED
"Partially invoiced"
PARTIALLY_INVOICED
"Completely invoiced"
COMPLETELY_INVOICED
}
"Type of item description"
enum ItemDescriptionType {
"None"
NONE
"Brief"
BRIEF
"Long"
LONG
}
"An enum of all supported item search fields."
enum ItemSearchField {
"The item SKU."
ITEM_NUMBER
"The item GTIN (former EAN)."
GTIN
"The item number of the manufacturer (HAN)."
MANUFACTURER_NUMBER
"The item UPC."
UPC
"The item ISBN."
ISBN
"The item name."
NAME
"The item's container GTIN."
CONTAINER_GTIN
"The item ASIN."
ASIN
"The item's supplier item id."
SUPPLIER_ITEM_NUMBER
"The item's container UPC."
CONTAINER_UPC
"The item FNSKU."
FNSKU
"The item JFSKU."
JFSKU
"The item subset number."
SUBSET_NUMBER
"The shop search terms."
META_KEYWORDS
}
"Specifies whether item properties should be replaced or attached when copying."
enum ItemSettingCopyAction {
"Replaces all existing information with the copied data."
REPLACE
"Attaches\/appends the copied information to existing data without replacing it."
ATTACH
}
"Type of line item."
enum LineItemType {
"Custom line item"
CUSTOM
"Item"
ITEM
"Shipping"
SHIPPING
"Coupon"
COUPON
"Voucher"
VOUCHER
"Payment"
PAYMENT
"ShippingSurcharge"
SHIPPING_SURCHARGE
"NewCustomerCoupon"
NEW_CUSTOMER_COUPON
"CashOnDelivery"
CASH_ON_DELIVERY
"ShippingSurchargeItem"
SHIPPING_SURCHARGE_ITEM
"Packing"
PACKING
"GiftForFree"
GIFT_FOR_FREE
"TrustedShops"
TRUSTED_SHOPS
"InterestPremium"
INTEREST_PREMIUM
"ProcessingFee"
PROCESSING_FEE
"Carton"
CARTON
"ReturnDelivery"
RETURN_DELIVERY
"MultiPurposeVoucher"
MULTI_PURPOSE_VOUCHER
"MultiPurposeVoucherDigital"
MULTI_PURPOSE_VOUCHER_DIGITAL
"SinglePurposeVoucher"
SINGLE_PURPOSE_VOUCHER
"SinglePurposeVoucherDigital"
SINGLE_PURPOSE_VOUCHER_DIGITAL
"SinglePurposeVoucherRedemption"
SINGLE_PURPOSE_VOUCHER_REDEMPTION
}
"Defines the type of lot size configuration for a production item."
enum LotType {
"Fixed lot sizes are defined for the production item."
OWN
"No lot sizes are defined for the production item. The quantity to be produced must always be specified when creating a production order or at the start of an ad-hoc production."
NONE
}
"Defines the origin of an external document."
enum MarketplaceExternalDocumentOrigin {
"The document originates from Wawi."
WAWI
"The document originates from an external source."
EXTERNAL
}
"Defines the type of an external document."
enum MarketplaceExternalDocumentType {
"The document is an invoice."
INVOICE
"The document is a credit note (invoice correction)."
CREDIT_NOTE
}
"Defines the severity level of a marketplace notification."
enum MarketplaceNotificationSeverity {
"Informational notification."
INFO
"Warning notification."
WARNING
"Error notification."
ERROR
}
"Defines the type of a marketplace notification."
enum MarketplaceNotificationType {
"Offer-related notification."
OFFERS
"Order-related notification."
ORDERS
"Return-related notification."
RETURNS
"Credit note-related notification."
CREDIT_NOTES
"Outdated categories in offers notification."
OUTDATED_CATEGORIES_IN_OFFERS
"Invoice-related notification."
INVOICES
"Metadata changed notification."
META_DATA_CHANGED
}
"Type of an SCX offer."
enum MarketplaceOfferType {
"Offer that is assigned to an article."
WAWI_OFFER
"External offer without article assignment."
EXTERNAL_OFFER
}
"Combined lifecycle and action status of an SCX offer."
enum MarketplaceOfferViewStatus {
"No pending action."
NOTHING_TO_DO
"Offer is ready and waiting for upload."
WAITING_FOR_UPLOAD
"Offer has been uploaded to SCX, waiting for channel response."
UPLOADED
"Offer is being reviewed by the channel."
IN_REVIEW
"Offer is actively listed on the channel."
LISTED
"Offer has been ended or terminated."
ENDED
"Offer has an error reported by the channel."
ERROR
"Offer needs to be created."
PENDING_CREATION
"Offer needs to be updated."
PENDING_UPDATE
"Offer is scheduled for deletion."
PENDING_DELETION
"Transfer is blocked for this seller."
TRANSFER_BLOCKED
}
"Defines the upload status of an order cancellation request."
enum MarketplaceOrderCancellationRequestUploadStatus {
"The cancellation request upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The cancellation request upload has failed."
ERROR
}
"Defines the upload status of order cancellation information sent from Wawi to the marketplace."
enum MarketplaceOrderCancellationUploadStatus {
"The order cancellation information is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The upload of order cancellation information has failed."
ERROR
}
"Defines the status of a payment upload request."
enum MarketplacePaymentUploadStatus {
"The payment upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The payment upload is in an invalid state."
ERROR
}
"Defines the status of a return upload request."
enum MarketplaceReturnUploadStatus {
"The return upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The return upload is in an invalid state."
ERROR
}
"Defines the status of a shipping information upload request."
enum MarketplaceShippingInformationUploadStatus {
"The shipping information upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The shipping information upload is in an invalid state."
ERROR
}
"Defines requirements for the production input of all components of a bill of materials regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum OverallComponentPostingsInventoryAccountingDataRequirements {
"For the production input of all components of a bill of materials, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of all components of a bill of materials, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Defines the type of manufacturing of a production item."
enum ProductionType {
"The production item is always manufactured in the same way according to its production bill of materials."
REGULAR
"The production item and\/or its production bill of materials have customizable properties (e.g., process parameters or configuration groups)."
CUSTOMIZED
}
"Access level for modifying the sales order"
enum ReadOnlyType {
"ChangesAllowed"
CHANGES_ALLOWED
"InvoicedExternally"
INVOICED_EXTERNALLY
"ChangesForbidden"
CHANGES_FORBIDDEN
}
enum RecalculateTaxMode {
"No recalculation, even if tax-relevant fields have been changed."
NO_RECALCULATION
"Keep net prices (change in VAT rate is borne by the customer)"
KEEP_NET_PRICES
"Maintain gross prices (changes in VAT rate are borne by the retailer)"
KEEP_GROSS_PRICES
}
enum ReplenishmentCreationAvailableStockReservationMode {
"Available stock is not reserved for the production session when a replenishment order is created."
NONE
"Available stock is reserved for the production session based on a user prompt when a replenishment order is created."
USER_PROMPT
"Available stock is automatically reserved for the production session when a replenishment order is created."
AUTO
}
enum ReservationMode {
"The reservation is carried out for each operation of a production."
OPERATION
"The reservation is carried out per run (lot) of a production (for all operations at once)."
ITERATION
"The reservation is carried out directly for the entire production session (i.e., all operations of all runs\/lots)."
SESSION
}
"Tax setting for the sales invoice"
enum SalesInvoiceTaxSetting {
"Delivery with VAT"
DELIVERY_WITH_VAT
"Intra-community delivery"
INTRA_COMMUNITY_DELIVERY
"Exempt from VAT – reverse charge"
EXEMPT_FROM_VAT_REVERSE_CHARGE
"Exempt from VAT"
EXEMPT_FROM_VAT
}
"EnumValuekeys beziehen sich auf FunctionOperatorType"
enum SearchOperator {
STARTS_WITH
CONTAINS
WILDCARD
}
"Type of bill of materials item."
enum SerialNumberTrackingMode {
"No serial number tracking."
NONE
"Serial number tracking for outgoing goods."
OUTGOING
"Serial number tracking for outgoing and incoming goods."
OUTGOING_INCOMING
"Serial number tracking for all movements of goods."
ALL
}
"Enumeration that defines the type of serial number management for an item. Determines whether and how serial numbers are processed for stock movements and sales."
enum SerialNumberType {
"Serial numbers are inactive. The item does not require or use serial numbers for tracking."
NO_SERIAL_NUMBERS
"Serial numbers are active. The item requires a serial number to be assigned during stock movements."
SERIAL_NUMBERS_ACTIVE
"Serial numbers are being tracked. The item requires serial numbers and maintains a full tracking history of all movements."
SERIAL_NUMBERS_TRACKING
}
"Indicates how a product’s shelf life end date is calculated after completing a lot."
enum ShelfLifeEndDateGenerationMode {
"The product’s shelf life end date is based on the earliest shelf life end date of the components used."
EARLIEST
"The product’s shelf life end date is based on the latest shelf life end date of the components used."
LATEST
"The product’s shelf life end date is based on the production date plus a separately configurable time span."
PRODUCTION_DATE
}
enum SortEnumType {
ASC
DESC
}
"Special tax treatment options for sales invoices"
enum SpecialTaxTreatment {
"None"
NONE
"ReverseCharge"
REVERSE_CHARGE
"ExemptFromVat"
EXEMPT_FROM_VAT
"SubjectToVat"
SUBJECT_TO_VAT
}
"Special tax treatment options for tax calculation."
enum TaxDomainSpecialTaxTreatment {
"None"
NONE
"ReverseCharge"
REVERSE_CHARGE
"ExemptFromVat"
EXEMPT_FROM_VAT
"SubjectToVat"
SUBJECT_TO_VAT
}
"This setting controls which data is used during tax calculation."
enum TaxDomainTaxReference {
"Shipment address is used for tax calculation."
SHIPMENT_ADDRESS
"Billing address is used for tax calculation."
BILLING_ADDRESS
}
"The tax reference controls which data is used during tax calculation."
enum TaxReference {
"Shipment address is used for tax calculation."
SHIPMENT_ADDRESS
"Billing address is used for tax calculation."
BILLING_ADDRESS
}
"Tax setting for the sales order"
enum TaxSetting {
"Delivery with VAT"
DELIVERY_WITH_VAT
"Intra-community delivery"
INTRA_COMMUNITY_DELIVERY
"Exempt from VAT – reverse charge"
EXEMPT_FROM_VAT_REVERSE_CHARGE
"Exempt from VAT"
EXEMPT_FROM_VAT
}
"Represents the type of a tax class"
enum TaxType {
"No tax type"
NONE
"Super reduced tax rate"
SUPER_REDUCED
"Reduced low tax rate"
REDUCED_LOW
"Reduced tax rate"
REDUCED
"Standard tax rate"
STANDARD
"Intermediate tax rate"
INTERMEDIATE
}
enum VariationType {
"Undefined VariationType. This should never be used."
UNKNOWN
"A simple dropdown. One value can be selected. In variation combinations, incompatible options are greyed out. Variation children are not allowed to use this type."
SELECTBOX
"Same functionality as Dropdown, but presented as classic radio buttons. Variation children are not allowed to use this type."
RADIOBUTTON
"Same functionality as Dropdown or Radio button. Displays as buttons with descriptions or images (similar to Amazon). Variation children are not allowed to use this type."
SWATCHES
"Same functionality as Dropdown, Radio button, or Swatches. Display is text-only (like on Amazon). Variation children are not allowed to use this type."
TEXTBOX
"Cannot have predefined values. Optional free text input by the user. Variation children are allowed to use this type."
FREE_TEXT
"Cannot have predefined values. Required free text input by the user. Variation children are allowed to use this type."
MANDATORY_FREE_TEXT
}
"The authorize directive."
directive @authorize("The name of the authorization policy that determines access to the annotated resource." policy: String "Roles that are allowed to access the annotated resource." roles: [String!] "Defines when when the authorize directive shall be applied.By default the authorize directives are applied during the validation phase." apply: ApplyPolicy! = BEFORE_RESOLVER) repeatable on OBJECT | FIELD_DEFINITION
"The purpose of the `cost` directive is to define a `weight` for GraphQL types, fields, and arguments. Static analysis can use these weights when calculating the overall cost of a query or response."
directive @cost("The `weight` argument defines what value to add to the overall cost for every appearance, or possible appearance, of a type, field, argument, etc." weight: String!) on SCALAR | OBJECT | FIELD_DEFINITION | ARGUMENT_DEFINITION | ENUM | INPUT_FIELD_DEFINITION
"The purpose of the `@listSize` directive is to either inform the static analysis about the size of returned lists (if that information is statically available), or to point the analysis to where to find that information."
directive @listSize("The `assumedSize` argument can be used to statically define the maximum length of a list returned by a field." assumedSize: Int "The `slicingArguments` argument can be used to define which of the field's arguments with numeric type are slicing arguments, so that their value determines the size of the list returned by that field. It may specify a list of multiple slicing arguments." slicingArguments: [String!] "The `slicingArgumentDefaultValue` argument can be used to define a default value for a slicing argument, which is used if the argument is not present in a query." slicingArgumentDefaultValue: Int "The `sizedFields` argument can be used to define that the value of the `assumedSize` argument or of a slicing argument does not affect the size of a list returned by a field itself, but that of a list returned by one of its sub-fields." sizedFields: [String!] "The `requireOneSlicingArgument` argument can be used to inform the static analysis that it should expect that exactly one of the defined slicing arguments is present in a query. If that is not the case (i.e., if none or multiple slicing arguments are present), the static analysis may throw an error." requireOneSlicingArgument: Int! = 1) on FIELD_DEFINITION
"The `@specifiedBy` directive is used within the type system definition language to provide a URL for specifying the behavior of custom scalar definitions."
directive @specifiedBy("The specifiedBy URL points to a human-readable specification. This field will only read a result for scalar types." url: String!) on SCALAR
"The `Byte` scalar type represents non-fractional whole numeric values. Byte can represent values between 0 and 255."
scalar Byte
"The `DateTime` scalar represents an ISO-8601 compliant date time type."
scalar DateTime @specifiedBy(url: "https:\/\/www.graphql-scalars.com\/date-time")
"The `Decimal` scalar type represents a decimal floating-point number."
scalar Decimal
"The `TimeSpan` scalar represents an ISO-8601 compliant duration type."
scalar TimeSpan
scalar UUID @specifiedBy(url: "https:\/\/tools.ietf.org\/html\/rfc4122")
```
# GraphQL Schema Reference (v2.1)
Source: https://developer.jtl-software.com/api-reference/v2.1/graphql-schema
Complete GraphQL SDL schema for the JTL ERP API v2.1. Indexed for AI tools (MCP, llms.txt) to enable accurate query and mutation assistance.
# GraphQL Schema — JTL ERP API v2.1
This is the complete GraphQL schema (SDL) for the **JTL ERP API v2.1 (Cloud)**. It is
auto-generated from the official introspection output and kept in sync with
each API version.
**Use this schema to understand the available queries, mutations, input types, and
object types when building GraphQL requests against the JTL Platform API.**
* **Endpoint:** `https://api.jtl-cloud.com/erp/v2/graphql`
* **Authentication:** OAuth 2.0 Bearer token (see [Authentication guide](/guides/essentials/authentication/oauth2-flow))
* **Required header:** `x-tenant-id` — the tenant ID for the target ERP instance
* **Interactive playground:** [GraphQL Playground](/api-reference/graphql-playground)
## Schema (SDL)
```graphql theme={null}
schema {
query: Query
mutation: Mutation
}
"Reference data describing available employee tracking activity types."
type ActivityType {
"Activity type numeric value (kBuchungsart)."
value: Int!
"Display name of the activity type."
name: String!
}
"Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals. - Response"
type AddItemSupplierCommandResponse {
"Unique ID of the modified item."
itemId: ID!
}
"Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options. - Response"
type AddItemVariationCommandResponse {
"Unique ID of the newly added variation."
variationId: ID!
}
"Adds a new value to an existing item variation. - Response"
type AddItemVariationValueCommandResponse {
"Unique ID of the newly added variation value."
variationValueId: ID!
}
type AttributeSalesChannelValues {
"Identifies the saleschannel for this attributevalue"
salesChannelId: ID!
"Contains the values for a saleschannel"
values: [AttributeValue!]!
}
type AttributeValue {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Value of this attribute as string. Please consider the Attribute Type for correct formatting."
value: String!
}
type AttributeValues {
"Identifies the attribute"
attributeId: ID!
"Defines the default values for the attribute and item in different languages."
defaultValues: [AttributeValue!]!
"Contains all values for saleschannels for this attribute and item"
salesChannelValues: [AttributeSalesChannelValues!]!
}
"A list of batches for specific items and their quantities"
type BatchListItem {
"Id of the Item"
itemId: ID!
"The batch number"
batch: String!
"The quantity of the item in the batch"
quantity: Decimal!
"Id of the Warehouse"
warehouseId: ID!
}
"A list of best before dates (MHDs) for specific items and their quantities"
type BestBeforeListItem {
"Id of the Item"
itemId: ID!
"The best before date (MHD)"
bestBeforeDate: DateTime!
"The quantity of the item with this best before date"
quantity: Decimal!
"Id of the Warehouse"
warehouseId: ID!
}
"A bill of materials for a production item. It defines which operations must be performed and which components are required to produce the production item."
type BillOfMaterials {
"The ID of this bill of materials."
id: ID!
"The ID of the production item of this bill of materials."
productionItemId: ID!
"The version of this bill of materials."
version: Int!
"The name of this production bill of materials."
name: String!
"The description of this production bill of materials."
description: String!
"The status of this production bill of materials."
state: BillOfMaterialsState!
"The timestamp when this bill of materials was created."
createDate: DateTime!
"The timestamp when this bill of materials was last modified, or NULL if this bill of materials has not been modified yet."
updateDate: DateTime
"The ID of the user who last modified this bill of materials, or NULL if this bill of materials has not been modified yet."
updateUserId: ID
"The timestamp when this bill of materials was activated, or NULL if this bill of materials has not been activated yet."
activationDate: DateTime
"The last calculated producible stock."
producibleStock: Decimal!
"The timestamp when the producible stock was last calculated, or NULL if it has not been calculated yet."
producibleStockCalculationDate: DateTime
"Specifies requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsShelfLifeEndDateRequirements: OverallComponentPostingsInventoryAccountingDataRequirements!
"Specifies requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsBatchNumberRequirements: OverallComponentPostingsInventoryAccountingDataRequirements!
"Indicates how the shelf life end date of a product is calculated after completing a lot."
shelfLifeEndDateGenerationMode: ShelfLifeEndDateGenerationMode!
"A time span that is added when calculating the shelf life end date of a product after completing a lot."
additionalShelfLifeEndDateTime: TimeSpan
}
"Represents properties of a bill of materials child component."
type BillOfMaterialsChildComponentProperties {
"The ID of this bill of materials component's parent."
parentId: ID!
}
"Represents properties of a bill of materials component regardless of its type."
type BillOfMaterialsComponentProperties {
"The ID of this bill of materials component."
id: ID!
"The ID of the bill of materials this bill of materials component belongs to."
billOfMaterialsId: ID!
"The sort order of this bill of materials component within the bill of materials."
sort: Int!
}
"A bill of materials item."
type BillOfMaterialsItem {
"This bill of material item's properties common for all bill of materials components."
billOfMaterialsComponentProperties: BillOfMaterialsComponentProperties!
"This bill of material item's properties common for all bill of materials child components."
billOfMaterialsChildComponentProperties: BillOfMaterialsChildComponentProperties!
"This bill of material item's properties."
billOfMaterialsItemProperties: BillOfMaterialsItemProperties!
}
"Represents properties of a bill of materials item."
type BillOfMaterialsItemProperties {
"The ID of the item underlying this bill of materials item."
itemId: ID!
"The required quantity of this item for the production of the production item."
quantity: Decimal!
"The ID of the measurement unit in which the quantity is managed, or NULL if the quantity is managed in the sales unit of the underlying item."
measurementUnitId: ID
"The ID of the operation step to which the item is assigned, or NULL if the item is not assigned to any operation step."
operationStepId: ID
"Specifies requirements for the production input of this bill of materials component regarding the shelf life end dates of the stock accounts to be debited."
componentPostingsShelfLifeEndDateRequirements: ComponentPostingsInventoryAccountingDataRequirements!
"Specifies requirements for the production input of this bill of materials component regarding the batch numbers of the stock accounts to be debited."
componentPostingsBatchNumberRequirements: ComponentPostingsInventoryAccountingDataRequirements!
}
"A bill of materials operation."
type BillOfMaterialsOperation {
"This bill of material operation's properties common for all bill of materials components."
billOfMaterialsComponentProperties: BillOfMaterialsComponentProperties!
"This bill of material operation's properties."
billOfMaterialsOperationProperties: BillOfMaterialsOperationProperties!
}
"Represents properties of a bill of materials operation."
type BillOfMaterialsOperationProperties {
"The ID of the operation underlying this bill of materials operation."
operationId: ID!
}
"Single row of the bin locations overview list."
type BinLocationListItem {
"Unique bin location identifier."
binLocationId: ID!
"Warehouse that owns this bin location."
warehouseId: ID!
"Bin location name (unique within the warehouse)."
name: String!
"Current status of the bin location (0=Active, 1=Deactivated, 2=Locked)."
status: Int!
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: Int!
"Optional sort order."
sort: Int
}
"Occupancy data (fill factors) for a single bin location in a warehouse."
type BinLocationOccupancyItem {
"Unique bin location identifier."
binLocationId: ID!
"Date of the last WMS inventory count for this bin location. Null if never inventoried."
lastInventoryDate: DateTime
"Volume fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
volumeFillFactor: Decimal!
"Weight fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
weightFillFactor: Decimal!
}
"Single row of the bin location pick heatmap query."
type BinLocationPickHeatmapItem {
"Id of the bin location."
binLocationId: ID!
"Warehouse that owns this bin location."
warehouseId: ID!
"Number of completed pick operations in the selected time period."
pickCount: Int!
"Total quantity picked in the selected time period."
pickQuantity: Decimal!
}
"DTO for bin location status reference data."
type BinLocationStatusDto {
"Status identifier."
value: Int!
"Status name."
name: String!
}
"DTO for bin location type reference data."
type BinLocationTypeDto {
"Type identifier."
value: Int!
"Type name."
name: String!
}
"Recalculate prices, discounts, and taxes for a sales entity from a client-supplied state without persisting it. - Response"
type CalculateSalesEntityCommandResponse {
"The list of calculated sales entity line items."
lineItems: [CalculateSalesEntityLineItemResponse!]!
"The total net amount for the sales entity."
totalNetAmount: Decimal!
"The total gross amount for the sales entity."
totalGrossAmount: Decimal!
"The total net amount for the sales entity excluding shipping costs."
totalNetAmountExcludingShipping: Decimal!
"The total gross amount for the sales entity excluding shipping costs."
totalGrossAmountExcludingShipping: Decimal!
"The VAT ID of the company for the departure country."
vatId: String!
"The ISO code of the currency used for the calculated prices."
currencyIso: String!
"The currency factor used for the price conversion."
currencyFactor: Decimal!
"The net shipping cost."
shippingCostNet: Decimal!
"The gross shipping cost."
shippingCostGross: Decimal!
"The VAT amounts grouped by tax rate."
vatAmounts: [SalesOrderVatAmountPerRate!]!
"The tax setting applied to the sales entity."
taxSetting: TaxSetting!
}
"Response model for a calculated sales entity line item."
type CalculateSalesEntityLineItemResponse {
"The synchronization identifier for the line item. Negative values indicate system-generated BOM child positions."
syncNumber: Int!
"Type of the sales entity line item."
lineItemType: LineItemType!
"The article\/item ID for the line item. Not set for shipping positions and free-text positions."
itemId: ID
"The quantity for the line item."
quantity: Decimal!
"The calculated net sales price per unit."
salesPriceNet: Decimal!
"The calculated gross sales price per unit."
salesPriceGross: Decimal!
"The total net amount for this line item after applying quantity and discount."
totalSalesPriceNet: Decimal!
"The total gross amount for this line item after applying quantity and discount."
totalSalesPriceGross: Decimal!
"The discount percentage applied to the line item."
discountPercent: Decimal!
"The tax rate applied to the line item."
taxRate: Decimal!
"The tax class applied to the line item."
taxClassId: ID!
"The tax code applied to the line item."
taxCodeId: ID!
"The SyncNumber of the parent line item. Set for BOM components (negative SyncNumbers) and configuration components."
parentSyncNumber: Int
"Indicates which price components were changed as a result of a quantity change."
recalculateLineItemPriceChangeResult: RecalculateLineItemPriceResult!
}
"Calculate prices, discounts, and taxes for a sales order without persisting it. - Response"
type CalculateSalesOrderCommandResponse {
"The list of calculated sales order line items."
lineItems: [CalculateSalesOrderLineItemResponse!]!
"The total net amount for the sales order."
totalNetAmount: Decimal!
"The total gross amount for the sales order."
totalGrossAmount: Decimal!
"The total net amount for the sales order including shipping costs."
totalNetAmountInclShipping: Decimal!
"The total gross amount for the sales order including shipping costs."
totalGrossAmountInclShipping: Decimal!
"The VAT ID of the company for the departure country."
companyVatId: String!
"The ISO code of the currency used for the calculated prices."
currencyIso: String!
"The currency factor used for the price conversion."
currencyFactor: Decimal!
"The net shipping cost."
shippingCostNet: Decimal!
"The VAT amounts grouped by tax rate."
vatAmounts: [CalculateSalesOrderVatAmount!]!
"The gross shipping cost."
shippingCostGross: Decimal!
}
"Response model for a calculated sales order line item."
type CalculateSalesOrderLineItemResponse {
"The synchronization identifier for the line item."
syncNumber: Int!
"Type of the sales order line item."
type: LineItemType!
"The article\/item ID for the line item. Not set for shipping positions and free-text positions."
itemId: ID
"The quantity for the line item."
quantity: Decimal!
"The calculated net sales price for the line item."
salesPriceNet: Decimal!
"The calculated gross sales price for the line item."
salesPriceGross: Decimal!
"The total net amount for this line item after applying quantity and discount."
lineItemTotalNetAmount: Decimal!
"The total gross amount for this line item after applying quantity and discount."
lineItemTotalGrossAmount: Decimal!
"The discount percentage applied to the line item."
discountPercent: Decimal!
"The tax rate applied to the line item."
taxRate: Decimal!
"The tax class applied to the line item."
taxClassId: ID!
"The SyncNumber of the parent line item. Set for BOM components (negative SyncNumbers) and configuration components."
parentSyncNumber: Int
}
"VAT amount for a specific tax rate."
type CalculateSalesOrderVatAmount {
"The tax rate in percent (e.g. 19.0 for 19% VAT)."
taxRate: Decimal!
"The VAT amount for this tax rate."
vatAmount: Decimal!
}
type CategoryCapabilities {
"Indicates if the category descriptions for this sales channel can be created or changed via REST-API."
descriptions: Boolean!
"Indicates if the category for this sales channel can be activated. Categories can only be activated for online shops or JTL-POS."
onlineShopActivation: Boolean!
}
"Category details"
type CategoryDetails {
"Id of the category."
id: ID!
"Id of the parent category."
parentId: ID
"Sortnumber of the category."
sortNumber: Int!
"Category descriptions"
descriptions: [CategoryDetailsDescription!]!
}
"Category description details"
type CategoryDetailsDescription {
"Associated category"
categoryId: ID!
"Category description saleschannel key"
salesChannelId: ID!
"Category description language key"
languageId: ID!
"Category name"
name: String
"Category description"
description: String
"Category metadescription"
metaDescription: String
"Category metakeywords"
metaKeywords: String
"Category meta title tag"
titleTag: String
"Category meta url path"
urlPath: String
}
"Single Row of the category overview"
type CategoryListItem {
"Id of the category."
id: ID!
"Id of the parent category."
parentId: ID
"Sortnumber of the category."
sortNumber: Int
"Default Category Name"
name: String
}
"A command to modify an existing company, including identification, contact, banking, and tax information. - Response"
type ChangeCompanyCommandResponse {
"Unique ID of the modified company."
id: ID!
"Name of the company."
companyName: String!
"Owner of the company."
owner: String!
"Street address of the company."
street: String!
"Postal code of the company."
postalCode: String!
"City of the company."
city: String!
"Country of the company."
country: String!
"Country ISO code."
countryIsoCode: String!
"Phone number of the company."
phone: String!
"Fax number of the company."
fax: String!
"Email address of the company."
emailAddress: String!
"Website of the company."
website: String!
"Bank code."
bankCode: String!
"Bank account number."
accountNumber: String!
"Name of the bank."
bankName: String!
"Tax identification number."
taxId: String!
"International Bank Account Number."
iban: String!
"Bank Identifier Code."
bic: String!
"Bank account holder name."
accountHolder: String!
"Creditor identification number."
creditorId: String!
"PayPal email address of the company."
payPalEmailAddress: String!
"Indicates if the company is a small business owner."
isSmallBusinessOwner: Boolean!
"DHL Intraship customer Id for shipping."
dhlIntrashipCustomerId: String!
"UPS customer Id for shipping."
upsCustomerId: String!
"List of company VAT identifiers."
companyVatIdentifiers: [UpdateCompanyVatIdDetailsItem!]!
}
"Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information. - Response"
type ChangeItemCommandResponse {
"The changed item."
item: ItemdetailsItem!
}
"Represents a company address"
type CompanyAddress {
"Company ID"
id: ID!
"Company name"
name: String!
"Entrepreneur"
entrepreneur: String!
"Street"
street: String!
"Zip code"
zipCode: String!
"City"
city: String!
"Country"
country: String!
"Phone"
phone: String!
"Mail"
mail: String!
"ISO code"
iso: String!
}
"Single row of the company table"
type CompanyDetailsItem {
"Unique ID to identify a company (kFirma)."
id: ID!
"Name of the company."
companyName: String
"Owner of the company."
owner: String
"Street address of the company."
street: String
"Postal code of the company."
postalCode: String
"City of the company."
city: String
"Country of the company."
country: String
"Country ISO code."
countryIsoCode: String
"Phone number of the company."
phone: String
"Fax number of the company."
fax: String
"Email address of the company."
emailAddress: String
"Website of the company."
website: String
"Bank code."
bankCode: String
"Bank account number."
accountNumber: String
"Name of the bank."
bankName: String
"Tax identification number."
taxId: String
"International Bank Account Number."
iban: String
"Bank Identifier Code."
bic: String
"Bank account holder name."
accountHolder: String
"Creditor identification number."
creditorId: String
"PayPal email address of the company."
payPalEmailAddress: String
"Indicates if the company is a small business owner."
isSmallBusinessOwner: Boolean!
"DHL Intraship customer Id for shipping."
dhlIntrashipCustomerId: String
"UPS customer Id for shipping."
upsCustomerId: String
"List of company vat ids."
companyVatIdentifiers: [CompanyVatIdDetailsItem!]!
}
"Single row of the company table"
type CompanyListItem {
"Unique ID to identify a company (kFirma)."
id: ID!
"Name of the company."
companyName: String
"Owner of the company."
owner: String
"Street address of the company."
street: String
"Postal code of the company."
postalCode: String
"City of the company."
city: String
"Country of the company."
country: String
"Country ISO code."
countryIsoCode: String
"Phone number of the company."
phone: String
"Fax number of the company."
fax: String
"Email address of the company."
emailAddress: String
"Website of the company."
website: String
"Bank code."
bankCode: String
"Bank account number."
accountNumber: String
"Name of the bank."
bankName: String
"Tax identification number."
taxId: String
"International Bank Account Number."
iban: String
"Bank Identifier Code."
bic: String
"Bank account holder name."
accountHolder: String
"Creditor identification number."
creditorId: String
"PayPal email address of the company."
payPalEmailAddress: String
"Indicates if the company is a small business owner."
isSmallBusinessOwner: Boolean!
"DHL Intraship customer Id for shipping."
dhlIntrashipCustomerId: String
"UPS customer Id for shipping."
upsCustomerId: String
"List of company vat ids."
companyVatIdentifiers: [CompanyVatIdItem!]!
}
"Single row of the company VAT id table"
type CompanyVatIdDetailsItem {
"Unique VAT ID."
id: ID!
"The company id."
companyId: ID!
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"Single row of the company VAT id table"
type CompanyVatIdItem {
"Unique VAT ID."
id: ID!
"The company id."
companyId: ID!
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"- Response"
type CopyItemdetailsCommandResponse {
"Unique IDs of the items that received copied values."
itemId: [ID]!
}
"Definition of a country item"
type CountryItem {
"The ISO code of the country"
countryIso: String!
"The three Character ISO code of the country"
countryIso3: String!
"The name of the country"
name: String!
"The continent of the country"
continent: String!
"The ISO code of the currency used in the country"
currencyIso: String!
"The numeric ISO code of the country"
numericIso: Int!
"Indicates if the country is part of the European Union"
isEu: Boolean!
"The default culture associated with the country"
defaultCulture: String!
"The display name for states Name in the country"
displayNameState: String!
"List of known states in the country"
knownStates: [CountryStateItem!]!
}
"Definition of a country state item"
type CountryStateItem {
"The short region code of the state"
regionCode: String!
"The Full ISO code of the state in ISO 3166-2"
isoCode: String!
"The name of the state"
name: String!
}
"Creates a new bill of materials for a production item, including its components. - Response"
type CreateBillOfMaterialsCommandResponse {
"The ID of the newly created bill of materials."
id: ID!
}
"Creates a new bill of materials item for a bill of materials operation. - Response"
type CreateBillOfMaterialsItemCommandResponse {
"The ID of the newly created bill of materials item."
id: ID!
}
"Creates a new bill of materials operation for a bill of materials, including its items. - Response"
type CreateBillOfMaterialsOperationCommandResponse {
"The ID of the newly created bill of materials operation."
id: ID!
}
"Creates a new bin location in a warehouse. - Response"
type CreateBinLocationCommandResponse {
"The ID of the newly created bin location."
binLocationId: ID!
}
"Creates a new Category. - Response"
type CreateCategoryCommandResponse {
"Unique ID of the newly created category."
categoryId: ID!
}
"A command to create a new company, including identification, contact, banking, and tax information. - Response"
type CreateCompanyCommandResponse {
"Unique ID of the newly created company - this key is used for all further operations with the company."
companyId: ID!
}
"Creates a customer - Response"
type CreateCustomerCommandResponse {
"Unique ID of the newly created customer."
customerId: ID!
}
"Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements. - Response"
type CreateItemCommandResponse {
"Unique ID of the newly created item - this key is used for all further operations with the item."
itemId: ID!
}
"Creates a new lot size for a production item. - Response"
type CreateLotSizeCommandResponse {
"The ID of the newly created lot size."
id: ID!
}
"Creates a new production item, including its bills of materials with their components. - Response"
type CreateProductionItemCommandResponse {
"The ID of the newly created production item."
id: ID!
}
"Creates a new production order. - Response"
type CreateProductionOrderCommandResponse {
"The ID of the newly created production order."
id: ID!
}
"Create a new sales invoice for a salesorder - Response"
type CreateSalesInvoiceCommandResponse {
"The Id of the created sales invoice"
salesInvoiceId: ID!
}
"Create a new sales invoice correction from an existing invoice - Response"
type CreateSalesInvoiceCorrectionCommandResponse {
"The Id of the created sales invoice correction"
salesInvoiceCorrectionId: ID!
}
"Creates a new sales order. - Response"
type CreateSalesOrderCommandResponse {
"Unique ID of the newly created sales order."
salesOrderId: ID!
}
"Create a new sales order for a sales quotation - Response"
type CreateSalesOrderFromSalesQuotationCommandResponse {
"The ID of the created sales order"
salesOrderId: ID!
}
"Creates a new sales quotation. - Response"
type CreateSalesQuotationCommandResponse {
"Unique ID of the newly created sales quotation."
salesQuotationId: ID!
}
"Creates a new shipping box within a warehouse. - Response"
type CreateShippingBoxCommandResponse {
"The ID of the newly created shipping box."
shippingBoxId: ID!
}
"Creates a new shipping class - Response"
type CreateShippingClassCommandResponse {
"Id of the new ShippingClass"
id: ID!
}
"Creates a new warehouse zone. - Response"
type CreateWarehouseZoneCommandResponse {
"The ID of the newly created warehouse zone."
zoneId: ID!
}
"Creates a new workbench resource - Response"
type CreateWorkbenchResourceCommandResponse {
"The new workbench resource's ID."
id: ID!
}
"Creates a new workbench resource type - Response"
type CreateWorkbenchResourceTypeCommandResponse {
"The new workbench resource type's ID"
id: ID!
}
"Represents a single cross-selling item."
type CrossSellItem {
"Id of the item"
id: ID!
"Sku of the item"
sku: String
}
"Single row of the currencies overview table"
type Currency {
"Currency id"
id: ID!
"Currency factor"
factor: Decimal!
"Is default currency"
isDefault: Boolean!
"ISO code of the currency"
iso: String!
"Name of the currency"
name: String
"Date and time of the last update"
updated: DateTime
}
"Metadata definition of custom fields (Eigene Felder)"
type CustomFieldListItem {
"Unique identifier of the custom field."
customFieldKey: ID!
"Name of the custom field in the specified language."
name: String!
"Group name where the custom field belongs to."
group: String
"Data type of the custom field. Possible values: Kein = No specific type, Ganzzahl = Integer number, FliesskommaZahl = Floating point number, Text = Free text, Checkbox = Boolean checkbox, Liste = Selection list, Url = Website URL, EMail = Email address, TelNr = Phone number, LandIso = Country ISO code, Preis = Price\/Currency, Datum = Date, KurzText = Short text"
customFieldType: CustomFieldType!
"The underlying .NET data type of the CustomFieldType: 'int' for Ganzzahl and Checkbox, 'string' for Text, KurzText, Url, EMail, TelNr, LandIso, Liste, and Kein, 'decimal' for FliesskommaZahl and Preis, 'DateTime' for Datum"
dataType: String!
"Indicates whether the field is mandatory."
isRequired: Boolean!
"Entity type the custom field belongs to (e.g., Artikel, Kategorie, Kunde)."
referenceType: CustomFieldReferenceType!
"Sort order within the group."
sort: Int!
"Indicates whether the field value is readonly."
isReadonly: Boolean!
"Indicates whether the field is hidden in UI."
isInvisible: Boolean!
"Description of the custom field."
description: String
}
"A single customer by its id"
type Customer {
"Customer id"
customerId: ID!
"Id of the customer group"
customerGroupId: ID!
"Customer number"
customerNumber: String!
"Date when the customer was created"
createdDate: DateTime!
"List of addresses of the customer"
customerAddresses: [CustomerAddress!]!
"The customer group of the customer"
customerGroup: CustomerGroup!
"The language iso code of the customer"
languageIso: String!
}
type CustomerAddress {
"Unique ID of the address."
customerAddressId: ID!
"Unique ID of the customer."
customerId: ID!
"Indicates whether this is the default address of the customer."
isDefault: Boolean!
"Type of the address (shipment, billing, etc.)."
addressType: CustomerAddressType!
"Company name of the customer"
companyName: String!
"Additional company information line."
additionalCompanyLine: String!
"Salutation of the customer (e.g. Mr., Mrs., etc.)"
salutation: String!
"Title of the customer (e.g. Dr., Prof., etc.)"
title: String!
"First name of the customer"
firstName: String!
"Last name of the customer"
lastName: String!
"Name of the street (including number)."
street: String!
"Additional address information."
additionalAddressLine: String!
"Postal code of the customer."
postalCode: String!
"City name of the customer."
city: String!
"ISO code of the country"
countryIso: String!
"Name of the state."
state: String!
"The customers email address."
emailAddress: String!
"The customers fax number."
faxNumber: String!
"The customers phone number."
phoneNumber: String!
"The customers mobile phone number."
mobilePhoneNumber: String!
"The customers VAT identification number."
vatId: String!
}
type CustomerCategory {
"Unique internal ID of the customer category."
id: ID!
"The name of the customer category."
name: String!
}
type CustomerGroup {
"Unique internal ID of the customer group."
id: ID!
"The name of the customer group."
name: String!
"Indicates if the customer group is the default group. Only one group can be selected as the default group."
isDefault: Boolean!
"The discounted percentage for the customer group."
discount: Decimal!
"Indicates if the customer group sees the net price in the online shop."
isNetPrice: Boolean!
}
type CustomerGroupSurcharge {
"Id of the customergroup"
customerGroupId: ID!
"Surcharge for that customergroup"
surcharge: Decimal!
"Defines if the surcharges will be synchronized to online saleschannels. Does not apply for the default customer group surcharges, which are always synchronized when not overriden."
isActive: Boolean!
}
"Single row of the customers overview table"
type CustomerListItem {
"Customer id"
id: ID!
"Customer number"
customerNumber: String
"Customer's eBay user name."
ebayName: String
"Customer's date of birth."
birthday: String
"Customer's homepage URL."
homepage: String
"Last name of the customer"
lastName: String
"First name of the customer"
firstName: String
"Phone number."
phoneNumber: String
"Fax number."
faxNumber: String
"Email address."
emailAddress: String
"Company name (if applicable)."
companyName: String
"Postal code."
postalCode: String
"City."
city: String
"Country name."
countryName: String
"ISO-Code of the country."
countryIso: String
"Company extension."
additionalCompanyLine: String
"Formal salutation (e.g., Mr., Ms.)."
salutation: String
"Academic or professional title."
title: String
"Street and house number."
street: String
"Additional address information."
additionalAddressLine: String
"Date the customer record was created."
createdDate: DateTime
"Mobile phone number."
mobilePhoneNumber: String
"Customer-specific discount rate."
discountRate: Decimal
"VAT identification number."
vatId: String
"Subscription status for the newsletter."
hasNewsletter: Boolean!
"Customer's PostID (specific delivery identifier)."
postId: String
"Number of days for payment terms."
paymentDueDateInDays: Int
"Federal state or province."
state: String
"Source or origin of the customer."
initialContact: String
"Flag indicating if the customer is a cash register\/POS customer."
isCashRegisterBased: Boolean!
"Account lock status."
isLocked: Boolean!
"Commercial register number."
commercialRegisterNumber: String
"Accounts receivable number for accounting."
accountsReceivableNumber: Int
"Name of the customer category."
customerCategoryName: String
"Name of the customer group."
customerGroupName: String
"Key\/ID of the customer category."
customerCategoryId: ID
"Key\/ID of the customer group."
customerGroupId: ID
"Flag indicating participation in JTL Fulfillment."
isJtlFulfillment: Boolean!
"Comma-separated list of all assigned customer labels."
labels: String
"The language iso code of the customer"
languageIso: String
}
"Defines a default description of an item in a specific language. This description is used as a fallback when no more specific platform or sales channel descriptions are available."
type DefaultDescription {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the actual description data such as name, short and long description as well as SEO-relevant information."
descriptionData: DescriptionData!
}
"Removes an existing variation from an item. All associated variation values and combinations will also be removed. - Response"
type DeleteItemVariationCommandResponse {
"Unique ID of the deleted variation."
variationId: ID!
}
"Removes a specific value from an item variation. - Response"
type DeleteItemVariationValueCommandResponse {
"Unique ID of the deleted variation value."
variationValueId: ID!
}
"A delivery note item"
type DeliveryNoteItem {
"Unique ID to identify a delivery note."
id: ID!
"Created at timestamp"
createdAt: DateTime!
"Delivery note number"
number: String!
}
type Description {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Name of the Variation in the specific language"
name: String!
}
"Defines the actual description data of an item. This structure contains all textual information of an item including SEO-relevant metadata for online shops."
type DescriptionData {
"The name of the item as displayed in the user interface or shop."
itemName: String
"Short description of the item for overview displays and search results."
shortDescription: String
"Detailed description of the item with comprehensive product information and properties."
description: String
"Meta description for search engine optimization (SEO) that is displayed in search results."
metaDescription: String
"Meta keywords for search engine optimization to improve discoverability of the item."
metaKeywords: String
"HTML title tag for the item that is displayed in the browser tab and search results."
titleTag: String
"URL path for the item to create SEO-friendly and speaking URLs."
urlPath: String
}
"A single sales channel with the available endpoints."
type DiscoverableSalesChannel {
"Unique ID to identify a sales channel."
id: ID!
"Type of the sales channel."
type: SalesChannelType!
"Name of the sales channel, e.g. eBay.de, amazon.uk, myshop.de."
name: String!
"Indicates which parts of items can be manipulated for a specific sales channel via REST-API."
itemCapabilities: ItemCapabilities!
"Indicates which parts of categories can be manipulated for a specific sales channel via REST-API."
categoryCapabilities: CategoryCapabilities!
"URL for the documentation of the available endpoints for this specific sales channel."
documentationUrl: String
"Machine-readable, type-specific URL of the detail endpoint for this specific sales channel."
detailUrl: String
}
"Creates one or more duplicates of an existing item with specified duplication options. - Response"
type DuplicateItemsCommandResponse {
"The list of unique identifiers (ArtikelKeys) for all successfully created duplicate items."
createdItems: [ID]!
}
type EbayImages {
"Unique ID to identify an ebay account."
ebayAccountId: ID!
"List of images assigned to the eBay account."
images: [ItemImage!]!
}
"Last tracked bin location activity per employee."
type EmployeeLocationItem {
"Employee user ID (kBenutzer)."
userIdentifier: Int!
"Employee display name."
userName: String!
"Timestamp of the last tracked activity."
lastActivityTimestamp: DateTime!
"Bin location where the last activity occurred."
binLocationId: ID!
"Activity type of the last activity."
activityTypeId: ID!
"Display name of the activity type."
activityTypeName: String!
"Article involved in the activity, if available."
articleId: ID
"Article display name or number, if available."
articleName: String
}
"An empty sales order with default values."
type EmptySalesOrder {
"The default sales order date (current date\/time)."
salesOrderDate: DateTime
"The default item description type from global settings."
itemDescriptionType: ItemDescriptionType!
"The default read-only type."
readOnlyType: ReadOnlyType!
"The company ID the sales order is initialized for."
companyId: ID!
"The default language ID."
languageId: ID!
"The default additional weight from global settings."
additionalWeight: Decimal!
"The VAT ID of the company."
vatId: String
"The special tax treatment setting."
specialTaxTreatment: SpecialTaxTreatment!
"The tax setting."
taxSetting: TaxSetting!
"The departure country information."
departureCountry: EmptySalesOrderDepartureCountry!
"The payment details."
paymentDetails: EmptySalesOrderPaymentDetails!
"The initialized empty billing address."
billingAddress: EmptySalesOrderAddress!
"The initialized empty shipment address."
shipmentAddress: EmptySalesOrderAddress!
}
"An empty initialized address for the sales order."
type EmptySalesOrderAddress {
"The address salutation."
salutation: String
"The address title."
title: String
"The first name."
firstName: String
"The last name."
lastName: String
"The company name."
company: String
"Additional company line."
additionalCompanyLine: String
"The street address."
street: String
"Additional address line."
additionalAddressLine: String
"The postal code."
postalCode: String
"The city."
city: String
"The state or region."
state: String
"The country ISO code."
countryIso: String
"The country name."
countryName: String
"The email address."
emailAddress: String
"The phone number."
phoneNumber: String
"The mobile phone number."
mobilePhoneNumber: String
"The fax number."
fax: String
}
"Departure country information for the empty sales order."
type EmptySalesOrderDepartureCountry {
"The ISO code of the departure country (default is company headquarters)."
countryIso: String!
"The currency ISO code of the departure country."
currencyIso: String!
"The currency factor."
currencyFactor: Decimal!
}
"Payment details for the empty sales order."
type EmptySalesOrderPaymentDetails {
"The default currency ISO code."
currencyIso: String!
"The default currency factor."
currencyFactor: Decimal!
"The default payment due date in days."
paymentDueDateInDays: Int!
"The default cash discount percentage."
cashDiscount: Decimal!
"The default cash discount days."
cashDiscountDays: Int!
}
"External document M&A"
type ExternalDocumentInternal {
"Primary key of document"
externalDocumentTransactionId: ID!
"Primary key of company"
companyId: ID
"Primary key of customer"
customerId: ID
"Primary key of platform"
platformId: ID
"Primary key of payment type document"
paymentMethodId: ID
"Primary key of invoice"
externalInvoiceDocumentId: ID
"Invoice number"
salesInvoiceNumber: String
"Credit note number"
externalDocumentNumber: String
"Document date"
externalDocumentDate: DateTime!
"External order number"
externalDocumentOrderNumber: String
"Currency factor"
currencyFactor: Decimal!
"Currency code"
currency: String
"Shipping currency code"
departureCountryCurrencyIso: String
"Shipping currency factor"
departureCountryCurrenyFactor: Decimal
"Service date"
serviceDate: DateTime!
"Payment date"
payDate: DateTime!
"Platform ID"
platformIdentifier: String
"Debtor number"
accountsReceivableNumber: Int
"Tax setting"
taxSetting: Byte!
"Document type"
externalDocumentType: Byte!
"Country VAT ID"
companyVatIdNumber: String
"Seller VAT ID"
customerVatIdNumber: String
"Shipping country ISO code"
departureCountryIso: String
"Payment information"
paymentMethodName: String
"Order date"
orderDate: DateTime!
"Shipping company name"
shipmentAddressCompany: String
"Shipping last name"
shipmentAddressLastName: String
"Shipping street address"
shipmentAddressStreet: String
"Shipping ZIP code"
shipmentAddressPostalCode: String
"Shipping city"
shipmentAddressCity: String
"Shipping phone number"
shipmentAddressPhoneNumber: String
"Shipping additional address information"
shipmentAddressAdditionalAddressLine: String
"Shipping country ISO code"
shipmentAddressCountryIso: String
"Shipping VAT ID"
shipmentAddressVatIdNumber: String
"Customer company name"
customerDefaultBillingAddressCompany: String
"Customer salutation"
customerDefaultBillingAddressSalutation: String
"Customer title"
customerDefaultBillingAddressTitle: String
"Customer first name"
customerDefaultBillingAddressFirstName: String
"Customer last name"
customerDefaultBillingAddressLastName: String
"Customer street address"
customerDefaultBillingAddressStreet: String
"Customer ZIP code"
customerDefaultBillingAddressPostalCode: String
"Customer city"
customerDefaultBillingAddressCity: String
"Customer country"
customerDefaultBillingAddressCountry: String
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: String
"Customer fax number"
customerDefaultBillingAddressFaxNumber: String
"Customer additional information"
customerDefaultBillingAddressForTheAttentionOf: String
"Customer country ISO code"
customerDefaultBillingAddressCountryIso: String
"Customer email address"
customerDefaultBillingAddressEmailAddress: String
"Customer VAT ID"
customerDefaultBillingAddressVatIdNumber: String
"Customer number from sales order"
salesOrderCustomerNumber: String
"Customer group"
customerGroupName: String
"Payment due date in days"
paymentDueDateInDays: Int!
"Customer number"
customerNumber: String
"Invoice company name"
billingAddressCompany: String
"Invoice last name"
billingAddressLastName: String
"Invoice street address"
billingAddressStreet: String
"Invoice ZIP code"
billingAddressPostalCode: String
"Invoice city"
billingAddressCity: String
"Invoice phone number"
billingAddressPhoneNumber: String
"Invoice additional address information"
billingAddressAdditionalAddressLine: String
"Invoice country ISO code"
billingAddressCountryIso: String
"Invoice VAT ID"
billingAddressVatIdNumber: String
"Document total gross value"
externalDocumentTotalGrossValue: Decimal!
"Document total net value"
externalDocumentTotalNetValue: Decimal!
"Shipping date"
shipmentDate: DateTime
"Order payment type"
orderPaymentMethodName: String
"Shipping country count"
shipmentCountryCount: Int!
}
"External document position for M&A system"
type ExternalDocumentLineItemInternal {
"External document line item ID"
externalDocumentLineItemId: ID!
"External document ID"
externalDocumentId: ID!
"Sales price gross"
externalDocumentSalesPriceGross: Decimal!
"External document sales price net"
externalDocumentSalesPriceNet: Decimal!
"External document purchase price net"
externalDocumentPurchasePriceNet: Decimal
"Quantity"
quantity: Decimal!
"Item name"
itemName: String
"SKU"
sku: String
"Tax rate"
taxRate: Decimal!
"Tax class ID"
taxClassId: ID
"Taric code"
taric: String
"Item weight"
itemWeight: Decimal
"Item volume"
itemVolume: Decimal
"Product group ID"
productGroupId: ID
"Purchase price net"
purchasePriceNet: Decimal
"Product group"
productGroup: String
"Warehouse ID"
warehouseId: ID
"External document invoice line item ID"
externalDocumentInvoiceLineItemId: ID!
}
"A connection to a list of items."
type GetItemSuppliersByIdConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [GetItemSuppliersByIdEdge!]
"A flattened list of the nodes."
nodes: [ItemSupplierListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type GetItemSuppliersByIdEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ItemSupplierListItem!
}
type ItemAttributes {
"Contains all attribute values assigned to the item"
values: [AttributeValues!]!
}
type ItemCapabilities {
"Indicates if the category descriptions for this sales channel can be created or changed via REST-API."
descriptions: Boolean!
"Indicates if the category for this sales channel can be activated. Categories can only be activated for online shops or JTL-POS."
onlineShopActivation: Boolean!
"Indicates if the prices for this sales channel can be manipulated."
prices: Boolean!
"Indicates if the special prices for this sales channel can be manipulated."
specialPrices: Boolean!
"Indicates if the images for this sales channel can be manipulated."
images: Boolean!
}
"Defines the category assignments of an item for creation. This structure manages all categories to which an item can be assigned and enables hierarchical classification for better organization and navigation."
type ItemCategories {
"Contains all categories to which the item is assigned. An item can be assigned to multiple categories simultaneously to enable flexible categorization and better discoverability."
categories: [ItemCategory!]!
}
"Defines a single category assignment for an item. This structure represents the link between an item and a specific category in the hierarchical category system of the ERP system."
type ItemCategory {
"Unique key of the category that identifies the specific category to which the item should be assigned. This key establishes the connection to the category data."
categoryId: ID!
}
"Represents a single cross-selling group with its assigned items."
type ItemCrosssellingGroup {
"Unique identifier of the cross-selling group."
crosssellingGroupId: ID!
"List of item keys that belong to this cross-selling group."
items: [CrossSellItem!]!
}
"Manages cross-selling groups assigned to an item. Cross-selling groups define related products that should be promoted together."
type ItemCrosssellingGroups {
"Collection of cross-selling groups associated with the item."
groups: [ItemCrosssellingGroup!]!
}
"Defines a single custom field value for an item. This structure connects a custom field definition with its actual value for a specific item."
type ItemCustomFieldValue {
"Unique identifier of the custom field definition. References the custom field that was previously created in the system."
fieldId: ID!
"The actual value stored in this custom field. The format and content depend on the custom field type definition (text, number, date, etc.)."
value: String!
"The culture name (e.g., \"en-US\", \"de-DE\") associated with the custom field value. This is important for localized fields where the value may vary based on the user's language or region. When returning those values from the server side this Format is always InvariantCulture. When sending values to the server side the culture name is optional and if not provided, it will be treated as InvariantCulture. Otherwise this value initializes a CultureInfo Object."
valueCultureName: String!
}
"Defines custom fields for an item to store additional, user-defined information. Custom fields allow flexible extension of item data beyond standard properties and can be used for special business requirements, integrations, or custom workflows."
type ItemCustomFields {
"List of custom field values assigned to the item. Each entry represents a custom field with its corresponding value."
fieldValues: [ItemCustomFieldValue!]!
}
"Defines customer group-specific prices for an item. This structure enables differentiated pricing by customer groups, allowing different price levels for different customer segments."
type ItemCustomerGroupPrices {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers)."
customerGroupId: ID!
"List of prices for this customer group - can contain different tier prices or volume discounts."
prices: [ItemPrice!]!
}
"Defines a customer group-specific special price for an item. This structure represents a single promotional price for a specific customer group in a sales channel."
type ItemCustomerGroupSpecialPrice {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers) for which this special price applies."
customerGroupId: ID!
"Net special price for this customer group without taxes. Setting this to null will deactivate the special price for this customer group."
netPrice: Decimal
"Indicates whether this special price is active for this customer group. Automatically set to false when NetPrice is set to null."
isActive: Boolean!
}
"Defines customer-specific prices for an item. This structure enables individual price agreements for specific customers that can deviate from standard or customer group prices."
type ItemCustomerPrices {
"Key of the customer that identifies the specific customer for whom these individual prices apply."
customerId: ID!
"List of individual prices for this customer - can contain different tier prices or special conditions."
prices: [ItemPrice!]!
}
"Defines the collection of all descriptions of an item for creation. This structure manages default, platform, and sales channel-specific item descriptions for different languages and distribution channels."
type ItemDescriptions {
"Default descriptions of the item. This is used when no more specific platform or sales channel descriptions are available and serves as a fallback description."
defaultDescriptions: [DefaultDescription!]!
"List of sales channel-specific descriptions for sales platforms like JTL-Shop. Enables individual customization of item descriptions for specific sales channels."
salesChannelDescriptions: [SalesChannelDescription!]!
"List of platform-specific descriptions for non-sales platforms like print. Allows different descriptions for various output platforms."
platformDescriptions: [PlatformDescription!]!
}
"Defines a single feature assignment for an item. This structure represents the link between an item and a specific feature value from the feature system, allowing detailed product characterization."
type ItemFeature {
"Unique key of the feature value that identifies the specific feature characteristic to be assigned to the item. This key establishes the connection to a predefined feature value in the feature system."
featureId: ID!
}
"Defines the feature assignments of an item. This structure manages all features (characteristics\/attributes) that describe specific properties or attributes of an item, such as color, size, material, or other custom characteristics used for product differentiation and filtering."
type ItemFeatures {
"Contains all features assigned to the item. Each feature represents a specific characteristic or attribute that describes the item in more detail, enabling better product differentiation and advanced filtering capabilities."
features: [ItemFeature!]!
}
"Defines various identifiers of an item for creation. This structure includes all relevant markings and numbers used for unique identification of an item."
type ItemIdentifiers {
"Unique item number (Stock Keeping Unit) - the user-assigned main identification of the item."
sku: String!
"Amazon FNSKU (Fulfillment Network Stock Keeping Unit) - used by Amazon for inventory management."
amazonFnsku: String
"GTIN (Global Trade Item Number, formerly EAN) - internationally standardized product identification for global trade."
gtin: String
"Manufacturer's item number - the official product number assigned by the manufacturer."
manufacturerNumber: String
"ISBN (International Standard Book Number) - mainly used for books and other publications."
isbn: String
"Taric code - customs tariff number for international trade and customs processing."
tariccode: String
"UPC (Universal Product Code) - barcode standard mainly used in North America."
upc: String
"UN number - used for marking dangerous goods in transport."
unNumber: String
"Hazard number - identifies the type of danger for hazardous goods in transport."
hazardNumber: String
"Own identifier - user-defined internal identification for company-specific purposes."
ownIdentifier: String
"Default ASIN (Amazon Standard Identification Number) - primary Amazon product identification."
defaultAsin: String
"JTL-Fulfillment-SKU (JFSKU) - unique identifier in the JTL Fulfillment Network (FFN) for item identification."
jfsku: String
}
type ItemImage {
"Unique ID to identify an image."
blobIdentifier: UUID
"Download Url for the image."
url: String
"Download URL for the preview-sized image."
previewUrl: String
"Sort order of the image."
sortNumber: Int!
"Declares the main image of the item. Typically the image with sort order 1."
isMainImage: Boolean!
"Original source filename of the image including its extension."
filename: String
"Platform the image is assigned to. For default images this is 1 (Wawi)."
platform: ID
"Last modification timestamp of the image."
modificationDate: DateTime
"Width of the image in pixels."
width: Int
"Height of the image in pixels."
height: Int
"File size of the image in kilobytes (bytes divided by 1024, truncated to integer)."
fileSizeKilobytes: Int
}
type ItemImages {
"List of default images assigned to the item."
defaultImages: [ItemImage!]!
"List of images assigned to different platforms."
platformImages: [PlatformImages!]!
"List of images assigned to different saleschannels."
saleschannelImages: [SaleschannelImages!]!
"List of images assigned to different eBay accounts."
ebayImages: [EbayImages!]!
}
"Single row of the item overview"
type ItemListItem {
"Item id"
id: ID!
"Bill of materials ID"
billOfMaterialsId: Int
"Parent item ID (for variation children)"
parentItemId: ID
"Item id for category search"
itemIdForCategoryItemId: ID
"Item number"
sku: String!
"Sort number for display ordering"
sortNumber: Int!
"Name of the item in the requested language"
name: String
"Sales unit name"
unit: String
"Item description (first 255 chars)"
description: String
"Short description (first 255 chars)"
shortDescription: String
"Notes of the item"
notes: String
"Label names"
labels: String
"Series name"
series: String
"GTIN (former EAN) of the item"
gtin: String
"Manufacturer number of the item"
manufacturerNumber: String
"ISBN of the item"
isbn: String
"Default ASIN of the item"
defaultAsin: String
"TaricCode of the item"
taricCode: String
"UPC of the item"
upc: String
"UNNumber of the item"
unNumber: String
"HazardNumber of the item"
hazardNumber: String
"Amazon FNSKU"
amazonFnsku: String
"Identifier for JTL Fulfillment Network"
jfsku: String
"Country of origin"
countryOfOrigin: String
"Name of the manufacturer"
manufacturerName: String
"Delivery status name"
deliveryStatus: String
"Automatic delivery time calculation active"
isDeliveryTimeAutomatic: Boolean!
"Manual delivery time in days"
manualDeliveryTimeDays: Int
"Item width"
width: Decimal!
"Item height"
height: Decimal!
"Item length"
length: Decimal!
"Shipping weight"
shippingWeight: Decimal!
"Item weight (without packaging)"
weight: Decimal!
"Creation date of the item"
createdDate: DateTime
"Last modification date (date only)"
modifiedDate: DateTime
"Last modification timestamp (date and time)"
modifiedTimestamp: DateTime
"Release date of the item"
releaseDate: DateTime
"Date of last purchase"
lastPurchaseDate: DateTime
"Name of the last editor"
lastEditor: String
"Item Net Price"
salesPriceNet: Decimal!
"Sales price gross (including tax)"
salesPriceGross: Decimal!
"UVP"
suggestedRetailPrice: Decimal!
"Average purchase price net"
averagePurchasePriceNet: Decimal!
"Last Purchase Net Price"
lastPurchasePrice: Decimal!
"AmazonPrice Net Price"
amazonPrice: Decimal!
"EbayPrice Net Price"
ebayPrice: Decimal!
"Profit of this item"
profit: Decimal
"Profit in percent"
profitPercent: Decimal!
"Special price status (0 = no special price, 1 = expired, 2 = active)"
specialPriceStatus: Int!
"Base price value"
basePriceValue: Decimal
"Base price unit display code"
basePriceUnit: String
"Measurement unit name"
measurementUnit: String
"Total stock in all warehouses"
stockTotal: Decimal!
"Own Stock (without children\/variations)"
stockOwn: Decimal!
"Stock incoming"
stockIncoming: Decimal!
"Stock on purchase list"
stockOnPurchaseList: Decimal!
"Total stock in orders"
stockInOrders: Decimal!
"Available stock"
stockAvailable: Decimal!
"Total stock reserved"
stockReservedTotal: Decimal!
"Stock in Amazon offers"
stockInAmazonOffers: Int!
"Stock in eBay listings"
ebayStock: Decimal!
"Minimum order quantity"
minimumOrderQuantity: Decimal!
"Purchase interval"
purchaseInterval: Decimal!
"The item buffer"
buffer: Int!
"The Item minimum stock level"
minimumStock: Decimal!
"Determines if negative stock is allowed for this item"
allowNegativeStock: Boolean!
"Determines if the item is working with inventory management"
isInventoryManagementActive: Boolean!
"Determines if the item is working with split quantities in stock"
isDivisible: Boolean!
"The Item HasBatch"
hasBatch: Boolean!
"Determines if the item is working with best before date (MHD)"
hasBestBeforeDate: Boolean!
"If the item uses serial number management."
isSerialNumberManaged: Boolean!
"Serial number tracking flag"
serialNumberTrackingMode: SerialNumberTrackingMode!
"Indicates if the item is active"
isActive: Boolean!
"Is on price list flag"
isOnPriceList: Boolean!
"Is top item flag"
isTopItem: Boolean!
"Is new item flag"
isNew: Boolean!
"Is bill of materials"
isBillOfMaterials: Boolean!
"Is bill of materials component"
isBillOfMaterialsComponent: Boolean!
"Is variation parent"
isVariationParent: Boolean!
"Is variation child"
isVariationChild: Boolean!
"Has minimum stock level"
hasMinimumStock: Boolean!
"Is blocked for order suggestions"
isBlockedForOrderSuggestions: Boolean!
"Is active in at least one shop"
isShopActive: Boolean!
"No order process flag"
isOrderProcessProhibited: Boolean!
"Sales packaging unit (VPE)"
salesPackagingUnit: Byte
"Condition ID"
conditionId: ID
"Condition name"
conditionName: String
"Determines if the item is being shared in the JTL Fulfillment Network"
isFulfillmentActive: Boolean!
"Determines if the item is managed by this client"
isFulfillmentOwn: Boolean!
"Tax class ID"
taxClassId: ID
"Name of the tax class"
taxClassName: String
"Manufacturer ID"
manufacturerId: ID
"Product group ID"
productGroupId: ID
"Name of the ProductGroup"
productGroupName: String
"Default supplier ID"
defaultSupplierId: ID
"Name of the Default Supplier"
defaultSupplier: String
"Shipping class ID"
shippingClassId: ID
"Shipping class name"
shippingClassName: String
"The id of the default image."
defaultImageId: ID
"Additional processing time in days"
additionalProcessingTime: Int
"Meta description for SEO (first 255 chars)"
metaDescription: String
"Title tag for SEO (first 255 chars)"
titleTag: String
"Meta keywords for SEO (first 255 chars)"
metaKeywords: String
"Language ID for descriptions"
languageId: ID
"Company ID"
companyId: ID
"""
Returns the full image structure (default, platform, saleschannel and eBay buckets)
associated with this list row. The DataLoader always returns a value (possibly empty)
for any requested key, so the field never resolves to null.
"""
images: ItemImages! @cost(weight: "10")
"""
Returns the preview URL of the default image for this list row, or null when
the item has no default image. The URL is resolved lazily via
DefaultImageUrlByBildIdDataLoader and batched across all list rows.
"""
defaultImageUrl: String @cost(weight: "10")
}
"Defines the physical dimensions and weight specifications of an item for creation. This structure includes all relevant measurements for storage, shipping and product presentation and is used for shipping cost calculations and storage space optimizations."
type ItemMeasurements {
"Height of the item in the configured unit of measurement (usually centimeters or millimeters)."
height: Decimal!
"Length of the item in the configured unit of measurement (usually centimeters or millimeters)."
length: Decimal!
"Shipping weight of the item for shipping cost calculation in the configured weight unit (usually kilograms or grams). May differ from the actual item weight."
shippingWeight: Decimal!
"Actual weight of the item without packaging in the configured weight unit (usually kilograms or grams)."
weight: Decimal!
"Width of the item in the configured unit of measurement (usually centimeters or millimeters)."
width: Decimal!
}
"Defines a single price with tiering options and discount possibilities. This structure forms the basis for complex price structures with volume discounts and percentage price reductions from the standard price."
type ItemPrice {
"Minimum quantity from which this price applies - enables tier prices based on order quantity (e.g., from 10 pieces)."
fromQuantity: Int!
"Net price for this price tier without taxes - the actual selling price for the specified quantity tier."
netPrice: Decimal!
"Percentage discount on the standard price - indicates by what percentage the standard price is reduced for this price tier. Used as an alternative to NetPrice."
reduceStandardPriceByPercent: Decimal!
}
"Price details for an item."
type ItemPriceDetails {
"Unique ID to identify an item."
itemId: ID!
"The default net sales price of the item."
defaultSalesPriceNet: Decimal
"The latest net sales price of the item."
latestSalesPriceNet: Decimal
"The latest net sales price of the item for a specific customer."
customersLatestSalesPriceNet: Decimal
"The purchase price of the item."
purchasePriceNet: Decimal
"The latest purchase price of the item."
latestPurchasePriceNet: Decimal
}
"Defines the complete price structure of an item for creation. This structure includes all price information for different sales channels, customer groups and individual customer prices as well as basic price information."
type ItemPrices {
"Indicates whether discounts should be ignored for this item. When set to true, no automatic discounts will be applied to the item prices."
ignoreDiscounts: Boolean!
"Net sales price of the item without taxes and discounts - the basic selling price of the item."
salesPriceNet: Decimal!
"Manufacturer's suggested retail price (MSRP) - the selling price recommended by the manufacturer."
suggestedRetailPrice: Decimal!
"Net purchase price without taxes - the price at which the item was purchased."
purchasePriceNet: Decimal!
"eBay-specific selling price - special price for eBay sales."
ebayPrice: Decimal!
"Amazon-specific selling price - special price for Amazon sales."
amazonPrice: Decimal!
"List of sales channel-specific prices - enables different pricing for various sales channels or shops."
salesChannelPrices: [ItemSaleschannelPrices!]!
"List of customer-specific prices - allows individual price agreements for specific customers."
customerPrices: [ItemCustomerPrices!]!
"List of default prices for different customer groups - these prices serve as fallback when no more specific prices are defined."
defaultPrices: [ItemCustomerGroupPrices!]!
}
"Defines sales channel-specific special prices for an item. This structure enables different promotional pricing for a specific sales channel or shop with customer group-related special price structures."
type ItemSalesChannelSpecialPrices {
"Key of the sales channel that identifies the specific sales channel or shop for which this special price structure applies."
salesChannelId: ID!
"List of special prices for different customer groups within this sales channel - enables differentiated promotional pricing by customer groups."
specialPrices: [ItemCustomerGroupSpecialPrice!]!
}
"Defines sales channel-specific prices for an item. This structure enables different pricing for various sales channels or shops with customer group-related price structures."
type ItemSaleschannelPrices {
"Key of the sales channel that identifies the specific sales channel or shop for which this price structure applies."
saleschannelId: ID!
"List of prices for different customer groups within this sales channel - enables differentiated pricing by customer groups."
customerGroupPrices: [ItemCustomerGroupPrices!]!
"Indicates whether this sales channel is active for the item - determines whether the item can be sold in this sales channel."
isActive: Boolean!
}
"Defines the special prices (promotional prices) structure of an item. This structure includes time-based and stock-based special pricing for different sales channels and customer groups, as well as Amazon-specific special prices."
type ItemSpecialPrices {
"Indicates whether special prices are active for this item. When set to true, the special price rules defined below will be applied according to their conditions."
isActive: Boolean!
"Date from which the special price becomes active. The special price will only be valid from this date onwards."
startDate: DateTime
"Date until which the special price remains active. The special price will expire after this date. Only evaluated if IsEndDateActive is true."
endDate: DateTime
"Indicates whether the end date should be considered. If false, the special price has no expiration date."
isEndDateActive: Boolean!
"Minimum stock quantity that must be available for the special price to remain active. Only evaluated if IsStockRestrictionActive is true."
minimumStockQuantity: Int
"Indicates whether the stock restriction should be applied. When true, the special price is only active if the stock level is greater than or equal to MinimumStockQuantity. Can only be activated for items that use stock management."
isStockRestrictionActive: Boolean!
"List of sales channel-specific special prices - enables different promotional pricing for various sales channels or shops with customer group differentiation."
salesChannelSpecialPrices: [ItemSalesChannelSpecialPrices!]!
}
"Defines the storage and inventory management constraints of an item. This structure includes settings for negative stock handling, inventory management, serial numbers, batch tracking, and best-before date management."
type ItemStorageConstraints {
"Allows selling a higher quantity of the item than is actually in stock. This global setting must be activated first before platform-specific or sales channel-specific negative stock settings can be enabled."
allowNegativeStock: Boolean!
"List of platform-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific platforms (e.g., eBay, Amazon). AllowNegativeStock must be activated as well for these settings to take effect."
itemPlatformNegativeStocks: [NegativeStockPlatform!]!
"List of sales channel-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific sales channels or shops. AllowNegativeStock must be activated as well for these settings to take effect."
itemSalesChannelNegativeStocks: [NegativeStockSalesChannel!]!
"Item buffer quantity - defines a safety stock buffer that is reserved and not available for sale. This helps prevent overselling and ensures availability for important orders."
buffer: Int
"Global minimum stock level across all warehouses. When the total stock falls below this value, the item is flagged for reordering. Used for automatic order suggestions and low-stock warnings."
globalMinimumStockLevel: Decimal!
"Indicates whether the item uses batch management. When enabled, the item requires batch numbers to be assigned for each stock movement to enable tracking and traceability."
hasBatch: Boolean!
"Determines if the item is working with inventory management. When active, stock levels are tracked and managed; when inactive, the item is treated as always available regardless of stock levels."
isInventoryManagementActive: Boolean!
"Determines if the item is working with best-before date (MHD - Mindesthaltbarkeitsdatum) management. When enabled, stock items must have an assigned best-before date for tracking perishable goods."
isBestBeforeManaged: Boolean!
"Determines if the item can be sold in split quantities (fractional units). When enabled, stock can be managed in decimal quantities (e.g., 2.5 pieces) instead of only whole numbers."
isStockDivisible: Boolean!
"Determines the type of serial number processing. Defines whether serial numbers are inactive, active, or tracked for this item."
serialNumberType: SerialNumberType!
}
type ItemSupplier {
"Id of the supplier"
supplierId: ID!
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Stock level of the item at the supplier."
stockLevel: Decimal!
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal!
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean!
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"VAT rate of the item at the supplier."
vatRate: Decimal!
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean!
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean!
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal!
"Scale prices defined by the supplier for this item."
scalePrices: [SupplierPrice!]!
}
type ItemSupplierListItem {
"Id of the item supplier"
id: ID!
"Id of the item"
itemId: ID!
"Id of the supplier"
supplierId: ID!
"Name of the supplier"
supplierName: String
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Delivery period as text (max 255 characters)."
deliveryPeriod: String
"Currency used by the supplier"
supplierCurrency: String
"Indicates if the supplier supports dropshipping."
isDropshippingSupported: Boolean!
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean!
"Indicates if this supplier is the default supplier for the item."
isDefaultSupplier: Boolean!
"Indicates if this supplier is the default dropshipping supplier for the item."
isDefaultDropshippingSupplier: Boolean!
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Stock level of the item at the supplier."
stockLevel: Decimal!
"Average delivery time based on historical data."
averageDeliveryTime: Decimal!
"Date when the stock level was last updated."
stockLevelLastModified: DateTime
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean!
"The delivery time of the supplier."
supplierDeliveryTimeInDays: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean!
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal!
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal!
"VAT rate of the item at the supplier."
vatRate: Decimal!
"Scale prices defined by the supplier for this item."
scalePrices: [ItemSupplierPriceListItem!]!
}
type ItemSupplierPriceListItem {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal!
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal!
}
type ItemSuppliers {
"Sets the default supplier for the item."
defaultSupplier: ID
"Sets the default supplier for dropshipping for the item."
defaultDropshippingSupplier: ID
"Assigned suppliers for the item"
suppliers: [ItemSupplier!]!
}
"Single row of the item type information"
type ItemTypeListItem {
"Item id"
id: ID!
"Indicates whether the item is managed as a stock item."
isStockItem: Boolean!
"Indicates whether the item currently has a positive stock quantity."
hasStock: Boolean!
"Indicates whether the item requires serial number tracking."
isSerialNumberItem: Boolean!
"Indicates whether the item can be divided into partial quantities."
isDivisibleStock: Boolean!
"Indicates whether the item has an expiration or best-before date (MHD)."
stockHasExpirationDate: Boolean!
"Indicates whether the item is managed as a batch or lot item."
stockIsBatch: Boolean!
"Indicates whether the item is a bill of materials (BOM \/ Stückliste)."
isBillOfMaterials: Boolean!
"Indicates whether the item is used as a component within a bill of materials."
isBillOfMaterialsComponent: Boolean!
"Indicates whether the item is a parent of a variation combination."
isVariationCombinationParent: Boolean!
"Indicates whether the item is a child (variant) of a variation combination."
isVariationCombinationChild: Boolean!
"Indicates whether the item has variations defined."
hasVariations: Boolean!
"Indicates whether the item represents a voucher."
isVoucher: Boolean!
"Indicates whether the item is a packaging item."
isPackaging: Boolean!
"Indicates whether the item has a configuration attached."
hasConfigurationGroup: Boolean!
"Indicates whether the item is a configuration component."
isConfigurationComponent: Boolean!
}
"Defines the item unit pricing settings for creation and modification. This structure includes all relevant information about the sales unit, packaging unit, inner quantity and base price details for an item."
type ItemUnitPricing {
"Id of the sales unit in which the item is sold (e.g. piece or box)."
salesUnitId: ID
"Id of the packaging unit of the item."
packagingUnitId: ID
"The amount of content for one piece of the sales unit, relative to the inner quantity unit."
innerQuantity: Decimal!
"The measurement unit for the inner quantity (e.g. kg or liter)."
innerQuantityUnitId: ID
"Indicates whether the base price should be automatically calculated and displayed."
isBasePriceDeclared: Boolean!
"The measurement unit to which the base price refers (e.g. per liter or per 100 grams)."
basePriceReferenceUnitId: ID
"The reference amount used when calculating the base price (e.g. 1 for per liter, 100 for per 100 grams)."
basePriceReferenceAmount: Decimal!
}
type ItemVariations {
"Contains all Variations"
variations: [Variation!]!
}
"Complete item details including all sub-elements"
type ItemdetailsItem {
"Item id"
id: ID!
"The ID of the product group to which the item should be assigned. Product groups serve for categorical classification of items for reports and analyses."
productGroupId: ID
"The ID of the shipping class to which the item should be assigned."
shippingClassId: ID
"The ID of the manufacturer to which the item should be assigned."
manufacturerId: ID
"Various identifiers of the item for unique identification (SKU, GTIN, ISBN, etc.)"
identifiers: ItemIdentifiers!
"Categories to which the item is assigned"
categories: ItemCategories!
"List of item descriptions in different languages"
descriptions: ItemDescriptions!
"Price structures of the item for different sales channels, customer groups and individual customers. Includes sales prices, purchase prices and tier prices."
prices: ItemPrices!
"Images associated with the item"
images: ItemImages!
"Physical dimensions and weight specifications of the item for storage, shipping and product presentation. Important for shipping cost calculations and storage space optimization."
measurements: ItemMeasurements!
"Custom fields defined for the item to store additional information. Useful for special requirements or integrations."
customFields: ItemCustomFields!
"Suppliers associated with the item including supplier-specific information such as purchase prices, delivery times and order intervals."
suppliers: ItemSuppliers!
"Indicates whether the item can be included in exported price lists. From Tab 'Sonstiges'."
includeInPriceList: Boolean!
"Indicates whether order suggestions should be ignored for this item. If true, the item will not appear in automatic order suggestions. From Tab 'Sonstiges'."
ignoreOrderSuggestions: Boolean!
"Indicates whether the item is not eligible for discounts (Rabatte ignorieren \/ Nicht Rabattfähig). From Tab 'Sonstiges'."
ignoreDiscounts: Boolean!
"Country of origin (Herkunftsland) - ISO code or country name. Max length 64. From Tab 'Sonstiges'."
countryOfOrigin: String
"Additional notes (Anmerkung) for the item - unlimited length. From Tab 'Sonstiges'."
notes: String
"Last modification timestamp (date and time) of the item."
modifiedTimestamp: DateTime
"Variations of an item"
variations: ItemVariations!
"Features of an item"
features: ItemFeatures!
"Attributes of an item"
attributes: ItemAttributes!
"UnitPricing information of an item"
unitPricing: ItemUnitPricing!
"SpecialPrices information of an item"
specialPrices: ItemSpecialPrices!
"ItemStorageConstraints information of an item"
storageConstraints: ItemStorageConstraints!
"CrosssellingGroups of an item"
crosssellingGroups: ItemCrosssellingGroups!
}
"Represents a language item in the system"
type LanguageItem {
"The culture ISO code of the language"
cultureIso: String!
"The two-letter ISO code of the language"
languageIso2: String!
"The three-letter ISO code of the language"
languageIso3: String!
"The name of the language in the Accept-Language header"
name: String!
"Indicates if this language is the default language"
isDefault: Boolean!
}
"""
The first Wawi image of the article referenced by a sales order/quotation line item,
resolved cross-domain from the ArtikelVerwaltung domain so the frontend can render the
line-item image from blob storage without re-fetching the article.
"""
type LineItemImage {
"Gets or sets the blob identifier referencing the image binary in blob storage."
blobIdentifier: UUID
"Gets or sets the resolved download URL of the full-size image."
url: URL
"Gets or sets the resolved download URL of the preview-sized image."
previewUrl: URL
"Gets or sets the source filename of the image file including its extension."
filename: String
"Gets or sets the width of the image in pixels."
width: Int
"Gets or sets the height of the image in pixels."
height: Int
}
"A lot size for a production item. It defines the quantity of a production item that is produced in one lot."
type LotSize {
"The ID of this lot size."
id: ID!
"The ID of the production item of this lot size."
productionItemId: ID!
"The quantity of the production item that is produced in one lot."
quantity: Int!
}
"Single Row of the manufacturer overview"
type ManufacturerListItem {
"Id of the manufacturer."
id: ID!
"Sortnumber of the manufacturer."
sortNumber: Int!
"Default manufacturer Name"
name: String!
}
"Marks a given sales order as completely paid by creating a payment with the open amount of the sales order. - Response"
type MarkSalesOrderAsPaidCommandResponse {
"List of the created payment Ids."
paymentIds: [ID]!
}
"Single row of the external document overview list."
type MarketplaceExternalDocumentListItem {
"ID of the invoice."
invoiceId: ID
"ID of the credit note."
creditNoteId: ID
"ID of the sales order."
salesOrderId: ID
"Type of the external document."
documentType: MarketplaceExternalDocumentType!
"Origin of the external document."
origin: MarketplaceExternalDocumentOrigin!
"Name of the shop."
shopName: String
"Invoice date."
invoiceDate: DateTime
"External sales order number."
externalSalesOrderNumber: String
"Gross total amount."
grossTotal: Decimal!
"ID of the associated document file."
documentFileId: ID
"Document number."
documentNumber: String
"ID of the seller."
sellerId: ID!
"Currency code."
currency: String
}
"Single row of the invoice correction PDF upload overview list."
type MarketplaceInvoiceCorrectionPdfUploadListItem {
"ID of the document upload queue entry."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"ID of the sales order."
salesOrderId: ID!
"Name of the shop."
shopName: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String!
"Invoice correction number."
invoiceCorrectionNumber: String!
"Invoice correction creation timestamp."
invoiceCorrectionCreatedAt: DateTime
"Invoice correction gross amount."
invoiceCorrectionGrossAmount: Decimal!
"Sales order gross amount."
salesOrderGrossAmount: Decimal!
"UTC timestamp when the queue entry was created."
createdAt: DateTime!
"Number of print attempts."
printAttemptCount: Int!
"Number of upload attempts."
uploadAttemptCount: Int!
"UTC timestamp when PDF generation started."
printStartedAt: DateTime
"UTC timestamp when PDF generation finished."
printCompletedAt: DateTime
"UTC timestamp when upload to the channel succeeded."
uploadCompletedAt: DateTime
"Status message."
message: String
"Remaining print attempts."
printAttemptsRemaining: Int
"Print status of the invoice correction PDF."
printStatus: MarketplaceInvoicePdfPrintStatus!
"Remaining upload attempts."
uploadAttemptsRemaining: Int
"Upload status of the invoice correction PDF."
uploadStatus: MarketplaceInvoicePdfUploadStatus!
"Overall queue status."
status: MarketplaceUploadQueueStatus!
}
"Single row of the invoice correction upload line item overview list."
type MarketplaceInvoiceCorrectionUploadLineItemListItem {
"ID of the order item."
id: ID!
"ID of the order."
orderId: ID!
"Quantity of the line item."
quantity: Decimal!
"Article number."
articleNumber: String
"Article name."
articleName: String
"Amount."
amount: Decimal!
"Currency."
currency: String
}
"Single row of the invoice correction upload overview list."
type MarketplaceInvoiceCorrectionUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"ID of the sales order."
salesOrderId: ID!
"Name of the shop."
shopName: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Invoice correction number."
invoiceCorrectionNumber: String
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Creation timestamp."
createdAt: DateTime
"Invoice correction gross amount."
invoiceCorrectionGrossAmount: Decimal!
"Timestamp of the last failed refund upload in UTC."
refundUploadFailedAt: DateTime
"Number of refund upload attempts."
refundUploadCount: Int
"Remaining upload attempt count."
uploadCountRemaining: Int
"Status of the invoice correction upload."
status: MarketplaceInvoiceCorrectionUploadStatus!
}
"Single row of the invoice PDF upload overview list."
type MarketplaceInvoicePdfUploadListItem {
"ID of the document upload queue entry."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"ID of the sales order."
salesOrderId: ID!
"Name of the shop."
shopName: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String!
"Invoice number."
invoiceNumber: String!
"Invoice creation timestamp."
invoiceCreatedAt: DateTime!
"Invoice gross amount."
invoiceGrossAmount: Decimal!
"Sales order gross amount."
salesOrderGrossAmount: Decimal!
"UTC timestamp when the queue entry was created."
createdAt: DateTime!
"Number of print attempts."
printAttemptCount: Int!
"Number of upload attempts."
uploadAttemptCount: Int!
"UTC timestamp when PDF generation started."
printStartedAt: DateTime
"UTC timestamp when PDF generation finished."
printCompletedAt: DateTime
"UTC timestamp when upload to the channel succeeded."
uploadCompletedAt: DateTime
"Status message."
message: String
"Remaining print attempts."
printAttemptsRemaining: Int
"Print status of the invoice PDF."
printStatus: MarketplaceInvoicePdfPrintStatus!
"Remaining upload attempts."
uploadAttemptsRemaining: Int
"Upload status of the invoice PDF."
uploadStatus: MarketplaceInvoicePdfUploadStatus!
"Overall queue status."
status: MarketplaceUploadQueueStatus!
}
"Single row of the notification detail overview list."
type MarketplaceNotificationDetailListItem {
"ID of the notification detail."
id: ID!
"ID of the notification."
notificationId: ID!
"Detail code of the notification."
code: String
"Detailed message of the notification."
message: String
}
"Single Row of the notification overview list."
type MarketplaceNotificationListItem {
"ID of the notification."
id: ID!
"Reference key associated with the notification."
referenceId: ID
"Event identifier that triggered this notification."
eventId: String!
"Creation timestamp."
creationDate: DateTime!
"Severity level of the notification."
severity: MarketplaceNotificationSeverity!
"Type of the notification."
notificationType: MarketplaceNotificationType!
"Optional reference string providing additional context."
reference: String
"Whether the notification has been read."
isRead: Boolean!
"ID of the shop."
shopId: ID!
"Optional order cancellation request identifier."
orderCancellationRequestId: String
"Optional short message summarizing the notification."
shortMessage: String
"Name of the marketplace channel."
channel: String!
"Optional display name of the shop."
shopName: String
"Optional title of the associated offer."
offerTitle: String
}
"Single row of the offer failure list."
type MarketplaceOfferFailureListItem {
"ID of the offer failure."
id: ID!
"ID of the associated offer."
offerId: ID!
"Error code."
code: String!
"Short error message."
message: String!
"Detailed error message."
longMessage: String
"Creation timestamp (UTC)."
createdAt: DateTime!
}
"Single row of the marketplace offer overview list."
type MarketplaceOfferListItem {
"ID of the offer."
offerId: ID!
"ID of the linked article."
itemId: ID!
"Stock keeping unit."
sku: String
"Product number of the article."
productNumber: String
"Title of the offer."
offerTitle: String
"Display name of the sales channel."
channelName: String
"ID of the channel."
channelId: ID!
"Internal channel identifier."
channel: String
"ID of the shop."
shopId: ID!
"ID of the seller."
shopScxId: ID!
"Current quantity."
quantity: Decimal!
"Expiration date of the offer."
expirationDate: DateTime
"ID of the channel category."
categoryId: ID!
"Channel-specific category identifier."
channelCategoryId: String
"Display name of the channel category."
channelCategoryName: String
"Net price of the offer."
netPrice: Decimal
"Percentage discount."
percent: Decimal
"ID of the price entry."
priceId: ID!
"ID of the customer group."
customerGroupId: ID!
"Net sale price from the article."
salePriceNet: Decimal
"ID of the tax class."
taxClassId: ID!
"ID of the company."
companyId: ID!
"Currency code of the channel."
currency: String
"Available stock quantity."
availableQuantity: Decimal
"Quantity reserved in orders."
quantityInOrders: Decimal
"Expected inbound quantity."
inboundQuantity: Decimal
"Global Trade Item Number."
gtin: String
"Product weight."
productWeight: Decimal
"Manufacturer Part Number."
mpn: String
"International Standard Book Number."
isbn: String
"Amazon Standard Identification Number."
asin: String
"Name of the manufacturer."
manufacturer: String
"Net purchase price."
purchasePriceNet: Decimal
"Timestamp since the offer is active."
activeSince: DateTime
"Processing time in days."
processingTime: Int
"Date when inbound stock becomes available."
inboundAvailableAt: DateTime
"Type of the offer."
offerType: MarketplaceOfferType!
"Combined lifecycle and action status of the offer."
offerStatus: MarketplaceOfferViewStatus!
"URL of the offer listing on the channel."
listingUrl: String
"Whether the offer is currently listed."
isListed: Boolean!
"ID of the sales channel article data."
salesChannelItemDataId: Int
"Minimum stock threshold."
minimumStock: Decimal
"Maximum stock threshold."
maximumStock: Decimal
"Timestamp of the last upload."
lastUpload: DateTime
"Number of days after which pending offers are deleted."
deletionIntervalPendingOffer: Int!
"Name of the shop."
shopName: String
"Whether the offer is external."
isExtern: Boolean!
"Timestamp when the quantity was last updated."
quantityUpdatedAt: DateTime
"Timestamp when the price was last updated. UTC."
priceUpdatedAt: DateTime
"Timestamp when the status was last received. UTC."
statusReceivedAt: DateTime
"Last uploaded price value."
lastUploadedPrice: Decimal
"Whether automatic stock updates are enabled for this seller."
stockUpdateEnabled: Boolean!
"Channel-specific offer identifier."
channelOfferId: String
}
"Single row of the order cancellation request upload overview list."
type MarketplaceOrderCancellationRequestUploadListItem {
"ID of the cancellation event."
id: ID!
"ID of the order."
orderId: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Sales order number."
salesOrderNumber: String!
"Display name of the sales channel."
salesChannelDisplayName: String!
"External sales order number."
externalSalesOrderNumber: String
"ID of the sales order."
salesOrderId: ID!
"Creation timestamp."
createdAt: DateTime!
"Remaining upload attempt count."
uploadCountRemaining: Int
"Status of the cancellation request upload."
status: MarketplaceOrderCancellationRequestUploadStatus!
"Upload attempt count."
uploadCount: Byte!
}
"Single Row of the order cancellation upload overview list."
type MarketplaceOrderCancellationUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Indicates whether cancellation upload is required for the order."
cancellationUploadRequired: Boolean!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Gross sales order amount."
salesOrderGrossAmount: Decimal!
"Creation timestamp."
createdAt: DateTime!
"ID of the sales order."
salesOrderId: ID!
"Number of cancellation upload attempts."
cancellationUploadCount: Int!
"Timestamp of the last failed cancellation upload in UTC."
cancellationUploadFailedAt: DateTime
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the cancellation upload."
status: MarketplaceOrderCancellationUploadStatus!
}
"Single Row of the payment upload overview list."
type MarketplacePaymentUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Indicates whether payment upload is required for the order."
paymentUploadRequired: Boolean!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Gross sales order amount."
salesOrderGrossAmount: Decimal!
"Gross paid amount of the sales order."
salesOrderPaymentGrossAmount: Decimal!
"Creation timestamp."
createdAt: DateTime!
"ID of the sales order."
salesOrderId: ID!
"Number of payment upload attempts."
paymentUploadCount: Int!
"Timestamp of the last failed payment upload in UTC."
paymentUploadFailedAt: DateTime
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the payment upload."
status: MarketplacePaymentUploadStatus!
}
"Single row of the return upload line item overview list."
type MarketplaceReturnUploadLineItemListItem {
"ID of the return line item."
id: ID!
"ID of the order."
orderId: ID!
"ID of the return."
returnId: ID!
"Quantity of the return line item."
quantity: Decimal!
"Indicates whether the line item is credited in the credit note."
creditNoteRequired: Boolean!
"SKU of the item."
sku: String
"Name of the return line item."
name: String
}
"Single Row of the return upload overview list."
type MarketplaceReturnUploadListItem {
"ID of the order."
id: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"Name of the shop."
shopName: String
"Indicates whether return upload is required for the order."
returnUploadRequired: Boolean!
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Return number."
returnNumber: String!
"Display name of the sales channel."
salesChannelDisplayName: String!
"Gross sales order amount."
salesOrderGrossAmount: Decimal!
"Creation timestamp."
createdAt: DateTime!
"ID of the sales order."
salesOrderId: ID!
"Number of return upload attempts."
returnUploadCount: Int!
"Timestamp of the last failed return upload in UTC."
returnUploadFailedAt: DateTime
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the return upload."
status: MarketplaceReturnUploadStatus!
"Gross amount of the linked credit note."
creditNoteGrossAmount: Decimal!
"ID of the return."
returnId: ID!
}
"Seller detail sub-elements (price types, shipping rules, metadata, supported marketplaces)."
type MarketplaceSellerDetailsItem {
"Price types assigned to this seller channel."
priceTypes: MarketplaceSellerPriceTypes!
"Shipping rules assigned to this seller channel."
shippingRules: MarketplaceSellerShippingRules!
"Metadata entries for this seller (no date required)."
metaData: MarketplaceSellerMetaData!
"Event entries for this seller (with CreatedAfter date)."
events: MarketplaceSellerEvents!
"Supported marketplaces for this seller channel."
supportedMarketplaces: MarketplaceSellerSupportedMarketplaces!
"Return tracking settings for this seller."
returnSettings: MarketplaceSellerReturnSettings!
}
"Wrapper containing a list of all marketplace sellers with complete details."
type MarketplaceSellerDetailsListItem {
"List of sellers with all nested detail data."
sellers: [MarketplaceSellerWithDetailsItem!]!
}
"Single event entry for a seller (CreatedAfter date is relevant)."
type MarketplaceSellerEventItem {
"Event type (e.g. Channel:Order, Channel:OfferListing:Failed). Unique key per seller."
type: String!
"ID of the metadata entry. Null if not yet persisted."
metaDataEntryId: ID
"Resource identifier."
resource: String
"Seller identifier."
sellerId: String!
"ID of the channel."
channelId: ID!
"Events created after this timestamp will be fetched."
createdAfter: DateTime
"API mode type (0=Event)."
apiModeType: MarketplaceApiModeType!
"Whether import is enabled for this event type."
isImportEnabled: Boolean!
}
"Event entries for a marketplace seller (with CreatedAfter date)."
type MarketplaceSellerEvents {
"List of event entries."
events: [MarketplaceSellerEventItem!]!
}
"Flat read model of a marketplace seller from SCX.lvSeller."
type MarketplaceSellerListItem {
"ID of the SCX shop assignment."
scxShopId: ID!
"ID of the shop."
shopId: ID!
"ID of the channel."
channelId: ID!
"Name of the shop."
name: String
"Shop is active."
isActive: Boolean!
"Shop blocked state."
isBlocked: Byte
"ID of the company."
companyId: ID
"ID of the warehouse."
warehouseId: ID
"ID of the language."
languageId: ID
"Seller identifier on the marketplace channel."
sellerId: String!
"Channel code."
channel: String!
"Creation timestamp."
createdAt: DateTime!
"Last update timestamp."
updatedAt: DateTime
"Reason text."
reason: String
"ID of the default shipping method."
shippingMethodId: ID
"Display name of the channel."
channelDisplayName: String!
"Currency of the channel."
channelCurrency: String!
"Document storage is enabled."
isDocumentStorageEnabled: Boolean!
"Stock update is enabled."
isStockUpdateEnabled: Boolean!
"Offer automapping is enabled."
isOfferAutomappingEnabled: Boolean!
"Offer automapping type."
offerAutomappingType: MarketplaceOfferAutomappingType!
"Attribute import is enabled."
isAttributeImportEnabled: Boolean!
"Order confirm type."
orderConfirmType: MarketplaceOrderConfirmType!
"ID of the payment method."
paymentMethodId: ID
"Deletion interval for pending offers in days."
pendingOfferDeletionIntervalDays: Int!
"Deletion interval for completed offers in days."
completedOfferDeletionIntervalDays: Int!
"SCX shop assignment is marked as deleted."
isDeleted: Boolean!
"Channel supports variations."
isVariationsSupported: Boolean!
"Channel supports quantity prices."
isQuantityPriceSupported: Boolean!
"Invoice document transfer mode."
invoiceDocumentTransfer: MarketplaceInvoiceDocumentTransferType!
"Channel allows combining orders."
isAllowCombineOrders: Boolean!
}
"Metadata entries for a marketplace seller (no date required)."
type MarketplaceSellerMetaData {
"List of metadata entries."
metaData: [MarketplaceSellerMetaDataItem!]!
}
"Single metadata entry for a seller (ApiModeType = Metadata\/MetadataPull)."
type MarketplaceSellerMetaDataItem {
"Download type (e.g. CATEGORY, GLOBAL_ATTRIBUTES). Unique key per seller."
type: String!
"ID of the metadata entry. Null if not yet persisted."
metaDataEntryId: ID
"Resource identifier."
resource: String
"Seller identifier."
sellerId: String!
"ID of the channel."
channelId: ID!
"API mode type (1=Metadata, 4=MetadataPull)."
apiModeType: MarketplaceApiModeType!
"Whether import is enabled for this metadata type."
isImportEnabled: Boolean!
}
"Single price type assigned to a seller channel."
type MarketplaceSellerPriceType {
"ID of the channel price type."
channelPriceTypeId: ID!
"ID of the channel."
channelId: ID!
"ID of the shop."
shopId: ID!
"Price type identifier on the channel."
priceTypeId: String
"Display name of the price type."
displayName: String
"Description of the price type."
description: String
"ID of the mapped customer group."
customerGroupId: ID
}
"Price types assigned to a marketplace seller."
type MarketplaceSellerPriceTypes {
"List of price types."
priceTypes: [MarketplaceSellerPriceType!]!
}
"Return tracking settings for a marketplace seller."
type MarketplaceSellerReturnSettings {
"Channel requires return tracking."
isReturnTrackingRequired: Boolean!
"Return tracking ID generation is enabled."
isReturnTrackingIdEnabled: Boolean!
"Return transmission type."
returnTransmissionType: MarketplaceReturnTransmissionType!
"Refund transmission type."
refundTransmissionType: MarketplaceRefundTransmissionType!
"ID of the return shipping rule (carrier code)."
returnShippingRuleId: ID
"ID of the return warehouse."
returnWarehouseId: ID
"Prefix for return number range."
returnNumberRangePrefix: String
"Start of return number range."
returnNumberRangeFrom: Long!
"End of return number range."
returnNumberRangeTo: Long!
"Suffix for return number range."
returnNumberRangeSuffix: String
"Current return number in the range."
returnNumberRangeCurrent: Long!
"Return ID limit warning is enabled."
isReturnIdLimitWarningEnabled: Boolean!
"Remaining IDs threshold for warning."
returnIdLimitWarningCount: Int!
"Email address for return ID limit warning."
returnIdLimitWarningEmail: String
}
"Single shipping rule assigned to a seller channel."
type MarketplaceSellerShippingRule {
"ID of the shipping rule."
shippingRuleId: ID!
"ID of the channel."
channelId: ID!
"Carrier identifier."
carrierId: String!
"Display name of the shipping rule."
displayName: String
"ID of the mapped shipping method."
shippingMethodId: ID
"ID of the shop."
shopId: ID
"Custom carrier code override."
customCarrierId: String
}
"Shipping rules assigned to a marketplace seller."
type MarketplaceSellerShippingRules {
"List of shipping rules."
shippingRules: [MarketplaceSellerShippingRule!]!
}
"Single supported marketplace (country) for a seller channel."
type MarketplaceSellerSupportedMarketplace {
"ID of the channel."
channelId: ID!
"ISO code of the marketplace country."
iso: String!
"Country name."
name: String!
"Sort order."
sort: Byte!
}
"Supported marketplaces for a seller channel."
type MarketplaceSellerSupportedMarketplaces {
"List of supported marketplaces."
supportedMarketplaces: [MarketplaceSellerSupportedMarketplace!]!
}
"Complete marketplace seller including base info and all detail sub-elements."
type MarketplaceSellerWithDetailsItem {
"ID of the SCX shop assignment."
scxShopId: ID!
"ID of the shop."
shopId: ID!
"ID of the channel."
channelId: ID!
"Name of the shop."
name: String
"Shop is active."
isActive: Boolean!
"Shop blocked state."
isBlocked: Byte
"ID of the company."
companyId: ID
"ID of the warehouse."
warehouseId: ID
"ID of the language."
languageId: ID
"Seller identifier on the marketplace channel."
sellerId: String!
"Channel code."
channel: String!
"Creation timestamp."
createdAt: DateTime!
"Last update timestamp."
updatedAt: DateTime
"Reason text."
reason: String
"ID of the default shipping method."
shippingMethodId: ID
"Display name of the channel."
channelDisplayName: String!
"Currency of the channel."
channelCurrency: String!
"Document storage is enabled."
isDocumentStorageEnabled: Boolean!
"Stock update is enabled."
isStockUpdateEnabled: Boolean!
"Offer automapping is enabled."
isOfferAutomappingEnabled: Boolean!
"Offer automapping type."
offerAutomappingType: MarketplaceOfferAutomappingType!
"Attribute import is enabled."
isAttributeImportEnabled: Boolean!
"Order confirm type."
orderConfirmType: MarketplaceOrderConfirmType!
"ID of the payment method."
paymentMethodId: ID
"Deletion interval for pending offers in days."
pendingOfferDeletionIntervalDays: Int!
"Deletion interval for completed offers in days."
completedOfferDeletionIntervalDays: Int!
"SCX shop assignment is marked as deleted."
isDeleted: Boolean!
"Channel supports variations."
isVariationsSupported: Boolean!
"Channel supports quantity prices."
isQuantityPriceSupported: Boolean!
"Invoice document transfer mode."
invoiceDocumentTransfer: MarketplaceInvoiceDocumentTransferType!
"Channel allows combining orders."
isAllowCombineOrders: Boolean!
"Price types assigned to this seller channel."
priceTypes: MarketplaceSellerPriceTypes!
"Shipping rules assigned to this seller channel."
shippingRules: MarketplaceSellerShippingRules!
"Metadata entries for this seller (no date required)."
metaData: MarketplaceSellerMetaData!
"Event entries for this seller (with CreatedAfter date)."
events: MarketplaceSellerEvents!
"Supported marketplaces for this seller channel."
supportedMarketplaces: MarketplaceSellerSupportedMarketplaces!
"Return tracking settings for this seller."
returnSettings: MarketplaceSellerReturnSettings!
}
"Single row of the shipping information upload overview list."
type MarketplaceShippingInformationUploadListItem {
"ID of the shipping information upload entry."
id: ID!
"ID of the delivery note."
deliveryNoteId: ID!
"ID of the order."
orderId: ID!
"ID of the shop."
shopId: ID!
"ID of the seller."
sellerId: ID!
"ID of the sales order."
salesOrderId: ID!
"Name of the shop."
shopName: String
"Display name of the sales channel."
salesChannelDisplayName: String!
"Delivery note number."
deliveryNoteNumber: String
"Sales order number."
salesOrderNumber: String!
"External sales order number."
externalSalesOrderNumber: String
"Creation timestamp."
createdAt: DateTime!
"Timestamp of the last failed upload in UTC."
uploadFailedAt: DateTime
"Upload attempt count."
uploadCount: Byte!
"Remaining upload attempt count."
uploadCountRemaining: Int!
"Status of the shipping information upload."
status: MarketplaceShippingInformationUploadStatus!
}
"Mutation collection of the BillOfMaterialsComponents domain"
type Mutation {
"Deletes a bill of materials item from a bill of materials."
DeleteBillOfMaterialsItem(request: DeleteBillOfMaterialsItemCommandRequestInput!): Boolean! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Deletes a bill of materials operation from a bill of materials."
DeleteBillOfMaterialsOperation(request: DeleteBillOfMaterialsOperationCommandRequestInput!): Boolean! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Deletes a bill of materials."
DeleteBillOfMaterials(request: DeleteBillOfMaterialsCommandRequestInput!): Boolean! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new bill of materials for a production item, including its components."
CreateBillOfMaterials(request: CreateBillOfMaterialsCommandRequestInput!): CreateBillOfMaterialsCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new bill of materials item for a bill of materials operation."
CreateBillOfMaterialsItem(request: CreateBillOfMaterialsItemCommandRequestInput!): CreateBillOfMaterialsItemCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new bill of materials operation for a bill of materials, including its items."
CreateBillOfMaterialsOperation(request: CreateBillOfMaterialsOperationCommandRequestInput!): CreateBillOfMaterialsOperationCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new lot size for a production item."
CreateLotSize(request: CreateLotSizeCommandRequestInput!): CreateLotSizeCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new production item, including its bills of materials with their components."
CreateProductionItem(request: CreateProductionItemCommandRequestInput!): CreateProductionItemCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new production order."
CreateProductionOrder(request: CreateProductionOrderCommandRequestInput!): CreateProductionOrderCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Releases an existing production order."
ReleaseProductionOrder(request: ReleaseProductionOrderCommandRequestInput!): ReleaseProductionOrderCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Updates a production order."
UpdateProductionOrder(request: UpdateProductionOrderCommandRequestInput!): UpdateProductionOrderCommandResponse! @authorize(roles: [ "pps.write", "system.all" ]) @cost(weight: "10")
"Creates a new workbench resource type"
CreateWorkbenchResourceType(request: CreateWorkbenchResourceTypeCommandRequestInput!): CreateWorkbenchResourceTypeCommandResponse! @authorize(roles: [ "resources.write", "system.all" ]) @cost(weight: "10")
"Creates a new workbench resource"
CreateWorkbenchResource(request: CreateWorkbenchResourceCommandRequestInput!): CreateWorkbenchResourceCommandResponse! @authorize(roles: [ "resources.write", "system.all" ]) @cost(weight: "10")
"Creates a new Category."
CreateCategory(request: CreateCategoryCommandRequestInput!): CreateCategoryCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Delete a Category"
DeleteCategory(request: DeleteCategoryCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Updates a new Category"
UpdateCategory(request: UpdateCategoryCommandRequestInput!): UpdateCategoryCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"A command to modify an existing company, including identification, contact, banking, and tax information."
ChangeCompany(request: ChangeCompanyCommandRequestInput!): ChangeCompanyCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"A command to create a new company, including identification, contact, banking, and tax information."
CreateCompany(request: CreateCompanyCommandRequestInput!): CreateCompanyCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
CopyItemdetails(request: CopyItemdetailsCommandRequestInput!): CopyItemdetailsCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates one or more duplicates of an existing item with specified duplication options."
DuplicateItems(request: DuplicateItemsCommandRequestInput!): DuplicateItemsCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals."
AddItemSupplier(request: AddItemSupplierCommandRequestInput!): AddItemSupplierCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options."
AddItemVariation(request: AddItemVariationCommandRequestInput!): AddItemVariationCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Adds a new value to an existing item variation."
AddItemVariationValue(request: AddItemVariationValueCommandRequestInput!): AddItemVariationValueCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information."
ChangeItem(request: ChangeItemCommandRequestInput!): ChangeItemCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements."
CreateItem(request: CreateItemCommandRequestInput!): CreateItemCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Removes an existing variation from an item. All associated variation values and combinations will also be removed."
DeleteItemVariation(request: DeleteItemVariationCommandRequestInput!): DeleteItemVariationCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Removes a specific value from an item variation."
DeleteItemVariationValue(request: DeleteItemVariationValueCommandRequestInput!): DeleteItemVariationValueCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Add new product groups."
AddProductGroups(request: AddProductGroupsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Delete existing product groups."
DeleteProductGroups(request: DeleteProductGroupsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Update the properties of product groups."
UpdateProductGroups(request: UpdateProductGroupsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Updates the active sales channels for a set of items"
UpdateItemSalesChannels(request: UpdateItemSalesChannelsCommandRequestInput!): Boolean! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates a new shipping class"
CreateShippingClass(request: CreateShippingClassCommandRequestInput!): CreateShippingClassCommandResponse! @authorize(roles: [ "items.write", "system.all" ]) @cost(weight: "10")
"Creates a customer"
CreateCustomer(request: CreateCustomerCommandRequestInput!): CreateCustomerCommandResponse! @authorize(roles: [ "customers.write", "system.all" ]) @cost(weight: "10")
"Updates a customer"
UpdateCustomer(request: UpdateCustomerCommandRequestInput!): UpdateCustomerCommandResponse! @authorize(roles: [ "customers.write", "system.all" ]) @cost(weight: "10")
"Exclude marketplace invoice corrections from upload."
ExcludeMarketplaceInvoiceCorrectionFromUpload(request: ExcludeMarketplaceInvoiceCorrectionFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace invoice correction PDFs from upload."
ExcludeMarketplaceInvoiceCorrectionPdfFromUpload(request: ExcludeMarketplaceInvoiceCorrectionPdfFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace invoice PDFs from upload."
ExcludeMarketplaceInvoicePdfFromUpload(request: ExcludeMarketplaceInvoicePdfFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace invoice correction PDFs."
ResetMarketplaceInvoiceCorrectionPdfUploadCounter(request: ResetMarketplaceInvoiceCorrectionPdfUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace invoice corrections."
ResetMarketplaceInvoiceCorrectionUploadCounter(request: ResetMarketplaceInvoiceCorrectionUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Resets PDF generation for marketplace invoices\/invoice corrections so they can be reprinted and uploaded again."
ResetMarketplaceInvoicePdfPrinting(request: ResetMarketplaceInvoicePdfPrintingCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Assigns the specified item to the specified marketplace offer."
AssignItemToMarketplaceOffer(request: AssignItemToMarketplaceOfferCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Deletes the specified marketplace offers."
DeleteMarketplaceOffer(request: DeleteMarketplaceOfferCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Ends the specified marketplace offers for a shop."
EndMarketplaceOffer(request: EndMarketplaceOfferCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Removes the item assignment from the specified marketplace offers."
RemoveItemFromMarketplaceOffer(request: RemoveItemFromMarketplaceOfferCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Sets the maximum stock quantity for the specified marketplace offers."
SetMarketplaceOfferMaxQuantity(request: SetMarketplaceOfferMaxQuantityCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Sets the minimum stock quantity for the specified marketplace offers."
SetMarketplaceOfferMinQuantity(request: SetMarketplaceOfferMinQuantityCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Triggers offer synchronisation for the specified marketplace offers."
TriggerMarketplaceOfferSynchronisation(request: TriggerMarketplaceOfferSynchronisationCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Triggers stock synchronisation for the specified marketplace offers."
TriggerMarketplaceStockSynchronisation(request: TriggerMarketplaceStockSynchronisationCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Cancel marketplace order cancellation request uploads."
CancelMarketplaceOrderCancellationRequestUpload(request: CancelMarketplaceOrderCancellationRequestUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace order cancellation uploads from upload."
ExcludeMarketplaceOrderCancellationUploadFromUpload(request: ExcludeMarketplaceOrderCancellationUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace payment uploads from upload."
ExcludeMarketplacePaymentUploadFromUpload(request: ExcludeMarketplacePaymentUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace return uploads from upload."
ExcludeMarketplaceReturnUploadFromUpload(request: ExcludeMarketplaceReturnUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Exclude marketplace shipping information uploads from upload."
ExcludeMarketplaceShippingInformationUploadFromUpload(request: ExcludeMarketplaceShippingInformationUploadFromUploadCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Physically print the stored PDF files of marketplace external documents using the configured PDF print template set."
PrintMarketplaceExternalDocument(request: PrintMarketplaceExternalDocumentCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace order cancellation request uploads."
ResetMarketplaceOrderCancellationRequestUploadCounter(request: ResetMarketplaceOrderCancellationRequestUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace order cancellation uploads."
ResetMarketplaceOrderCancellationUploadCounter(request: ResetMarketplaceOrderCancellationUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace payment uploads."
ResetMarketplacePaymentUploadCounter(request: ResetMarketplacePaymentUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace return uploads."
ResetMarketplaceReturnUploadCounter(request: ResetMarketplaceReturnUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Reset the upload counter for marketplace shipping information uploads."
ResetMarketplaceShippingInformationUploadCounter(request: ResetMarketplaceShippingInformationUploadCounterCommandRequestInput!): Boolean! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Activates a language in the system"
ActivateLanguage(request: ActivateLanguageCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "system.config.write" ]) @cost(weight: "10")
"Deactivates a language in the system"
DeactivateLanguage(request: DeactivateLanguageCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "system.config.write" ]) @cost(weight: "10")
"Creates a new tax class in the system"
CreateTaxClass(request: CreateTaxClassCommandRequestInput!): ID! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Creates a new tax code in the system"
CreateTaxCode(request: CreateTaxCodeCommandRequestInput!): ID! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Deletes an existing tax class"
DeleteTaxClass(request: DeleteTaxClassCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Deletes an existing tax code"
DeleteTaxCode(request: DeleteTaxCodeCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Updates an existing tax class"
UpdateTaxClass(request: UpdateTaxClassCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Updates an existing tax code"
UpdateTaxCode(request: UpdateTaxCodeCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Batch saves the entire tax configuration in a single transaction. Zones with an Id are updated, zones without an Id are created, and zones in the database but not in the list are deleted."
SaveTaxConfiguration(request: SaveTaxConfigurationCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "taxes.write" ]) @cost(weight: "10")
"Deletes an existing payment."
DeletePayment(request: DeletePaymentCommandRequestInput!): Boolean! @authorize(roles: [ "payments.write", "system.all" ]) @cost(weight: "10")
"Cancel a sales invoice correction"
CancelSalesInvoiceCorrection(request: CancelSalesInvoiceCorrectionCommandRequestInput!): Boolean! @authorize(roles: [ "salesinvoicecorrections.write", "system.all" ]) @cost(weight: "10")
"Create a new sales invoice correction from an existing invoice"
CreateSalesInvoiceCorrection(request: CreateSalesInvoiceCorrectionCommandRequestInput!): CreateSalesInvoiceCorrectionCommandResponse! @authorize(roles: [ "salesinvoicecorrections.write", "system.all" ]) @cost(weight: "10")
"Cancel a sales invoice"
CancelSalesInvoice(request: CancelSalesInvoiceCommandRequestInput!): Boolean! @authorize(roles: [ "salesinvoices.write", "system.all" ]) @cost(weight: "10")
"Create a new sales invoice for a salesorder"
CreateSalesInvoice(request: CreateSalesInvoiceCommandRequestInput!): CreateSalesInvoiceCommandResponse! @authorize(roles: [ "salesinvoices.write", "system.all" ]) @cost(weight: "10")
"Recalculate prices, discounts, and taxes for a sales entity from a client-supplied state without persisting it."
CalculateSalesEntity(request: CalculateSalesEntityCommandRequestInput!): CalculateSalesEntityCommandResponse! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Calculate prices, discounts, and taxes for a sales order without persisting it."
CalculateSalesOrder(request: CalculateSalesOrderCommandRequestInput!): CalculateSalesOrderCommandResponse! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Creates a new sales order."
CreateSalesOrder(request: CreateSalesOrderCommandRequestInput!): CreateSalesOrderCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Marks a given sales order as completely paid by creating a payment with the open amount of the sales order."
MarkSalesOrderAsPaid(request: MarkSalesOrderAsPaidCommandRequestInput!): MarkSalesOrderAsPaidCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing sales order."
UpdateSalesOrder(request: UpdateSalesOrderCommandRequestInput!): UpdateSalesOrderCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Cancel a sales quotation"
CancelSalesQuotation(request: CancelSalesQuotationCommandRequestInput!): Boolean! @authorize(roles: [ "salesquotations.write", "system.all" ]) @cost(weight: "10")
"Create a new sales order for a sales quotation"
CreateSalesOrderFromSalesQuotation(request: CreateSalesOrderFromSalesQuotationCommandRequestInput!): CreateSalesOrderFromSalesQuotationCommandResponse! @authorize(roles: [ "salesorders.write", "system.all" ]) @cost(weight: "10")
"Creates a new sales quotation."
CreateSalesQuotation(request: CreateSalesQuotationCommandRequestInput!): CreateSalesQuotationCommandResponse! @authorize(roles: [ "salesquotations.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing sales quotation."
UpdateSalesQuotation(request: UpdateSalesQuotationCommandRequestInput!): UpdateSalesQuotationCommandResponse! @authorize(roles: [ "salesquotations.write", "system.all" ]) @cost(weight: "10")
"Modifies an existing Package Weight"
ChangePackageWeight(request: ChangePackageWeightCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Delivers an existing Package"
CreateDeliverPackage(request: CreateDeliverPackageCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Activates a bin location, making it available for operations."
ActivateBinLocation(request: ActivateBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Creates a new bin location in a warehouse."
CreateBinLocation(request: CreateBinLocationCommandRequestInput!): CreateBinLocationCommandResponse! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Deactivates a bin location, making it unavailable for operations."
DeactivateBinLocation(request: DeactivateBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Deletes a bin location from the warehouse."
DeleteBinLocation(request: DeleteBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Locks a bin location, preventing stock movements."
LockBinLocation(request: LockBinLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Locks a bin location for available stock, preventing it from being used for stock allocation."
LockBinLocationForAvailableStock(request: LockBinLocationForAvailableStockCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Unlocks a bin location for available stock, allowing it to be used for stock allocation."
UnlockBinLocationForAvailableStock(request: UnlockBinLocationForAvailableStockCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Updates metadata of an existing bin location (name, type, sort order)."
UpdateBinLocationMetadata(request: UpdateBinLocationMetadataCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Adds bin locations to a warehouse zone."
AddBinLocationsToZone(request: AddBinLocationsToZoneCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Creates a new warehouse zone."
CreateWarehouseZone(request: CreateWarehouseZoneCommandRequestInput!): CreateWarehouseZoneCommandResponse! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Deletes a warehouse zone."
DeleteWarehouseZone(request: DeleteWarehouseZoneCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Removes bin locations from a warehouse zone."
RemoveBinLocationsFromZone(request: RemoveBinLocationsFromZoneCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Updates mutable metadata (code, description, type) of an existing warehouse zone."
UpdateWarehouseZoneMetadata(request: UpdateWarehouseZoneMetadataCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Reassigns a shipping box to a different bin location (Rule SB-5)."
AssignShippingBoxToLocation(request: AssignShippingBoxToLocationCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Creates a new shipping box within a warehouse."
CreateShippingBox(request: CreateShippingBoxCommandRequestInput!): CreateShippingBoxCommandResponse! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Permanently deletes a shipping box and all its attributes (Rule SB-8)."
DeleteShippingBox(request: DeleteShippingBoxCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Updates mutable metadata of an existing shipping box. TypeId is immutable (Rule SB-3)."
UpdateShippingBoxMetadata(request: UpdateShippingBoxMetadataCommandRequestInput!): Boolean! @authorize(roles: [ "inventory.write", "system.all" ]) @cost(weight: "10")
"Configures a worker sync (interval and configuration values)."
ConfigureWorkerSync(request: ConfigureWorkerSyncCommandRequestInput!): WorkerSyncItem! @authorize(roles: [ "system.all", "system.worker.write" ]) @cost(weight: "10")
"Controls a worker sync (start, stop or restart)."
ControlWorkerSync(request: ControlWorkerSyncCommandRequestInput!): Boolean! @authorize(roles: [ "system.all", "system.worker.write" ]) @cost(weight: "10")
}
"Defines negative stock settings for a specific platform. This structure enables individual configuration of negative stock handling per platform (e.g., eBay, Amazon), allowing overselling for specific marketplaces when the global AllowNegativeStock is enabled."
type NegativeStockPlatform {
"Key of the platform that identifies the specific marketplace or platform (e.g., eBay, Amazon) for which this negative stock setting applies."
platformId: ID!
"Determines if negative stock is allowed for this platform. When true, orders can be accepted even when the item is out of stock on this specific marketplace."
isNegativeStockAllowed: Boolean!
}
"Defines negative stock settings for a specific sales channel. This structure enables individual configuration of negative stock handling per sales channel, allowing overselling for specific online shops when the global AllowNegativeStock is enabled."
type NegativeStockSalesChannel {
"Key of the sales channel that identifies the specific shop or sales channel for which this negative stock setting applies."
salesChannelId: ID!
"Determines if negative stock is allowed for this sales channel. When true, orders can be accepted even when the item is out of stock in this specific channel."
isNegativeStockAllowed: Boolean!
}
"Single Row of the order data query"
type OrderDataItem {
"The Package ID of the Order"
id: String!
"Total weight in kg (range 0-10000)"
totalWeight: Decimal
"Order ID"
orderId: ID!
"Customer ID"
customerId: ID!
"Company ID"
companyId: ID!
"Warehouse ID"
warehouseId: ID!
"Shipping address"
shippingAddress: ShippingAddress!
"Company address"
companyAddress: CompanyAddress!
"Warehouse address"
warehouseAddress: WarehouseAddress!
"List of delivery notes"
deliveryNotes: [DeliveryNoteItem!]!
"List of package content items"
content: [PackageContent!]!
}
"Represents a package content item"
type PackageContent {
"Item ID"
id: ID!
"Item number"
number: String!
"Content type (e.g. item, carton, openPosition)"
contentType: String!
"Amount of the item in the package"
amount: Decimal!
"Shipping Weight in kg (range: 0-10000)"
weight: Decimal
}
"Information about pagination in a connection."
type PageInfo {
"Indicates whether more edges exist following the set defined by the clients arguments."
hasNextPage: Int!
"Indicates whether more edges exist prior the set defined by the clients arguments."
hasPreviousPage: Int!
"When paginating backwards, the cursor to continue."
startCursor: String
"When paginating forwards, the cursor to continue."
endCursor: String
}
"Single row of the payment methods overview table"
type PaymentMethod {
"Unique identifier of the payment method"
id: ID!
"Name of the payment method"
name: String!
"G\/L account associated with the payment method"
generalLedgerAccount: String!
"Indicates whether the payment method is active"
isActive: Boolean!
"Indicates whether this is the default payment method"
isDefault: Boolean!
"Indicates whether the payment method is a debit type"
isDebit: Boolean!
"Indicates whether dunning is active for this payment method"
isDunningActive: Boolean!
"Indicates whether shipping is allowed before payment is received"
canShipBeforePayment: Boolean!
"Number of days for cash discount"
cashDiscountDays: Int!
"Value of the cash discount"
cashDiscountValue: Decimal!
"Payment option associated with the payment method"
paymentOption: String!
}
"A pick list with its positions"
type PickList {
"Pick list ID"
id: ID!
"Pick list number"
pickListNumber: String!
"Pick list status value"
status: Int!
"Id of the Warehouse"
warehouseId: ID!
"All positions sorted in pick order"
positions: [PickListPosition!]!
}
"A pick list position"
type PickListPosition {
"Position ID"
positionId: ID!
"Item ID"
itemId: ID!
"Item number (cArtNr)"
itemNumber: String!
"Target quantity"
quantity: Decimal!
"Bin location ID"
binLocationId: ID!
"Bin location name"
binLocationName: String!
"Position status value"
positionStatus: Int!
"Last status change timestamp"
processingTimestamp: DateTime
}
"Defines a platform-specific description of an item. This enables different descriptions for various output platforms like print or other non-sales platforms."
type PlatformDescription {
"Unique key of the platform for which this description is intended (e.g., print, labels)."
platformId: ID!
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the platform-specific description data with all relevant texts and SEO information."
descriptionData: DescriptionData!
}
type PlatformImages {
"Unique ID to identify a platform."
platformId: ID!
"List of images assigned to the platform."
images: [ItemImage!]!
}
"Single row of product group information."
type ProductGroupsListItem {
"Product group id"
id: ID!
"The name of the product group"
name: String
}
"A production item."
type ProductionItem {
"The ID of this production item."
id: ID!
"The ID of the item underlying this production item."
itemId: ID!
"Defines the type of lot size configuration for this production item."
lotType: LotType!
"Defines the type of manufacturing of this production item."
productionType: ProductionType!
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateKey: ID
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no item label for each produced unit should be printed on completion."
singleItemLabelTemplateKey: ID
"The timestamp when this production item was created."
createDate: DateTime!
"The timestamp when this production item was last modified."
updateDate: DateTime!
"The ID of the user who last modified this production item, or NULL if this production item has not been modified yet."
updateUserId: ID
}
"A production order."
type ProductionOrder {
"The ID of the production order."
id: ID!
"The ID of the production item to be produced by this production order."
productionItemId: ID!
"The ID of the bill of material used to produce the production item."
billOfMaterialId: ID!
"The ID of the disposition from which the production order originates."
dispositionId: ID
"Planned number of lots to be produced."
lotCount: Int!
"Planned size of the lots to be produced."
lotSize: Decimal!
"Planned total quantity to be produced."
targetTotalQuantity: Decimal!
"Actual total quantity produced."
actualQuantity: Decimal!
"Indicates whether it is allowed for this order to have a total quantity below the lot size (true) or not (false)."
isTargetTotalQuantityBelowLotSizeAllowed: Boolean!
"Progress of the production order."
progress: Decimal!
"Planned start time of the production order."
targetStartTimestamp: DateTime
"Planned completion time of the production order."
targetCompletionTimestamp: DateTime
"Actual (reported) start time of the production order."
actualStartTimestamp: DateTime
"Actual (reported) completion time of the production order."
actualCompletionTimestamp: DateTime
"The project number associated with the production order."
projectNumber: String!
"The reference number associated with the underlying order for this production order."
referenceNumber: String!
"The issue number of the production order."
issueNumber: String!
"The date when the production order was issued."
issueDate: DateTime!
"Additional note on the order that will be displayed during production."
notice: String!
"The timestamp when the production order was released."
releaseTimestamp: DateTime
"Planned delivery date."
deliveryTimestamp: DateTime
"The ID of the user who created the production order."
creationUserId: ID!
"The ID of the user who released the production order."
releaseUserId: ID
"The ID of the user who last modified the production order."
lastModificationUserId: ID!
"The timestamp of the last modification of the production order."
lastModificationTimestamp: DateTime!
"The ID type of the resource (workbench-types only) which is allowed to produce this production order."
resourceTypeId: ID
"The ID of the workbench resource onto which the production order was assigned."
workbenchResourceId: ID
}
type Query {
"Retrieves a bill of materials item by its ID."
QueryBillOfMaterialsItemById(id: ID!): BillOfMaterialsItem! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bill of materials items for a given bill of materials."
QueryBillOfMaterialsItemsByBillOfMaterialsId(billOfMaterialsId: ID!): [BillOfMaterialsItem!]! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bill of materials items for a given bill of materials operation."
QueryBillOfMaterialsItemsByBillOfMaterialsOperationId(billOfMaterialsOperationId: ID!): [BillOfMaterialsItem!]! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves a bill of materials operation by its ID."
QueryBillOfMaterialsOperationById(id: ID!): BillOfMaterialsOperation! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bill of materials operations for a given bill of materials."
QueryBillOfMaterialsOperationsByBillOfMaterialsId(billOfMaterialsId: ID!): [BillOfMaterialsOperation!]! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves a bill of materials by its ID."
QueryBillOfMaterialsById(id: ID!): BillOfMaterials! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all bills of materials for a given production item."
QueryBillsOfMaterialsByProductionItemId(productionItemId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BillOfMaterialsFilterInput @cost(weight: "10") order: [BillOfMaterialsSortInput!] @cost(weight: "10")): QueryBillsOfMaterialsByProductionItemIdConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a lot size by its ID."
QueryLotSizeById(id: ID!): LotSize! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all lot sizes for a given production item."
QueryLotSizesByProductionItemId(productionItemId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: LotSizeFilterInput @cost(weight: "10") order: [LotSizeSortInput!] @cost(weight: "10")): QueryLotSizesByProductionItemIdConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves all production items."
QueryProductionItems("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ProductionItemFilterInput @cost(weight: "10") order: [ProductionItemSortInput!] @cost(weight: "10")): QueryProductionItemsConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a production item by its ID."
QueryProductionItemById(id: ID!): ProductionItem! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves a production item by the ID of the underlying item."
QueryProductionItemByItemId(itemId: ID!): ProductionItem! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Retrieves all production orders."
QueryProductionOrders("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ProductionOrderFilterInput @cost(weight: "10") order: [ProductionOrderSortInput!] @cost(weight: "10")): QueryProductionOrdersConnection @authorize(roles: [ "pps.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a production order by its ID."
QueryProductionOrderById(id: ID!): ProductionOrder! @authorize(roles: [ "pps.read", "system.all" ]) @cost(weight: "10")
"Queries all resource categories"
QueryResourceCategories("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ResourceCategoryFilterInput @cost(weight: "10") order: [ResourceCategorySortInput!] @cost(weight: "10")): QueryResourceCategoriesConnection @authorize(roles: [ "resources.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Queries all workbench resource types"
QueryWorkbenchResourceTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WorkbenchResourceTypeFilterInput @cost(weight: "10") order: [WorkbenchResourceTypeSortInput!] @cost(weight: "10")): QueryWorkbenchResourceTypesConnection @authorize(roles: [ "resources.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Queries a single workbench resource type by its ID"
QueryWorkbenchResourceTypeById(id: ID!): WorkbenchResourceType! @authorize(roles: [ "resources.read", "system.all" ]) @cost(weight: "10")
"Queries all workbench resources."
QueryWorkbenchResources("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WorkbenchResourceFilterInput @cost(weight: "10") order: [WorkbenchResourceSortInput!] @cost(weight: "10")): QueryWorkbenchResourcesConnection @authorize(roles: [ "resources.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a single workbench resource by its ID"
QueryWorkbenchResourceById(id: ID!): WorkbenchResource! @authorize(roles: [ "resources.read", "system.all" ]) @cost(weight: "10")
"Delivers a single category"
GetCategoryById(categoryId: ID!): CategoryDetails! @authorize(roles: [ "items.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable overview list all categories"
QueryCategories("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CategoryListItemFilterInput @cost(weight: "10") order: [CategoryListItemSortInput!] @cost(weight: "10")): QueryCategoriesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all company settings"
QueryCompanies("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CompanyListItemFilterInput @cost(weight: "10") order: [CompanyListItemSortInput!] @cost(weight: "10")): QueryCompaniesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a single company"
GetCompanyById(companyId: ID!): CompanyDetailsItem! @authorize(roles: [ "items.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable list of all custom fields metadata for a specific entity type"
QueryCustomFields("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomFieldListItemFilterInput @cost(weight: "10") order: [CustomFieldListItemSortInput!] @cost(weight: "10")): QueryCustomFieldsConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list all items with optional search"
QueryItems(searchTerm: String searchOperator: SearchOperator searchField: [ItemSearchField!] extendedFilter: String "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ItemListItemFilterInput @cost(weight: "10") order: [ItemListItemSortInput!] @cost(weight: "10")): QueryItemsConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves item suppliers for a specific item"
GetItemSuppliersById(id: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ItemSupplierListItemFilterInput @cost(weight: "10") order: [ItemSupplierListItemSortInput!] @cost(weight: "10")): GetItemSuppliersByIdConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list all items with optional search"
QueryItemTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ItemTypeListItemFilterInput @cost(weight: "10") order: [ItemTypeListItemSortInput!] @cost(weight: "10")): QueryItemTypesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves a single article by its ID including all sub-elements"
GetItemById(id: ID!): ItemdetailsItem! @authorize(roles: [ "items.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable overview list all manufacturers"
QueryManufacturers("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ManufacturerListItemFilterInput @cost(weight: "10") order: [ManufacturerListItemSortInput!] @cost(weight: "10")): QueryManufacturersConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of all product groups"
QueryProductGroups("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ProductGroupsListItemFilterInput @cost(weight: "10") order: [ProductGroupsListItemSortInput!] @cost(weight: "10")): QueryProductGroupsConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of all shipping classes"
QueryShippingClasses("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingClassListItemFilterInput @cost(weight: "10") order: [ShippingClassListItemSortInput!] @cost(weight: "10")): QueryShippingClassesConnection @authorize(roles: [ "items.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a single customer by its id"
GetCustomerById(customerId: ID!): Customer! @authorize(roles: [ "customers.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable overview list of all customer categories"
QueryCustomerCategories("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomerCategoryFilterInput @cost(weight: "10") order: [CustomerCategorySortInput!] @cost(weight: "10")): QueryCustomerCategoriesConnection @authorize(roles: [ "customers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a querable overview list of all customer groups"
QueryCustomerGroups("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomerGroupFilterInput @cost(weight: "10") order: [CustomerGroupSortInput!] @cost(weight: "10")): QueryCustomerGroupsConnection @authorize(roles: [ "customers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all customers with optional search"
QueryCustomers(searchTerm: String searchOperator: CustomerSearchOperator searchField: [CustomerSearchField!] "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CustomerListItemFilterInput @cost(weight: "10") order: [CustomerListItemSortInput!] @cost(weight: "10")): QueryCustomersConnection @authorize(roles: [ "customers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceInvoiceCorrectionPdfUploadListItem"
QueryMarketplaceInvoiceCorrectionPdfUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceInvoiceCorrectionPdfUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceInvoiceCorrectionPdfUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceInvoiceCorrectionPdfUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of invoice correction upload line items for the given order."
QueryMarketplaceInvoiceCorrectionUploadLineItem(orderId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String order: [MarketplaceInvoiceCorrectionUploadLineItemListItemSortInput!] @cost(weight: "10")): QueryMarketplaceInvoiceCorrectionUploadLineItemConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceInvoiceCorrectionUploadListItem"
QueryMarketplaceInvoiceCorrectionUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceInvoiceCorrectionUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceInvoiceCorrectionUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceInvoiceCorrectionUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceInvoicePdfUploadListItem"
QueryMarketplaceInvoicePdfUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceInvoicePdfUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceInvoicePdfUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceInvoicePdfUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of notification details for the given notification."
QueryMarketplaceNotificationDetail(notificationId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String order: [MarketplaceNotificationDetailListItemSortInput!] @cost(weight: "10")): QueryMarketplaceNotificationDetailConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceNotificationListItem"
QueryMarketplaceNotification("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceNotificationListItemFilterInput @cost(weight: "10") order: [MarketplaceNotificationListItemSortInput!] @cost(weight: "10")): QueryMarketplaceNotificationConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of offer failures for the given offer."
QueryMarketplaceOfferFailure(offerId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String order: [MarketplaceOfferFailureListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOfferFailureConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceOfferListItem"
QueryMarketplaceOffer("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceOfferListItemFilterInput @cost(weight: "10") order: [MarketplaceOfferListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOfferConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceExternalDocumentListItem"
QueryMarketplaceExternalDocument("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceExternalDocumentListItemFilterInput @cost(weight: "10") order: [MarketplaceExternalDocumentListItemSortInput!] @cost(weight: "10")): QueryMarketplaceExternalDocumentConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceOrderCancellationRequestUploadListItem"
QueryMarketplaceOrderCancellationRequestUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceOrderCancellationRequestUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceOrderCancellationRequestUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOrderCancellationRequestUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceOrderCancellationUploadListItem"
QueryMarketplaceOrderCancellationUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceOrderCancellationUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceOrderCancellationUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceOrderCancellationUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplacePaymentUploadListItem"
QueryMarketplacePaymentUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplacePaymentUploadListItemFilterInput @cost(weight: "10") order: [MarketplacePaymentUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplacePaymentUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable list of return upload line items for the given order."
QueryMarketplaceReturnUploadLineItem(orderId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String order: [MarketplaceReturnUploadLineItemListItemSortInput!] @cost(weight: "10")): QueryMarketplaceReturnUploadLineItemConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceReturnUploadListItem"
QueryMarketplaceReturnUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceReturnUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceReturnUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceReturnUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all MarketplaceShippingInformationUploadListItem"
QueryMarketplaceShippingInformationUpload("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceShippingInformationUploadListItemFilterInput @cost(weight: "10") order: [MarketplaceShippingInformationUploadListItemSortInput!] @cost(weight: "10")): QueryMarketplaceShippingInformationUploadConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves detail sub-elements for a single marketplace seller by SCX shop ID."
GetMarketplaceSellerDetails(id: ID!): MarketplaceSellerDetailsItem! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Retrieves all marketplace sellers including all sub-elements (price types, shipping rules, metadata, supported marketplaces)."
GetAllMarketplaceSellersWithDetails: MarketplaceSellerDetailsListItem! @authorize(roles: [ "system.all" ]) @cost(weight: "10")
"Lists all marketplace sellers."
QueryMarketplaceSeller("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: MarketplaceSellerListItemFilterInput @cost(weight: "10") order: [MarketplaceSellerListItemSortInput!] @cost(weight: "10")): QueryMarketplaceSellerConnection @authorize(roles: [ "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup shipping methods"
QueryShippingMethods("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingMethodLookupItemFilterInput @cost(weight: "10") order: [ShippingMethodLookupItemSortInput!] @cost(weight: "10")): QueryShippingMethodsConnection @authorize(roles: [ "system.all", "system.config.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Definition to query countries"
QueryCountries("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String): QueryCountriesConnection @authorize(roles: [ "system.all", "system.config.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Query for activated languages"
QueryLanguages("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String): QueryLanguagesConnection @authorize(roles: [ "system.all", "system.config.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Query for tax classes"
QueryTaxClasses("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: TaxClassFilterInput @cost(weight: "10") order: [TaxClassSortInput!] @cost(weight: "10")): QueryTaxClassesConnection @authorize(roles: [ "system.all", "taxes.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns a list of all tax classes and their calculated tax rates for the given parameters."
ListTaxClassesWithTaxRates(companyId: ID! departureCountryIso: String! taxReference: TaxDomainTaxReference shipmentAddressVatId: String shipmentAddressCountryIso: String shipmentAddressState: String billingAddressVatId: String billingAddressCountryIso: String billingAddressState: String specialTaxTreatment: TaxDomainSpecialTaxTreatment taxClasses: [ID]): [TaxClassWithTaxRate!]! @authorize(roles: [ "system.all", "taxes.read" ]) @cost(weight: "10")
"Query for tax codes"
QueryTaxCodes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: TaxCodeFilterInput @cost(weight: "10") order: [TaxCodeSortInput!] @cost(weight: "10")): QueryTaxCodesConnection @authorize(roles: [ "system.all", "taxes.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Query for tax zones with nested country assignments, tax rates, and rate key assignments."
QueryTaxZones("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: TaxZoneFilterInput @cost(weight: "10") order: [TaxZoneSortInput!] @cost(weight: "10")): QueryTaxZonesConnection @authorize(roles: [ "system.all", "taxes.read" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers all sales channels with the available endpoints."
QueryDiscoverableSalesChannels: [DiscoverableSalesChannel!]! @authorize(roles: [ "saleschannels.read", "system.all" ]) @cost(weight: "10")
"Delivers a single sales channel with the available endpoints by its id."
QueryDiscoverableSalesChannelById(salesChannelId: String!): DiscoverableSalesChannel! @authorize(roles: [ "saleschannels.read", "system.all" ]) @cost(weight: "10")
"Delivers a querable overview list all currencies"
QueryCurrencies("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: CurrencyFilterInput @cost(weight: "10") order: [CurrencySortInput!] @cost(weight: "10")): QueryCurrenciesConnection @authorize(roles: [ "currencies.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all external documents"
QueryExternalDocumentsInternal(fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ExternalDocumentInternalFilterInput @cost(weight: "10") order: [ExternalDocumentInternalSortInput!] @cost(weight: "10")): QueryExternalDocumentsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
QueryExternalDocumentLineItemsInternal(externalDocumentTransactionId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ExternalDocumentLineItemInternalFilterInput @cost(weight: "10") order: [ExternalDocumentLineItemInternalSortInput!] @cost(weight: "10")): QueryExternalDocumentLineItemsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice corrections"
QuerySalesInvoiceCorrectionsInternal(depositAttributeName: String! fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCorrectionInternalFilterInput @cost(weight: "10") order: [SalesInvoiceCorrectionInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceCorrectionsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice correction line items"
QuerySalesInvoiceCorrectionLineItemsInternal(salesInvoiceCorrectionId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCorrectionLineItemInternalFilterInput @cost(weight: "10") order: [SalesInvoiceCorrectionLineItemInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceCorrectionLineItemsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales invoices"
QuerySalesInvoicesInternal(depositAttributeName: String! fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceInternalFilterInput @cost(weight: "10") order: [SalesInvoiceInternalSortInput!] @cost(weight: "10")): QuerySalesInvoicesInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice positions"
QuerySalesInvoiceLineItemsInternal(salesInvoiceId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceLineItemInternalFilterInput @cost(weight: "10") order: [SalesInvoiceLineItemInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceLineItemsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice cancellations"
QuerySalesInvoiceCancellationsInternal(depositAttributeName: String! fromDate: DateTime! toDate: DateTime! companyId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCancellationInternalFilterInput @cost(weight: "10") order: [SalesInvoiceCancellationInternalSortInput!] @cost(weight: "10")): QuerySalesInvoiceCancellationsInternalConnection @authorize(roles: [ "jera.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all payment methods"
QueryPaymentMethods("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: PaymentMethodFilterInput @cost(weight: "10") order: [PaymentMethodSortInput!] @cost(weight: "10")): QueryPaymentMethodsConnection @authorize(roles: [ "paymentmethods.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales channels."
QuerySalesChannels("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesChannelFilterInput @cost(weight: "10") order: [SalesChannelSortInput!] @cost(weight: "10")): QuerySalesChannelsConnection @authorize(roles: [ "saleschannels.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all invoice corrections."
QuerySalesInvoiceCorrections("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCorrectionListItemFilterInput @cost(weight: "10") order: [SalesInvoiceCorrectionListItemSortInput!] @cost(weight: "10")): QuerySalesInvoiceCorrectionsConnection @authorize(roles: [ "salesinvoicecorrections.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales invoice cancellation reasons"
QuerySalesInvoiceCancellationReasons("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceCancellationReasonFilterInput @cost(weight: "10") order: [SalesInvoiceCancellationReasonSortInput!] @cost(weight: "10")): QuerySalesInvoiceCancellationReasonsConnection @authorize(roles: [ "salesinvoices.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all sales invoices."
QuerySalesInvoices("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesInvoiceListItemFilterInput @cost(weight: "10") order: [SalesInvoiceListItemSortInput!] @cost(weight: "10")): QuerySalesInvoicesConnection @authorize(roles: [ "salesinvoices.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns an empty sales order with default values without persisting it. This is equivalent to opening a new sales order dialog in the UI."
GetEmptySalesOrder: EmptySalesOrder! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Returns a list of price details for the requested items."
ListItemPriceDetails(itemIds: [ID]! customerId: ID! currencyFactor: Decimal!): [ItemPriceDetails!]! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Delivers a single sales order by its id"
GetSalesOrderById(id: ID!): SalesOrder! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Delivers a querable overview list all sales orders"
QuerySalesOrders("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesOrderListItemFilterInput @cost(weight: "10") order: [SalesOrderListItemSortInput!] @cost(weight: "10")): QuerySalesOrdersConnection @authorize(roles: [ "salesorders.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns the shipping eligibility information for a specific sales order."
GetSalesOrderShippingEligibilityById(salesOrderId: ID!): SalesOrderShippingEligibility! @authorize(roles: [ "salesorders.read", "system.all" ]) @cost(weight: "10")
"Delivers a single sales quotation by its id"
GetSalesQuotationById(id: ID!): SalesQuotation! @authorize(roles: [ "salesquotations.read", "system.all" ]) @cost(weight: "10")
"Delivers a querable overview list all sales quotations"
QuerySalesQuotations("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SalesQuotationListItemFilterInput @cost(weight: "10") order: [SalesQuotationListItemSortInput!] @cost(weight: "10")): QuerySalesQuotationsConnection @authorize(roles: [ "salesquotations.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable overview list of all suppliers."
QuerySuppliers("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SupplierFilterInput @cost(weight: "10") order: [SupplierSortInput!] @cost(weight: "10")): QuerySuppliersConnection @authorize(roles: [ "suppliers.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Retrieves pick lists with positions for a warehouse"
QueryPicklists("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: PickListFilterInput @cost(weight: "10") order: [PickListSortInput!] @cost(weight: "10")): QueryPicklistsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers order data for a specific package"
QueryOrderData(packageId: String!): OrderDataItem! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Delivers a queryable to lookup batch"
QueryBatches("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BatchListItemFilterInput @cost(weight: "10") order: [BatchListItemSortInput!] @cost(weight: "10")): QueryBatchesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup best before dates (MHDs)"
QueryBestBeforeDates("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BestBeforeListItemFilterInput @cost(weight: "10") order: [BestBeforeListItemSortInput!] @cost(weight: "10")): QueryBestBeforeDatesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup stock reservations"
QueryStockReservations("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: StockReservationListItemFilterInput @cost(weight: "10") order: [StockReservationListItemSortInput!] @cost(weight: "10")): QueryStockReservationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup serial numbers"
QuerySerialNumbers("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: SerialNumberListItemFilterInput @cost(weight: "10") order: [SerialNumberListItemSortInput!] @cost(weight: "10")): QuerySerialNumbersConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable for stock items"
QueryStockItem("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: QueryStockItemFilterInput @cost(weight: "10") order: [QueryStockItemSortInput!] @cost(weight: "10")): QueryStockItemConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns stock entries for a warehouse filtered by bin location\/article with optional batch, serial, and MHD filters."
QueryStock(warehouseId: ID! binLocationId: ID articleId: ID batchNumber: String serialNumber: String bestBeforeDateFrom: DateTime bestBeforeDateTo: DateTime "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: QueryStockFilterInput @cost(weight: "10") order: [QueryStockSortInput!] @cost(weight: "10")): QueryStockConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns all valid employee tracking activity types excluding inventory types."
QueryActivityTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ActivityTypeFilterInput @cost(weight: "10") order: [ActivityTypeSortInput!] @cost(weight: "10")): QueryActivityTypesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns pick activity per bin location, filterable by time period."
QueryBinLocationPickHeatmap(startDate: DateTime endDate: DateTime "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BinLocationPickHeatmapItemFilterInput @cost(weight: "10") order: [BinLocationPickHeatmapItemSortInput!] @cost(weight: "10")): QueryBinLocationPickHeatmapConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns employee tracking rows for a warehouse, optionally filtered by activity type IDs."
QueryEmployeeLocations(warehouseId: ID! activityTypeIds: [Int!]! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: EmployeeLocationItemFilterInput @cost(weight: "10") order: [EmployeeLocationItemSortInput!] @cost(weight: "10")): QueryEmployeeLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns tracking data for a specific employee in a warehouse."
QueryEmployeeLocation(warehouseId: ID! userId: Int! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String): QueryEmployeeLocationConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns shipping boxes for a given warehouse with paging, sorting, and filtering support."
QueryShippingBoxes(warehouseId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingBoxListItemFilterInput @cost(weight: "10") order: [ShippingBoxListItemSortInput!] @cost(weight: "10")): QueryShippingBoxesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns the list of available shipping box types."
QueryShippingBoxTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ShippingBoxTypeFilterInput @cost(weight: "10") order: [ShippingBoxTypeSortInput!] @cost(weight: "10")): QueryShippingBoxTypesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns bin locations for a given warehouse with paging, sorting, and filtering support."
QueryBinLocations(warehouseId: ID! nameFilter: String statusFilter: Int typeFilter: Int "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BinLocationListItemFilterInput @cost(weight: "10") order: [BinLocationListItemSortInput!] @cost(weight: "10")): QueryBinLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns a single bin location by its ID."
GetBinLocationById(binLocationId: ID!): BinLocationListItem! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Returns occupancy fill factors for all bin locations in a warehouse."
QueryBinLocationOccupancy(warehouseId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: BinLocationOccupancyItemFilterInput @cost(weight: "10") order: [BinLocationOccupancyItemSortInput!] @cost(weight: "10")): QueryBinLocationOccupancyConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns all available bin location statuses."
GetBinLocationStatuses: [BinLocationStatusDto!]! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Returns all available bin location types."
GetBinLocationTypes: [BinLocationTypeDto!]! @authorize(roles: [ "inventory.read", "system.all" ]) @cost(weight: "10")
"Returns stock movement history for a warehouse with optional time, article, and bin location filters."
QueryStockMovementHistory(warehouseId: ID! startTime: DateTime endTime: DateTime article: String sourceBinLocation: String targetBinLocation: String "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: StockMovementHistoryItemFilterInput @cost(weight: "10") order: [StockMovementHistoryItemSortInput!] @cost(weight: "10")): QueryStockMovementHistoryConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns warehouse zones for a given warehouse with paging, sorting, and filtering support."
QueryWarehouseZones(warehouseId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WarehouseZoneListItemFilterInput @cost(weight: "10") order: [WarehouseZoneListItemSortInput!] @cost(weight: "10")): QueryWarehouseZonesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns bin locations assigned to a specific warehouse zone."
QueryZoneBinLocations(zoneId: ID! "Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ZoneBinLocationItemFilterInput @cost(weight: "10") order: [ZoneBinLocationItemSortInput!] @cost(weight: "10")): QueryZoneBinLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns the static list of available warehouse zone types."
QueryZoneTypes("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: ZoneTypeFilterInput @cost(weight: "10") order: [ZoneTypeSortInput!] @cost(weight: "10")): QueryZoneTypesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup storage locations"
QueryStorageLocations("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: StorageLocationListItemFilterInput @cost(weight: "10") order: [StorageLocationListItemSortInput!] @cost(weight: "10")): QueryStorageLocationsConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Delivers a queryable to lookup warehouses"
QueryWarehouses("Returns the first _n_ elements from the list." first: Int "Returns the elements in the list that come after the specified cursor." after: String "Returns the last _n_ elements from the list." last: Int "Returns the elements in the list that come before the specified cursor." before: String where: WarehouseListItemFilterInput @cost(weight: "10") order: [WarehouseListItemSortInput!] @cost(weight: "10")): QueryWarehousesConnection @authorize(roles: [ "inventory.read", "system.all" ]) @listSize(assumedSize: 500, slicingArguments: [ "first", "last" ], slicingArgumentDefaultValue: 200, sizedFields: [ "edges", "nodes" ], requireOneSlicingArgument: false) @cost(weight: "10")
"Returns the available syncs of the worker."
QueryWorkerSyncs: [WorkerSyncItem!]! @authorize(roles: [ "system.all", "system.worker.read" ]) @cost(weight: "10")
"Returns the status of one or more worker syncs."
QueryWorkerStatus(syncId: ID): [WorkerSyncStatus!]! @authorize(roles: [ "system.all", "system.worker.read" ]) @cost(weight: "10")
}
"A connection to a list of items."
type QueryActivityTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryActivityTypesEdge!]
"A flattened list of the nodes."
nodes: [ActivityType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryActivityTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ActivityType!
}
"A connection to a list of items."
type QueryBatchesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBatchesEdge!]
"A flattened list of the nodes."
nodes: [BatchListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBatchesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BatchListItem!
}
"A connection to a list of items."
type QueryBestBeforeDatesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBestBeforeDatesEdge!]
"A flattened list of the nodes."
nodes: [BestBeforeListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBestBeforeDatesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BestBeforeListItem!
}
"A connection to a list of items."
type QueryBillsOfMaterialsByProductionItemIdConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBillsOfMaterialsByProductionItemIdEdge!]
"A flattened list of the nodes."
nodes: [BillOfMaterials!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBillsOfMaterialsByProductionItemIdEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BillOfMaterials!
}
"A connection to a list of items."
type QueryBinLocationOccupancyConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBinLocationOccupancyEdge!]
"A flattened list of the nodes."
nodes: [BinLocationOccupancyItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBinLocationOccupancyEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BinLocationOccupancyItem!
}
"A connection to a list of items."
type QueryBinLocationPickHeatmapConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBinLocationPickHeatmapEdge!]
"A flattened list of the nodes."
nodes: [BinLocationPickHeatmapItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBinLocationPickHeatmapEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BinLocationPickHeatmapItem!
}
"A connection to a list of items."
type QueryBinLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryBinLocationsEdge!]
"A flattened list of the nodes."
nodes: [BinLocationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryBinLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: BinLocationListItem!
}
"A connection to a list of items."
type QueryCategoriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCategoriesEdge!]
"A flattened list of the nodes."
nodes: [CategoryListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCategoriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CategoryListItem!
}
"A connection to a list of items."
type QueryCompaniesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCompaniesEdge!]
"A flattened list of the nodes."
nodes: [CompanyListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCompaniesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CompanyListItem!
}
"A connection to a list of items."
type QueryCountriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCountriesEdge!]
"A flattened list of the nodes."
nodes: [CountryItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCountriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CountryItem!
}
"A connection to a list of items."
type QueryCurrenciesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCurrenciesEdge!]
"A flattened list of the nodes."
nodes: [Currency!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCurrenciesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: Currency!
}
"A connection to a list of items."
type QueryCustomFieldsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomFieldsEdge!]
"A flattened list of the nodes."
nodes: [CustomFieldListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomFieldsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomFieldListItem!
}
"A connection to a list of items."
type QueryCustomerCategoriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomerCategoriesEdge!]
"A flattened list of the nodes."
nodes: [CustomerCategory!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomerCategoriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomerCategory!
}
"A connection to a list of items."
type QueryCustomerGroupsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomerGroupsEdge!]
"A flattened list of the nodes."
nodes: [CustomerGroup!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomerGroupsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomerGroup!
}
"A connection to a list of items."
type QueryCustomersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryCustomersEdge!]
"A flattened list of the nodes."
nodes: [CustomerListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryCustomersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: CustomerListItem!
}
"A connection to a list of items."
type QueryEmployeeLocationConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryEmployeeLocationEdge!]
"A flattened list of the nodes."
nodes: [EmployeeLocationItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryEmployeeLocationEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: EmployeeLocationItem!
}
"A connection to a list of items."
type QueryEmployeeLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryEmployeeLocationsEdge!]
"A flattened list of the nodes."
nodes: [EmployeeLocationItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryEmployeeLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: EmployeeLocationItem!
}
"A connection to a list of items."
type QueryExternalDocumentLineItemsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryExternalDocumentLineItemsInternalEdge!]
"A flattened list of the nodes."
nodes: [ExternalDocumentLineItemInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryExternalDocumentLineItemsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ExternalDocumentLineItemInternal!
}
"A connection to a list of items."
type QueryExternalDocumentsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryExternalDocumentsInternalEdge!]
"A flattened list of the nodes."
nodes: [ExternalDocumentInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryExternalDocumentsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ExternalDocumentInternal!
}
"A connection to a list of items."
type QueryItemTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryItemTypesEdge!]
"A flattened list of the nodes."
nodes: [ItemTypeListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryItemTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ItemTypeListItem!
}
"A connection to a list of items."
type QueryItemsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryItemsEdge!]
"A flattened list of the nodes."
nodes: [ItemListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryItemsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ItemListItem!
}
"A connection to a list of items."
type QueryLanguagesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryLanguagesEdge!]
"A flattened list of the nodes."
nodes: [LanguageItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryLanguagesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: LanguageItem!
}
"A connection to a list of items."
type QueryLotSizesByProductionItemIdConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryLotSizesByProductionItemIdEdge!]
"A flattened list of the nodes."
nodes: [LotSize!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryLotSizesByProductionItemIdEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: LotSize!
}
"A connection to a list of items."
type QueryManufacturersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryManufacturersEdge!]
"A flattened list of the nodes."
nodes: [ManufacturerListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryManufacturersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ManufacturerListItem!
}
"A connection to a list of items."
type QueryMarketplaceExternalDocumentConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceExternalDocumentEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceExternalDocumentListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceExternalDocumentEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceExternalDocumentListItem!
}
"A connection to a list of items."
type QueryMarketplaceInvoiceCorrectionPdfUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceInvoiceCorrectionPdfUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceInvoiceCorrectionPdfUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceInvoiceCorrectionPdfUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceInvoiceCorrectionPdfUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceInvoiceCorrectionUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceInvoiceCorrectionUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceInvoiceCorrectionUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceInvoiceCorrectionUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceInvoiceCorrectionUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceInvoiceCorrectionUploadLineItemConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceInvoiceCorrectionUploadLineItemEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceInvoiceCorrectionUploadLineItemListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceInvoiceCorrectionUploadLineItemEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceInvoiceCorrectionUploadLineItemListItem!
}
"A connection to a list of items."
type QueryMarketplaceInvoicePdfUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceInvoicePdfUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceInvoicePdfUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceInvoicePdfUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceInvoicePdfUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceNotificationConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceNotificationEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceNotificationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"A connection to a list of items."
type QueryMarketplaceNotificationDetailConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceNotificationDetailEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceNotificationDetailListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceNotificationDetailEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceNotificationDetailListItem!
}
"An edge in a connection."
type QueryMarketplaceNotificationEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceNotificationListItem!
}
"A connection to a list of items."
type QueryMarketplaceOfferConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOfferEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOfferListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOfferEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOfferListItem!
}
"A connection to a list of items."
type QueryMarketplaceOfferFailureConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOfferFailureEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOfferFailureListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOfferFailureEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOfferFailureListItem!
}
"A connection to a list of items."
type QueryMarketplaceOrderCancellationRequestUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOrderCancellationRequestUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOrderCancellationRequestUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOrderCancellationRequestUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOrderCancellationRequestUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceOrderCancellationUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceOrderCancellationUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceOrderCancellationUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceOrderCancellationUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceOrderCancellationUploadListItem!
}
"A connection to a list of items."
type QueryMarketplacePaymentUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplacePaymentUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplacePaymentUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplacePaymentUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplacePaymentUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceReturnUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceReturnUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceReturnUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceReturnUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceReturnUploadListItem!
}
"A connection to a list of items."
type QueryMarketplaceReturnUploadLineItemConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceReturnUploadLineItemEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceReturnUploadLineItemListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceReturnUploadLineItemEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceReturnUploadLineItemListItem!
}
"A connection to a list of items."
type QueryMarketplaceSellerConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceSellerEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceSellerListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceSellerEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceSellerListItem!
}
"A connection to a list of items."
type QueryMarketplaceShippingInformationUploadConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryMarketplaceShippingInformationUploadEdge!]
"A flattened list of the nodes."
nodes: [MarketplaceShippingInformationUploadListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryMarketplaceShippingInformationUploadEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: MarketplaceShippingInformationUploadListItem!
}
"A connection to a list of items."
type QueryPaymentMethodsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryPaymentMethodsEdge!]
"A flattened list of the nodes."
nodes: [PaymentMethod!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryPaymentMethodsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: PaymentMethod!
}
"A connection to a list of items."
type QueryPicklistsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryPicklistsEdge!]
"A flattened list of the nodes."
nodes: [PickList!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryPicklistsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: PickList!
}
"A connection to a list of items."
type QueryProductGroupsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryProductGroupsEdge!]
"A flattened list of the nodes."
nodes: [ProductGroupsListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryProductGroupsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ProductGroupsListItem!
}
"A connection to a list of items."
type QueryProductionItemsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryProductionItemsEdge!]
"A flattened list of the nodes."
nodes: [ProductionItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryProductionItemsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ProductionItem!
}
"A connection to a list of items."
type QueryProductionOrdersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryProductionOrdersEdge!]
"A flattened list of the nodes."
nodes: [ProductionOrder!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryProductionOrdersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ProductionOrder!
}
"A connection to a list of items."
type QueryResourceCategoriesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryResourceCategoriesEdge!]
"A flattened list of the nodes."
nodes: [ResourceCategory!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryResourceCategoriesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ResourceCategory!
}
"A connection to a list of items."
type QuerySalesChannelsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesChannelsEdge!]
"A flattened list of the nodes."
nodes: [SalesChannel!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesChannelsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesChannel!
}
"A connection to a list of items."
type QuerySalesInvoiceCancellationReasonsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCancellationReasonsEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCancellationReason!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCancellationReasonsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCancellationReason!
}
"A connection to a list of items."
type QuerySalesInvoiceCancellationsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCancellationsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCancellationInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCancellationsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCancellationInternal!
}
"A connection to a list of items."
type QuerySalesInvoiceCorrectionLineItemsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCorrectionLineItemsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCorrectionLineItemInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCorrectionLineItemsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCorrectionLineItemInternal!
}
"A connection to a list of items."
type QuerySalesInvoiceCorrectionsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCorrectionsEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCorrectionListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCorrectionsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCorrectionListItem!
}
"A connection to a list of items."
type QuerySalesInvoiceCorrectionsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceCorrectionsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceCorrectionInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceCorrectionsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceCorrectionInternal!
}
"A connection to a list of items."
type QuerySalesInvoiceLineItemsInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoiceLineItemsInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceLineItemInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoiceLineItemsInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceLineItemInternal!
}
"A connection to a list of items."
type QuerySalesInvoicesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoicesEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoicesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceListItem!
}
"A connection to a list of items."
type QuerySalesInvoicesInternalConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesInvoicesInternalEdge!]
"A flattened list of the nodes."
nodes: [SalesInvoiceInternal!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesInvoicesInternalEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesInvoiceInternal!
}
"A connection to a list of items."
type QuerySalesOrdersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesOrdersEdge!]
"A flattened list of the nodes."
nodes: [SalesOrderListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesOrdersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesOrderListItem!
}
"A connection to a list of items."
type QuerySalesQuotationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySalesQuotationsEdge!]
"A flattened list of the nodes."
nodes: [SalesQuotationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySalesQuotationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SalesQuotationListItem!
}
"A connection to a list of items."
type QuerySerialNumbersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySerialNumbersEdge!]
"A flattened list of the nodes."
nodes: [SerialNumberListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySerialNumbersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: SerialNumberListItem!
}
"A connection to a list of items."
type QueryShippingBoxTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingBoxTypesEdge!]
"A flattened list of the nodes."
nodes: [ShippingBoxType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingBoxTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingBoxType!
}
"A connection to a list of items."
type QueryShippingBoxesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingBoxesEdge!]
"A flattened list of the nodes."
nodes: [ShippingBoxListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingBoxesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingBoxListItem!
}
"A connection to a list of items."
type QueryShippingClassesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingClassesEdge!]
"A flattened list of the nodes."
nodes: [ShippingClassListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingClassesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingClassListItem!
}
"A connection to a list of items."
type QueryShippingMethodsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryShippingMethodsEdge!]
"A flattened list of the nodes."
nodes: [ShippingMethodLookupItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryShippingMethodsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ShippingMethodLookupItem!
}
"Provides paged access to stock entries filtered by warehouse, bin location, or article."
type QueryStock {
"Unique identifier of the stock entry."
stockEntryId: ID!
"Warehouse that owns the stock entry."
warehouseId: ID!
"Bin location containing the stock entry."
binLocationId: ID!
"Article stored in the stock entry."
articleId: ID!
"Available quantity (fAnzahlAktuell)."
availableQuantity: Decimal!
"Quantity reserved for pick positions (fAnzahlReserviertPickpos)."
reservedQuantity: Decimal!
"Batch\/charge number, empty when not tracked."
batchNumber: String!
"Best-before date (MHD) if tracked."
bestBeforeDate: DateTime
"Serial number associated with the stock entry."
serialNumber: String!
}
"A connection to a list of items."
type QueryStockConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockEdge!]
"A flattened list of the nodes."
nodes: [QueryStock!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: QueryStock!
}
"Single Row of the serial number query"
type QueryStockItem {
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ID!
"Id of the item."
itemId: ID!
"Total quantity of this item at this storage location."
quantityTotal: Decimal!
"Comment1"
comment1: String!
"Comment2"
comment2: String!
}
"A connection to a list of items."
type QueryStockItemConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockItemEdge!]
"A flattened list of the nodes."
nodes: [QueryStockItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockItemEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: QueryStockItem!
}
"A connection to a list of items."
type QueryStockMovementHistoryConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockMovementHistoryEdge!]
"A flattened list of the nodes."
nodes: [StockMovementHistoryItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockMovementHistoryEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: StockMovementHistoryItem!
}
"A connection to a list of items."
type QueryStockReservationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStockReservationsEdge!]
"A flattened list of the nodes."
nodes: [StockReservationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStockReservationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: StockReservationListItem!
}
"A connection to a list of items."
type QueryStorageLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryStorageLocationsEdge!]
"A flattened list of the nodes."
nodes: [StorageLocationListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryStorageLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: StorageLocationListItem!
}
"A connection to a list of items."
type QuerySuppliersConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QuerySuppliersEdge!]
"A flattened list of the nodes."
nodes: [Supplier!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QuerySuppliersEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: Supplier!
}
"A connection to a list of items."
type QueryTaxClassesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryTaxClassesEdge!]
"A flattened list of the nodes."
nodes: [TaxClass!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryTaxClassesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: TaxClass!
}
"A connection to a list of items."
type QueryTaxCodesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryTaxCodesEdge!]
"A flattened list of the nodes."
nodes: [TaxCode!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryTaxCodesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: TaxCode!
}
"A connection to a list of items."
type QueryTaxZonesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryTaxZonesEdge!]
"A flattened list of the nodes."
nodes: [TaxZone!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryTaxZonesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: TaxZone!
}
"A connection to a list of items."
type QueryWarehouseZonesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWarehouseZonesEdge!]
"A flattened list of the nodes."
nodes: [WarehouseZoneListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWarehouseZonesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WarehouseZoneListItem!
}
"A connection to a list of items."
type QueryWarehousesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWarehousesEdge!]
"A flattened list of the nodes."
nodes: [WarehouseListItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWarehousesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WarehouseListItem!
}
"A connection to a list of items."
type QueryWorkbenchResourceTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWorkbenchResourceTypesEdge!]
"A flattened list of the nodes."
nodes: [WorkbenchResourceType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWorkbenchResourceTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WorkbenchResourceType!
}
"A connection to a list of items."
type QueryWorkbenchResourcesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryWorkbenchResourcesEdge!]
"A flattened list of the nodes."
nodes: [WorkbenchResource!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryWorkbenchResourcesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: WorkbenchResource!
}
"A connection to a list of items."
type QueryZoneBinLocationsConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryZoneBinLocationsEdge!]
"A flattened list of the nodes."
nodes: [ZoneBinLocationItem!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryZoneBinLocationsEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ZoneBinLocationItem!
}
"A connection to a list of items."
type QueryZoneTypesConnection {
"Information to aid in pagination."
pageInfo: PageInfo!
"A list of edges."
edges: [QueryZoneTypesEdge!]
"A flattened list of the nodes."
nodes: [ZoneType!]
"Identifies the total count of items in the connection."
totalCount: Int! @cost(weight: "10")
}
"An edge in a connection."
type QueryZoneTypesEdge {
"A cursor for use in pagination."
cursor: String!
"The item at the end of the edge."
node: ZoneType!
}
"Releases an existing production order. - Response"
type ReleaseProductionOrderCommandResponse {
"The result of the command, including the exact timestamp and the user who released the production order."
result: ReleaseProductionOrderCommandResult!
}
"Represents the result of releasing a production order."
type ReleaseProductionOrderCommandResult {
"The exact timestamp when the production order was released."
releaseTimestamp: DateTime!
"The ID of the user who released the production order."
releaseUserId: ID
}
"Represents a resource category"
type ResourceCategory {
"This resource category's unqiue ID."
id: ID!
"The resource category's name."
name: String!
"Specifies whether this resource category is visible to users."
isVisible: Boolean!
"Specifies whether this resource category is enabled for use."
isEnabled: Boolean!
}
"Single row of the sales channels overview table"
type SalesChannel {
"Unique identifier of the sales channel"
id: ID!
"Name of the sales channel"
name: String!
}
"Defines a sales channel-specific description of an item. This enables individual customization of item descriptions for specific sales channels or shops."
type SalesChannelDescription {
"Unique key of the sales channel or shop for which this description is intended."
salesChannelId: ID!
"ISO2 language code that determines the language for this sales channel-specific description."
languageIso: String!
"Contains the sales channel-specific description data with all relevant texts and SEO information."
descriptionData: DescriptionData!
}
type SalesChannelSurcharge {
"Id of the saleschannel"
salesChannelId: ID!
"Contains the surcharges for that saleschannel and customergroup"
surcharges: [CustomerGroupSurcharge!]!
}
"Invoice cancellation for M&A system"
type SalesInvoiceCancellationInternal {
"Sales order identifier"
salesOrderId: ID
"Sales invoice identifier"
salesInvoiceId: ID!
"Company identifier"
companyId: ID
"Customer identifier"
customerId: ID!
"Platform identifier"
platformId: ID
"Sales invoice number"
salesInvoiceNumber: String
"Sales invoice cancellation date"
salesInvoiceCancellationDate: DateTime
"External order number"
externalOrderNumber: String
"Sales order number"
salesOrderNumber: String
"Date when the order was created in the ERP system"
createdInErpDate: DateTime
"Tax setting"
taxSetting: Int!
"Currency ISO code"
currencyIso: String
"Currency conversion factor"
currencyFactor: Decimal!
"Departure country currency ISO code"
departureCountryCurrencyIso: String
"Departure country currency conversion factor"
departureCountryCurrencyFactor: Decimal!
"Service date"
serviceDate: DateTime
"Last shipping date"
lastShippingDate: DateTime
"Platform identifier"
platformName: String
"Shipment method identifier"
shippingMethodId: ID
"Value date"
valueDate: DateTime
"Customer VAT identifier"
customerVatIdNumber: String
"Sales invoice VAT identifier"
salesInvoiceVatIdNumber: String
"Departure country ISO code"
departureCountryIso: String
"Total gross amount"
totalGrossAmount: Decimal
"Total net amount"
totalNetAmount: Decimal
"Customer number"
salesInvoiceCustomerNumber: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Payment due date in days"
paymentDueDateInDays: Int!
"Payment status"
paymentStatus: Int
"Invoice payment method identifier"
invoicePaymentMethodId: ID
"Payment method identifier"
paymentMethodId: ID
"Payment method"
paymentMethodName: String
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: String
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: Decimal
"Shipment company name"
shipmentAddressCompany: String
"Shipment salutation"
shipmentAddressSalutation: String
"Shipment title"
shipmentAddressTitle: String
"Shipment first name"
shipmentAddressFirstName: String
"Shipment last name"
shipmentAddressLastName: String
"Shipment street address"
shipmentAddressStreet: String
"Shipment postal code"
shipmentAddressPostalCode: String
"Shipment city"
shipmentAddressCity: String
"Shipment country"
shipmentAddressCountry: String
"Shipment phone number"
shipmentAddressPhoneNumber: String
"Shipment fax number"
shipmentAddressFaxNumber: String
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment country ISO code"
shipmentAddressCountryIso: String
"Shipment VAT identifier"
shipmentAddressVatIdNumber: String
"Sales invoice company name"
billingAddressCompany: String
"Sales invoice salutation"
billingAddressSalutation: String
"Sales invoice title"
billingAddressTitle: String
"Sales invoice first name"
billingAddressFirstName: String
"Sales invoice last name"
billingAddressLastName: String
"Sales invoice street address"
billingAddressStreet: String
"Sales invoice postal code"
billingAddressPostalCode: String
"Sales invoice city"
billingAddressCity: String
"Sales invoice country"
billingAddressCountry: String
"Sales invoice phone number"
billingAddressPhoneNumber: String
"Sales invoice fax number"
billingAddressFaxNumber: String
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: String
"Sales invoice country ISO code"
billingAddressCountryIso: String
"Customer company name"
customerDefaultBillingAddressCompany: String
"Customer salutation"
customerDefaultBillingAddressSalutation: String
"Customer title"
customerDefaultBillingAddressTitle: String
"Customer first name"
customerDefaultBillingAddressFirstName: String
"Customer last name"
customerDefaultBillingAddressLastName: String
"Customer street address"
customerDefaultBillingAddressStreet: String
"Customer postal code"
customerDefaultBillingAddressPostalCode: String
"Customer city"
customerDefaultBillingAddressCity: String
"Customer country"
customerDefaultBillingAddressCountry: String
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: String
"Customer fax number"
customerDefaultBillingAddressFaxNumber: String
"Customer address country ISO code"
customerDefaultBillingAddressCountryIso: String
"Customer email address"
customerDefaultBillingAddressEmailAddress: String
"Customer address VAT identifier"
customerDefaultBillingAddressVatIdNumber: String
"Customer number"
customerNumber: String
"Customer group identifier"
customerGroupId: ID
"Customer payment due date in days"
customerPaymentDueDateInDays: Int
"Deposit information"
deposit: String
"Delivery note count for drop shipping"
dropShippingDeliveryNoteCount: Int!
}
"Single sales invoice cancellation reason"
type SalesInvoiceCancellationReason {
"Unique identifier of the sales invoice cancellation reason"
id: ID!
"Name of the cancellation reason"
name: String!
"Indicates whether a comment is required when using this cancellation reason"
isCommentRequired: Boolean!
}
"Credit note for M&A system"
type SalesInvoiceCorrectionInternal {
"Sales order identifier"
salesOrderId: ID
"Sales invoice correction identifier"
salesInvoiceCorrectionId: ID!
"Customer identifier"
customerId: ID!
"Company identifier"
companyId: ID!
"Sales invoice identifier"
salesInvoiceId: ID
"Platform identifier"
platformId: ID
"Cancelled sales invoice identifier"
cancelledSalesInvoiceId: ID
"Sales invoice payment method identifier"
salesInvoicePaymentMethodId: ID
"Sales invoice correction payment method identifier"
salesInvoiceCorrectionPaymentMethodId: ID
"Sales invoice correction number"
salesInvoiceCorrectionNumber: String
"Sales invoice correction date"
salesInvoiceCorrectionDate: DateTime!
"Sales invoice number"
salesInvoiceNumber: String
"Sales invoice date"
salesInvoiceDate: DateTime
"External order number"
externalOrderNumber: String
"Sales order number"
salesOrderNumber: String
"Date when the order was created in the ERP system"
createdInErpDate: DateTime
"Currency ISO code"
currencyIso: String
"Currency conversion factor"
currencyFactor: Decimal!
"Departure country currency ISO code"
departureCountryCurrencyIso: String
"Departure country currency conversion factor"
departureCountryCurrencyFactor: Decimal
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: String
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: Decimal
"Shipment type"
salesOrderShippingMethodId: ID
"Shipment type"
salesInvoiceShippingMethodId: ID
"Service date"
serviceDate: DateTime
"Delivery date"
deliveryDate: DateTime
"Total gross amount"
totalGrossAmount: Decimal!
"Sales order total gross amount"
salesOrderTotalGrossAmount: Decimal
"Sales order total net amount"
salesOrderTotalNetAmount: Decimal
"Platform identifier"
platformIdentifier: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Shipment company name"
shipmentCompany: String
"Shipment salutation"
shipmentSalutation: String
"Shipment title"
shipmentTitle: String
"Shipment first name"
shipmentFirstName: String
"Shipment last name"
shipmentLastName: String
"Shipment street address"
shipmentStreet: String
"Shipment postal code"
shipmentPostalCode: String
"Shipment city"
shipmentCity: String
"Shipment country"
shipmentCountry: String
"Shipment phone number"
shipmentPhoneNumber: String
"Shipment fax number"
shipmentFaxNumber: String
"Shipment additional address line"
shipmentAdditionalAddressLine: String
"Shipment country ISO code"
shipmentCountryIso: String
"Shipment VAT identifier"
shipmentVatIdNumber: String
"Sales order customer VAT identifier"
salesOrderCustomerVatIdNumber: String
"Sales invoice company name"
salesInvoiceCompany: String
"Sales invoice salutation"
salesInvoiceSalutation: String
"Sales invoice title"
salesInvoiceTitle: String
"Sales invoice first name"
salesInvoiceFirstName: String
"Sales invoice last name"
salesInvoiceLastName: String
"Sales invoice street address"
salesInvoiceStreet: String
"Sales invoice postal code"
salesInvoicePostalCode: String
"Sales invoice city"
salesInvoiceCity: String
"Sales invoice country"
salesInvoiceCountry: String
"Sales invoice phone number"
salesInvoicePhoneNumber: String
"Sales invoice fax number"
salesInvoiceFaxNumber: String
"Sales invoice additional address line"
salesInvoiceAdditionalAddressLine: String
"Sales invoice country ISO code"
salesInvoiceIso: String
"Customer company name"
customerCompany: String
"Customer salutation"
customerSalutation: String
"Customer title"
customerTitle: String
"Customer first name"
customerFirstName: String
"Customer last name"
customerLastName: String
"Customer street address"
customerStreet: String
"Customer postal code"
customerPostalCode: String
"Customer city"
customerCity: String
"Customer country"
customerCountry: String
"Customer phone number"
customerPhoneNumber: String
"Customer fax number"
customerFaxNumber: String
"Customer address country ISO code"
customerAddressIso: String
"Customer email address"
customerAddressEmailAddress: String
"Customer address VAT identifier"
customerAddressVatIdNumber: String
"Customer number"
customerNumber: String
"Customer group identifier"
customerGroupId: ID
"Customer payment due date in days"
customerPaymentDueDateInDays: Int
"Last shipping date"
lastShippingDate: DateTime
"Tax setting"
taxSetting: Int
"VAT identifier"
salesOrderVatIdNumber: String
"Departure country ISO code"
departureCountryIso: String
"Payment method"
paymentMethod: String
"Customer VAT identifier"
customerVatIdNumber: String
"VAT identifier"
salesInvoiceVatIdNumber: String
"Customer number"
salesInvoiceCustomerNumber: String
"Payment method name"
paymentMethodName: String
"Payment method"
paymentMethodId: ID
"Indicates if this is a storno (cancellation)"
isCancelled: String
"Deposit information"
deposit: String
"Sales invoice identifier"
salesInvoiceId2: ID
"Delivery note count"
dropShippingDeliveryNoteCount: Int!
}
"Invoice correction line item for M&A system"
type SalesInvoiceCorrectionLineItemInternal {
"Sales invoice correction line item identifier"
salesInvoiceCorrectionLineItemId: ID!
"Sales order line item identifier"
salesOrderLineItemId: ID
"Sales price gross"
salesPriceGross: Decimal!
"Discount amount"
discount: Decimal!
"Sales price net"
salesPriceNet: Decimal!
"Quantity"
quantity: Decimal!
"Sales invoice correction line item name"
lineItemName: String
"Stock keeping unit"
sku: String
"Value added tax rate"
taxRate: Decimal!
"Sales order item purchase price net"
salesOrderLineItemPurchasePriceNet: Decimal
"Item purchase price net"
itemPurchasePriceNet: Decimal
"Tax class identifier"
taxClassId: ID
"Line item type"
lineItemType: Byte
"Item identifier"
itemId: ID
"Sales order parts list identifier"
billOfMaterialsSalesOrderLineItemId: ID
"Parent item identifier"
parentItemId: ID
"Taric code"
taric: String
"Item weight"
itemWeight: Decimal
"Item volume"
itemVolume: Decimal
"Product group identifier"
productGroupId: ID
"Product group name"
productGroupName: String
"Warehouse identifier"
warehouseId: ID
"Sales invoice line item identifier"
salesInvoiceLineItemId: ID
}
"Single row of the invoice corrections overview table"
type SalesInvoiceCorrectionListItem {
"Unique identifier of the invoice correction"
id: ID!
"Entry number of the invoice correction"
salesInvoiceCorrectionNumber: String
"Entry number of the related invoice"
salesInvoiceNumber: String!
"Number of the related customer"
customerNumber: String
"Total gross amount of the invoice correction"
totalGrossAmount: Decimal!
"Total net amount of the invoice correction"
totalNetAmount: Decimal!
"The revenue account of the invoice correction"
revenueAccount: String
"Currency ISO code"
currencyIso: String
"Name of the customer group"
customerGroupName: String
"Date when the invoice correction was created"
salesInvoiceCorrectionDate: DateTime
"Date when the invoice correction was first printed"
printDate: DateTime
"Date when the invoice correction was first sent via e-mail"
mailDate: DateTime
"Comment of the related invoice"
salesInvoiceComment: String
"Date when the invoice correction was cancelled"
cancelledDate: DateTime
"Name of the user who cancelled the invoice correction"
cancellationUserName: String
"Cancellation reason"
cancellationReason: String
"Cancellation comment"
cancellationComment: String
"Short text of the invoice collection"
shortText: String
"Billing address company"
billingAddressCompany: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street"
billingAddressStreet: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address fax number"
billingAddressFax: String
"Billing address email address"
billingAddressEmailAddress: String
"Billing address additional company line"
billingAddressAdditionalCompanyLine: String
"Billing address additional address line"
billingAddressAdditionalAddressLine: String
"Billing address state"
billingAddressState: String
"Shipment address company"
shipmentAddressCompany: String
"Shipment address first name"
shipmentAddressFirstName: String
"Shipment address last name"
shipmentAddressLastName: String
"Shipment address street"
shipmentAddressStreet: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address fax number"
shipmentAddressFax: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: String
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment address state"
shipmentAddressState: String
"Created by user ID"
createdByUserId: ID
"Status text of the invoice correction"
status: String
"Sales channel of the invoice correction"
salesChannelId: ID @cost(weight: "10")
"DEPRECATED: do not use; use salesChannelId instead. Raw platform key (kPlattform); kept only as the source for salesChannelId."
platformId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"DEPRECATED: do not use; use salesChannelId instead. Raw shop key (kShop); kept only as the source for salesChannelId."
shopId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"CompanyId"
companyId: ID
"Comment of the sales invoice correction"
comment: String
"eBay user name"
ebayUsername: String
}
"Invoice for M&A system"
type SalesInvoiceInternal {
"Sales order ID"
salesOrderId: ID
"Sales invoice ID"
salesInvoiceId: ID!
"Customer ID"
customerId: ID!
"Platform ID"
platformId: ID
"Payment method ID"
salesInvoicePaymentMethodId: ID
"Company ID"
companyId: ID
"Payment due date in days"
paymentDueDateInDays: Int!
"Payment status"
paymentStatus: Byte
"Sales invoice number"
salesInvoiceNumber: String
"Sales invoice date"
salesInvoiceDate: DateTime
"External order number"
externalOrderNumber: String
"Shipment type"
shipmentType: Int
"Value date"
valueDate: DateTime
"Tax setting"
taxSetting: Int!
"Customer VAT ID"
customerVatIdNumber: String
"Sales invoice VAT ID"
salesInvoiceVatIdNumber: String
"Departure country ISO"
departureCountryIso: String
"Payment method ID"
paymentMethodId: ID
"Service date"
serviceDate: DateTime
"Customer number"
salesInvoiceCustomerNumber: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Currency ISO"
currencyIso: String
"Currency factor"
currencyFactor: Decimal!
"Departure country currency ISO"
departureCountryCurrencyIso: String
"Departure country currency factor"
departureCountryCurrencyFactor: Decimal!
"Total gross amount"
totalGrossAmount: Decimal
"Total net amount"
totalNetAmount: Decimal
"Last shipping"
lastShippingDate: DateTime
"Sales order number"
salesOrderNumber: String
"Created in ERP date"
createdInErpDate: DateTime
"Platform identifier"
platformIdentifier: String
"Payment method"
paymentMethod: String
"Payment method name"
paymentMethodName: String
"Shipment company"
shipmentAddressCompany: String
"Shipment salutation"
shipmentAddressSalutation: String
"Shipment title"
shipmentAddressTitle: String
"Shipment first name"
shipmentAddressFirstName: String
"Shipment last name"
shipmentAddressLastName: String
"Shipment street"
shipmentAddressStreet: String
"Shipment postal code"
shipmentAddressPostalCode: String
"Shipment city"
shipmentAddressCity: String
"Shipment country"
shipmentAddressCountry: String
"Shipment phone number"
shipmentAddressPhoneNumber: String
"Shipment fax number"
shipmentAddressFaxNumber: String
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment country ISO"
shipmentAddressCountryIso: String
"Shipment VAT ID"
shipmentAddressVatIdNumber: String
"Sales order shipment country ISO"
salesOrderShipmentCountryIso: String
"Sales invoice company"
billingAddressCompany: String
"Sales invoice salutation"
billingAddressSalutation: String
"Sales invoice title"
billingAddressTitle: String
"Sales invoice first name"
billingAddressFirstName: String
"Sales invoice last name"
billingAddressLastName: String
"Sales invoice street"
billingAddressStreet: String
"Sales invoice postal code"
billingAddressPostalCode: String
"Sales invoice city"
billingAddressCity: String
"Sales invoice country"
billingAddressCountry: String
"Sales invoice phone number"
billingAddressPhoneNumber: String
"Sales invoice fax number"
billingAddressFaxNumber: String
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: String
"Sales invoice ISO"
billingAddressCountryIso: String
"Customer company"
customerDefaultBillingAddressCompany: String
"Customer salutation"
customerDefaultBillingAddressSalutation: String
"Customer title"
customerDefaultBillingAddressTitle: String
"Customer first name"
customerDefaultBillingAddressFirstName: String
"Customer last name"
customerDefaultBillingAddressLastName: String
"Customer street"
customerDefaultBillingAddressStreet: String
"Customer postal code"
customerDefaultBillingAddressPostalCode: String
"Customer city"
customerDefaultBillingAddressCity: String
"Customer country"
customerDefaultBillingAddressCountry: String
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: String
"Customer fax number"
customerDefaultBillingAddressFaxNumber: String
"Customer address ISO"
customerDefaultBillingAddressCountryIso: String
"Customer address email address"
customerDefaultBillingAddressEmailAddress: String
"Customer address VAT ID"
customerDefaultBillingAddressVatIdNumber: String
"Customer number"
customerNumber: String
"Customer group ID"
customerGroupId: ID
"Customer payment due date in days"
customerPaymentDueDateInDays: Int
"Deposit"
deposit: String
"Cancelled sales invoice ID"
cancelledSalesInvoiceId: ID
"Delivery note count"
dropShippingDeliveryNoteCount: Int!
}
"Invoice line items for M&A system"
type SalesInvoiceLineItemInternal {
"Sales invoice identifier"
salesInvoiceId: ID!
"Sales invoice position identifier"
salesInvoicePositionId: ID!
"Sales order identifier"
salesOrderId: ID
"Item identifier"
itemId: ID
"Parts list line item identifier"
billOfMaterialsSalesInvoiceLineItemId: ID
"Sales invoice line item identifier"
salesInvoiceLineItemId: ID!
"Sales price gross"
salesPriceGross: Decimal!
"Sales price net"
salesPriceNet: Decimal!
"Invoice line item purchase price net"
purchasePriceNet: Decimal!
"Item purchase price net"
itemPurchasePriceNet: Decimal
"Invoice line item quantity"
quantity: Decimal!
"Invoice line item name"
name: String
"Stock keeping unit"
sku: String
"Invoice line item Tax rate"
taxRate: Decimal!
"Tax class identifier"
taxClassId: ID
"Invoice line item type"
invoiceLineItemType: Byte!
"Parent item identifier"
parentItemId: ID
"Taric code"
taric: String
"Item weight"
itemWeight: Decimal
"Item volume"
itemVolume: Decimal
"Product group identifier"
productGroupId: ID
"Product group name"
productGroupName: String
"Warehouse identifier"
warehouseId: ID
}
"Single row of the sales invoices overview table"
type SalesInvoiceListItem {
"Unique identifier of the sales invoice"
salesInvoiceId: ID!
"Created by user ID"
createdByUserId: ID
"Customer ID"
customerId: ID
"Currency ISO code"
currencyIso: String
"Company ID"
companyId: ID
"Company name"
companyName: String
"The VAT ID of the merchant’s company that is shown on the invoice"
vatIdNumber: String
"Payment method ID"
paymentMethodId: ID
"Payment method name"
paymentMethodName: String
"Indicates if dunning is blocked"
isDunningBlocked: Boolean!
"Date when the invoice was created"
salesInvoiceDate: DateTime!
"Value date of the invoice"
valueDate: DateTime!
"Sales invoice number"
salesInvoiceNumber: String
"Currency factor"
currencyFactor: Decimal!
"Shipping method ID"
shippingMethodId: ID
"Shipping method name"
shippingMethodName: String
"Indicates if the invoice is a draft"
isDraft: Boolean!
"Sales channel ID"
salesChannelId: ID @cost(weight: "10")
"DEPRECATED: do not use; use salesChannelId instead. Raw platform key (kPlattform); kept only as the source for salesChannelId."
platformId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"DEPRECATED: do not use; use salesChannelId instead. Raw shop key (kShop); kept only as the source for salesChannelId."
shopId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"Language ID"
languageId: ID
"Tax setting value"
taxSetting: SalesInvoiceTaxSetting!
"Indicates intra-community delivery"
isIntraCommunityDelivery: Boolean!
"Indicates VAT exemption"
isExemptFromVat: Boolean!
"Ebay username"
ebayUsername: String
"Sales channel name"
salesChannelName: String!
"Indicates if invoice is external"
isExternalSalesInvoice: Boolean!
"Indicates whether to print an existing invoice again"
printExistingSalesInvoice: Boolean!
"Date when the invoice was paid"
paymentDate: DateTime
"Date when the invoice was printed"
printDate: DateTime
"Date when the invoice was sent via e-mail"
mailDate: DateTime
"Indicates if the invoice has been dunned"
isDunned: Boolean!
"Open amount still to pay"
stillToPay: Decimal!
"Amount already paid"
alreadyPaidAmount: Decimal!
"Indicates if the invoice is completely paid"
isCompletelyPaid: Boolean!
"Internal comment"
comment: String
"Additional comment"
customerComment: String
"Total gross amount of credits related to this invoice"
salesInvoiceCorrectionTotalGrossAmount: Decimal!
"Indicates if a sales invoice correction exists"
hasSalesInvoiceCorrection: Boolean!
"Payment status of the invoice"
paymentStatus: InvoicePaymentStatus!
"Shipment address company"
shipmentAddressCompanyName: String
"Shipment address form of address"
shipmentAddressSalutation: String
"Shipment address title"
shipmentAddressTitle: String
"Shipment address first name"
shipmentAddressFirstName: String
"Shipment address last name"
shipmentAddressLastName: String
"Shipment address street"
shipmentAddressStreet: String
"The additional address line of the shipment address"
shipmentAddressAdditionalAddressLine: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: String
"Shipment address fax"
shipmentAddressFaxNumber: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"The additional company line of the shipment address"
shipmentAddressAdditionalCompanyLine: String
"Shipment address post ID"
shipmentAddressPostId: String
"Shipment address state"
shipmentAddressState: String
"Shipment address country ISO code"
shipmentAddressCountryIso: String
"Billing address company name"
billingAddressCompanyName: String
"The salutation of the billing address"
billingAddressSalutation: String
"Billing address title"
billingAddressTitle: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street"
billingAddressStreet: String
"The additional address line of the billing address"
billingAddressAdditionalAddressLine: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: String
"Billing address fax number"
billingAddressFaxNumber: String
"Billing address email address"
billingAddressEmailAddress: String
"The additional company line of the billing address"
billingAddressAdditionalCompanyLine: String
"Billing address post ID"
billingAddressPostId: String
"Billing address state"
billingAddressState: String
"Billing address country ISO code"
billingAddressCountryIso: String
"Total gross amount of the invoice"
totalGrossAmount: Decimal!
"Total gross amount in shipping country currency"
shippingCountryTotalGrossAmount: Decimal!
"Total net amount of the invoice"
totalNetAmount: Decimal!
"Total net amount in shipping country currency"
shippingCountryTotalNetAmount: Decimal!
"Name of the user who created the invoice"
createdByUserName: String
"Customer number"
customerNumber: String
"Accounts receivable number"
accountsReceivableNumber: Int
"Customer group name"
customerGroupName: String
"Payment due date in days"
paymentDueDateInDays: Int
"Payment due date"
paymentDueDate: DateTime
"Dunning level"
dunningLevel: Int
"Date of last dunning"
dunningDate: DateTime
"Indicates if the invoice is archived"
isArchived: Boolean!
"Process colour code"
processColourCode: Int!
"Process colour name"
processColourName: String
"Platform type"
platformType: Int!
"Sales order number"
salesOrderNumber: String
"Indicates if the invoice has been corrected"
isCorrected: Boolean!
"Indicates if the invoice is cancelled"
isCancelled: Boolean!
"Date when the invoice was cancelled"
cancelledDate: DateTime
"Cancellation comment"
cancellationComment: String
"Name of the user who cancelled the invoice"
cancellationUserName: String
"Cancellation reason"
cancellationReason: String
"Related sales order ID"
salesOrderId: ID
"External sales order number"
externalSalesOrderNumber: String
"Service date from (Leistungsdatum von) of the invoice"
serviceDateFrom: DateTime
"Service date to (Leistungsdatum bis) of the invoice"
serviceDateTo: DateTime
"Date of last shipping related to the invoice"
lastShippingDate: DateTime
}
"A single salesorder by its id"
type SalesOrder {
"Unique ID to identify a sales order."
id: ID!
"Customer this SalesOrder belongs to."
customerId: ID
"SalesOrderPaymentInfo"
paymentInfo: SalesOrderPaymentInfo
"SalesOrderText"
text: SalesOrderText
"The SalesOrder Date"
salesOrderDate: DateTime
"Indicates if the order has been cancelled."
isCancelled: Boolean!
"The SalesOrder IsPending"
isPending: Boolean!
"The SalesOrder ItemDescriptionType"
itemDescriptionType: ItemDescriptionType!
"The SalesOrder ReadOnlyType"
readOnlyType: ReadOnlyType!
"The SalesOrder SalesOrderStatus"
salesOrderStatus: Byte!
"The SalesOrder SalesOrderNumber"
salesOrderNumber: String!
"DepartureCountry"
departureCountry: SalesOrderDepartureCountry!
"ExternalDetails"
externalDetails: SalesOrderExternalDetails!
"PaymentDetails"
paymentDetails: SalesOrderPaymentDetails!
"ShippingDetails"
shippingDetails: SalesOrderShippingDetails!
"TaxDetails"
taxDetails: SalesOrderTaxDetails!
"The SalesOrder Process colour id"
processColourId: ID
"The SalesOrder OnHold reason id"
onHoldReasonId: ID
"The SalesOrder Carton item id"
cartonItemId: ID
"The SalesOrder Payment method id"
paymentMethodId: ID
"The SalesOrder Shipping method id"
shippingMethodId: ID
"The SalesOrder Process status id"
processStatusId: ID
"The SalesOrder Language iso code"
languageIso: String
"The SalesOrder Customer sales order number"
customerSalesOrderNumber: String
"The SalesOrder Vat Id"
vatId: String
"The SalesOrder Company Id"
companyId: ID!
"SalesOrderShipmentAddress"
shipmentAddress: SalesOrderAddress
"SalesOrderBillingAddress"
billingAddress: SalesOrderAddress
"List of SalesOrderLineItem"
lineItems: [SalesOrderLineItem!]!
"Key figures of the sales order."
keyFigures: SalesOrderKeyFigures
"List of invoices associated with this sales order"
invoices: [SalesOrderInvoice!]!
}
"Address information for a sales order"
type SalesOrderAddress {
"The SalesOrder this address belongs to"
salesOrderId: ID!
"The purpose of this address"
type: AddressType!
"The customer this address belongs to"
customerId: ID
"The SalesOrderAddress Salutation"
salutation: String
"The SalesOrderAddress Title"
title: String
"The SalesOrderAddress FirstName"
firstName: String
"The SalesOrderAddress LastName"
lastName: String
"The SalesOrderAddress Company"
company: String
"The SalesOrderAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesOrderAddress Street"
street: String
"The SalesOrderAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesOrderAddress City"
city: String
"The SalesOrderAddress PostalCode"
postalCode: String
"The SalesOrderAddress State"
state: String
"The SalesOrderAddress CountryISO"
countryIso: String
"The SalesOrderAddress PostId"
postId: String
"The SalesOrderAddress EmailAddress"
emailAddress: String
"The SalesOrderAddress PhoneNumber"
phoneNumber: String
"The SalesOrderAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesOrderAddress Fax"
fax: String
"The SalesOrderAddress Countryname"
country: String
"Information about the need for additional documents"
customsDocumentsRequired: Boolean
"The SalesOrderAddress VAT ID"
vatId: String
}
"Departure country information for a sales order"
type SalesOrderDepartureCountry {
"The SalesOrder CountryISO"
countryIso: String
"The SalesOrder DepartureCountry CurrencyISO"
currencyIso: String
"The SalesOrder DepartureCountry CurrencyFactor"
currencyFactor: Decimal!
"The SalesOrder State"
state: String
}
"External details for a sales order"
type SalesOrderExternalDetails {
"The SalesOrder ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType!
"The SalesOrder ExternalSalesOrderNumber"
externalSalesOrderNumber: String
}
"Invoice information associated with a sales order, including status details"
type SalesOrderInvoice {
"Unique ID of the invoice"
id: ID!
"The invoice number"
salesInvoiceNumber: String!
"The date the invoice was created"
createdDate: DateTime!
"Whether the invoice has been cancelled"
isCancelled: Boolean!
"Whether the invoice is a draft"
isDraft: Boolean!
}
"Provides key figures and status information for a sales order."
type SalesOrderKeyFigures {
"The unique identifier for the sales order."
salesOrderId: ID!
"The total amount already paid by the customer."
alreadyPaidAmount: Decimal!
"The total gross amount of all related credit notes."
creditsTotalGrossAmount: Decimal!
"The date and time when the payment was received."
dateOfPayment: DateTime
"The current delivery status of the sales order."
deliveryStatus: DeliveryStatus!
"The date and time when the order was sent via email."
emailedDate: DateTime
"A comma-separated string of associated invoice numbers."
invoiceNumbers: String
"The overall status of the associated invoices."
invoiceStatus: InvoiceStatus!
"The total gross amount of all associated invoices."
invoicesTotalGrossAmount: Decimal!
"The total net amount of all associated invoices."
invoicesTotalNetAmount: Decimal!
"Whether the order is handled via cash on delivery."
isCashOnDelivery: Boolean!
"Whether all items in the order have been returned."
isFullyReturned: Boolean!
"Whether the order is currently blocked for shipping."
isLockedForDelivery: Boolean!
"The date and time of the last shipping activity."
lastShippingDate: DateTime
"The total number of packages associated with this order."
packageCount: Int!
"The date and time when the payment confirmation email was sent."
paymentMailDate: DateTime
"The current payment status of the sales order."
paymentStatus: InvoicePaymentStatus!
"The date and time when the order documents were printed."
printedDate: DateTime
"The number of packages that have already been shipped."
shippedPackageCount: Int!
"The date and time when the shipping notification email was sent."
shippingMailDate: DateTime
"The remaining amount to be paid for this order."
stillToPay: Decimal!
"The remaining amount to be paid, excluding any cancelled items."
stillToPayWithoutCancellation: Decimal!
"The total gross amount of the sales order including shipping costs."
totalGrossAmount: Decimal!
"The total net amount of the sales order including shipping costs."
totalNetAmount: Decimal!
"The total gross amount of the sales order's articles only, excluding shipping costs."
totalGrossAmountExcludingShipping: Decimal!
"The total net amount of the sales order's articles only, excluding shipping costs."
totalNetAmountExcludingShipping: Decimal!
"The net shipping cost."
shippingCostNet: Decimal!
"The gross shipping cost."
shippingCostGross: Decimal!
"The VAT amounts grouped by tax rate."
vatAmounts: [SalesOrderVatAmountPerRate!]!
}
"A single line item of a sales order"
type SalesOrderLineItem {
"Id of this position"
id: ID!
"Id of the SalesOrder this position belongs to"
salesOrderId: ID!
"Unique ID to identify an item."
itemId: ID
"Sku"
sku: String
"Reserved status of that position"
isReserved: Boolean!
"Name of the position."
name: String
"The SalesOrderLineItem FNSKU"
fnSku: String
"Type of the sales order line item."
type: LineItemType!
"The quantity of the line item."
quantity: Decimal!
"The sales unit of the line item."
salesUnit: String
"The net sales price of the item."
salesPriceNet: Decimal!
"The gross sales price per unit (excl. quantity and discount)."
salesPriceGross: Decimal!
"The discount of the line item."
discountPercent: Decimal!
"The purchase price of the item."
purchasePriceNet: Decimal!
"The tax rate of the line item."
taxRate: Decimal!
"The SalesOrderLineItem TaxClassId"
taxClassId: ID
"The SalesOrderLineItem TaxCodeId"
taxCodeId: ID
"The SalesOrderLineItem Note"
note: String
"Total price net."
totalSalesPriceNet: Decimal!
"Total price gross."
totalSalesPriceGross: Decimal!
"Sort order."
sortOrder: Int!
"The default name."
standardName: String
"Information about an uploaded file."
hasUpload: Boolean!
"Id of the parent line item if this is a child line item."
parentSalesOrderLineItemId: ID
"Configuration item type."
configurationItemType: ConfigurationItemType!
"Bill of materials type."
billOfMaterialsType: BillOfMaterialsType!
"""
Returns the first Wawi image of the article referenced by this line item, or null
when the line item has no article or the article has no Wawi image. The image is resolved
lazily and batched across all line items of the response.
"""
itemImage: LineItemImage @cost(weight: "10")
}
"Single row of the salesorder overview table"
type SalesOrderListItem {
"Sales order id"
id: ID!
"The SalesOrder AccountsReceivableNumber"
accountsReceivableNumber: Int
"Assigned user ID"
assignedUserId: ID!
"Company name"
companyName: String
"Created by user ID"
createdByUserId: ID!
"Currency factor"
currencyFactor: Decimal!
"Currency ISO code"
currencyIso: String
"Customer ID"
customerId: ID
"The SalesOrder CustomerNumber"
customerNumber: String
"The SalesOrder DeliveryCompleteStatus"
deliveryCompleteStatus: DeliveryCompleteStatus!
"The SalesOrder CountryISO"
departureCountryIso: String
"The SalesOrder CurrencyFactor"
departureCountryCurrencyFactor: Decimal!
"The SalesOrder CurrencyISO"
departureCountryCurrencyIso: String!
"The SalesOrder EbayUsername"
ebayUsername: String
"The SalesOrder"
estimatedDeliveryDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalSalesInvoiceType: ExternalSalesInvoiceType!
"The SalesOrder"
externalSalesOrderNumber: String
"The SalesOrder ExtraWeight"
extraWeight: Decimal!
"SpacialTaxTreatment IntraCommunityDelivery"
isIntraCommunityDelivery: Boolean!
"Indicates if the order is cancelled"
isCancelled: Boolean!
"Indicates if the order is pending"
isPending: Boolean!
"Item description type"
itemDescriptionType: ItemDescriptionType!
"Language ISO code"
languageIso: String!
"The latest SalesOrder ShippingDate"
lastShippingDate: DateTime
"The SalesOrder NeedsOnlineSynchronization"
needsOnlineSynchronisation: Boolean!
"On hold reason ID"
onHoldReasonId: ID
"Payment method ID"
paymentMethodId: ID
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int
"Process colour code"
processColourCode: Int
"Process colour name"
processColourName: String
"Process status name"
processStatusName: String
"Read only type indicator"
readOnlyType: ReadOnlyType!
"Sales channel ID"
salesChannelId: ID @cost(weight: "10")
"DEPRECATED: do not use; use salesChannelId instead. Raw platform key (kPlattform); kept only as the source for salesChannelId."
platformId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"DEPRECATED: do not use; use salesChannelId instead. Raw shop key (kShop); kept only as the source for salesChannelId."
shopId: ID @deprecated(reason: "Do not use; use salesChannelId instead.")
"The date when the order was created"
salesOrderDate: DateTime!
"The SalesOrder SalesOrderNumber"
salesOrderNumber: String!
"Sales order status"
salesOrderStatus: Byte!
"Shipping method ID"
shippingMethodId: ID
"The SalesOrder ShippingPriority"
shippingPriority: Int!
"The SalesOrder ShopPaymentModule"
shopPaymentModule: String
"The SalesOrder TaxSetting"
taxSetting: TaxSetting
"The total gross amount of the order"
totalGrossAmount: Decimal
"SpacialTaxTreatment VATFree"
isExemptFromVat: Boolean!
"The company ID"
companyId: ID!
"The internet order ID"
onlineSalesOrderId: Int
"Comment\/Annotation"
comment: String
"Print date"
printDate: DateTime
"Mail date"
mailDate: DateTime
"Payment mail date"
paymentMailDate: DateTime
"Date of payment"
dateOfPayment: DateTime
"Payment date"
paymentDate: DateTime
"On hold reason name"
onHoldReasonName: String
"Sales invoice status"
salesInvoiceStatus: InvoiceStatus!
"Billing address company"
billingAddressCompany: String
"Billing address additional company line"
billingAddressAdditionalCompanyLine: String
"Billing address salutation"
billingAddressSalutation: String
"Billing address title"
billingAddressTitle: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street"
billingAddressStreet: String
"Billing address additional address line"
billingAddressAdditionalAddressLine: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: String
"Billing address fax"
billingAddressFax: String
"Billing address email address"
billingAddressEmailAddress: String
"Billing address post ID"
billingAddressPostId: String
"Billing address state"
billingAddressState: String
"Billing address country ISO"
billingAddressCountryIso: String
"Shipment address company"
shipmentAddressCompany: String
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: String
"Shipment address salutation"
shipmentAddressSalutation: String
"Shipment address title"
shipmentAddressTitle: String
"Shipment address first name"
shipmentAddressFirstName: String
"Shipment address last name"
shipmentAddressLastName: String
"Shipment address street"
shipmentAddressStreet: String
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: String
"Shipment address fax"
shipmentAddressFax: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"Shipment address post ID"
shipmentAddressPostId: String
"Shipment address state"
shipmentAddressState: String
"Shipment address country ISO"
shipmentAddressCountryIso: String
"Assigned user name"
assignedUserName: String
"Sales channel name"
salesChannelName: String
"Customer group name"
customerGroupName: String!
"Payment method name"
paymentMethodName: String
"Shipping method name"
shippingMethodName: String
"Shipping country total gross amount"
shippingCountryTotalGrossAmount: Decimal
"Customer comment"
customerComment: String
"Payment reference"
paymentReference: String
"Credits total gross amount"
salesInvoiceCorrectionTotalGrossAmount: Decimal!
"Already paid amount"
alreadyPaidAmount: Decimal!
"Still to pay amount"
stillToPay: Decimal
"Total net amount"
totalNetAmount: Decimal
"WMS locked"
wmsLocked: Byte
"WMS partial shipment"
wmsPartialShipment: Int
"WMS pre picking"
wmsPrePicking: Int
"Payment status"
paymentStatus: InvoicePaymentStatus!
"Delivery status"
deliveryStatus: DeliveryStatus!
"Platform type"
platformType: Int!
"Sales invoice numbers"
salesInvoiceNumbers: String
"Cancelled date"
cancelledDate: DateTime
"Cancellation comment"
cancellationComment: String
"Cancellation user name"
cancellationUserName: String
"Cancellation reason"
cancellationReason: String
"Amazon user ID"
amazonUserId: Int
"Created by user name"
createdByUserName: String
"Returns the sales invoices associated with this sales order."
salesInvoices: [SalesInvoiceListItem] @cost(weight: "10")
}
"Payment details for a sales order"
type SalesOrderPaymentDetails {
"The SalesOrder CashDiscount"
cashDiscount: Decimal!
"The SalesOrder CashDiscountDays"
cashDiscountDays: Int!
"The SalesOrder FinancingCosts"
financingCosts: Decimal!
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int!
"The currency ISO code"
currencyIso: String
"The currency factor"
currencyFactor: Decimal!
}
"Payment information and bank details for a sales order"
type SalesOrderPaymentInfo {
"The SalesOrderPaymentInfo AccountHolder"
accountHolder: String
"The SalesOrderPaymentInfo BankName"
bankName: String
"The SalesOrderPaymentInfo BIC"
bic: String
"The SalesOrderPaymentInfo CreditorId"
creditorId: String
"The SalesOrderPaymentInfo DueDate"
dueDate: DateTime
"The SalesOrderPaymentInfo EndToEndId"
endToEndId: String
"The SalesOrderPaymentInfo IBAN"
iban: String
"The SalesOrderPaymentInfo MandateReference"
mandateReference: String
"The SalesOrderPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesOrderPaymentInfo PaymentInfoType"
paymentInfoType: Byte!
"The SalesOrderPaymentInfo PaymentReference"
paymentReference: String
"The SalesOrderPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for a sales order"
type SalesOrderShippingDetails {
"The SalesOrder DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesOrder EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesOrder ExtraWeight"
extraWeight: Decimal!
"The SalesOrder MaxDeliveryDays"
maxDeliveryDays: Int!
"The SalesOrder ShippingDate"
shippingDate: DateTime
"The SalesOrder ShippingPriority"
shippingPriority: Int!
}
"Shipping eligibility information for a single sales order including stock-based status and blocking reasons."
type SalesOrderShippingEligibility {
"The sales order Id."
salesOrderId: ID!
"The stock-based shipping eligibility status including supplier stock."
shippingEligibilityStatus: ShippingEligibilityStatus!
"The stock-based shipping eligibility status based on own stock only (excluding supplier stock)."
shippingEligibilityStatusOwnStock: ShippingEligibilityStatus!
"A list of blocking reasons that prevent delivery. Empty if no blocking reasons exist."
blockingReasons: [SalesOrderShippingEligibilityBlockingReason!]!
}
"A single blocking reason that prevents delivery of a sales order."
type SalesOrderShippingEligibilityBlockingReason {
"The type of blocking reason."
reasonType: ShippingEligibilityBlockingReasonType!
"A human-readable message describing the blocking reason."
message: String!
}
"Tax details for a sales order"
type SalesOrderTaxDetails {
"The SalesOrder TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference!
"The SalesOrder SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment!
"The SalesOrder TaxSetting"
taxSetting: TaxSetting!
}
"Text and comment information for a sales order"
type SalesOrderText {
"The SalesOrderText Comment"
comment: String
"The SalesOrderText CustomerComment"
customerComment: String
"The SalesOrderText PrintText"
printText: String
"The SalesOrderText ProcessStatus"
processStatus: String
}
"VAT amount for a specific tax rate."
type SalesOrderVatAmountPerRate {
"The tax rate in percent (e.g. 19.0 for 19% VAT)."
taxRate: Decimal!
"The VAT amount for this tax rate."
vatAmount: Decimal!
}
"A single SalesQuotation by its id"
type SalesQuotation {
"Unique ID to identify a sales quoation."
id: ID!
"Customer this SalesQuotation belongs to."
customerId: ID
"SalesQuotationPaymentInfo"
paymentInfo: SalesQuotationPaymentInfo
"SalesQuotationText"
text: SalesQuotationText
"The SalesQuotation Date"
salesQuotationDate: DateTime
"Indicates if the quotation has been cancelled."
isCancelled: Boolean!
"The SalesQuotation IsPending"
isPending: Boolean!
"The SalesQuotation ItemDescriptionType"
itemDescriptionType: ItemDescriptionType!
"The SalesQuotation ReadOnlyType"
readOnlyType: ReadOnlyType!
"The SalesQuotation Status"
salesQuotationStatus: Byte!
"The SalesQuotation SalesQuotationNumber"
salesQuotationNumber: String!
"DepartureCountry"
departureCountry: SalesQuotationDepartureCountry!
"ExternalDetails"
externalDetails: SalesQuotationExternalDetails!
"PaymentDetails"
paymentDetails: SalesQuotationPaymentDetails!
"ShippingDetails"
shippingDetails: SalesQuotationShippingDetails!
"TaxDetails"
taxDetails: SalesQuotationTaxDetails!
"The SalesQuotation Process colour id"
processColourId: ID
"The SalesQuotation OnHold reason id"
onHoldReasonId: ID
"The SalesQuotation Carton item id"
cartonItemId: ID
"The SalesQuotation Payment method id"
paymentMethodId: ID
"The SalesQuotation Shipping method id"
shippingMethodId: ID
"The SalesQuotation Process status id"
processStatusId: ID
"The SalesQuotation Language iso code"
languageIso: String
"The SalesQuotation Customer sales quotation number"
customerSalesQuotationNumber: String
"The SalesQuotation Vat Id"
vatId: String
"The SalesQuotation Company Id"
companyId: ID!
"SalesQuotationShippingAddress"
shipmentAddress: SalesQuotationAddress
"SalesQuotationBillingAddress"
billingAddress: SalesQuotationAddress
"List of SalesQuotationLineItem"
lineItems: [SalesQuotationLineItem!]!
"Key figures of the sales quotation."
keyFigures: SalesQuotationKeyFigures
}
"Address information for a sales quotation"
type SalesQuotationAddress {
"The SalesQuotation this address belongs to"
salesQuotationId: ID!
"The purpose of this address"
type: AddressType!
"The customer this address belongs to"
customerId: ID
"The SalesQuotationAddress Salutation"
salutation: String
"The SalesQuotationAddress Title"
title: String
"The SalesQuotationAddress FirstName"
firstName: String
"The SalesQuotationAddress LastName"
lastName: String
"The SalesQuotationAddress Company"
company: String
"The SalesQuotationAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesQuotationAddress Street"
street: String
"The SalesQuotationAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesQuotationAddress City"
city: String
"The SalesQuotationAddress PostalCode"
postalCode: String
"The SalesQuotationAddress State"
state: String
"The SalesQuotationAddress CountryISO"
countryIso: String
"The SalesQuotationAddress PostId"
postId: String
"The SalesQuotationAddress EmailAddress"
emailAddress: String
"The SalesQuotationAddress PhoneNumber"
phoneNumber: String
"The SalesQuotationAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesQuotationAddress Fax"
fax: String
"The SalesQuotationAddress Countryname"
country: String
"Information about the need for additional documents"
customsDocumentsRequired: Boolean
"The SalesQuotationAddress VAT ID"
vatId: String
}
"Departure country information for a sales quotation"
type SalesQuotationDepartureCountry {
"The SalesQuotation CountryISO"
countryIso: String
"The SalesQuotation DepartureCountry CurrencyISO"
currencyIso: String
"The SalesQuotation DepartureCountry CurrencyFactor"
currencyFactor: Decimal!
"The SalesQuotation StateCode"
stateCode: String
}
"External details for a sales quotation"
type SalesQuotationExternalDetails {
"The SalesQuotation ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesQuotation ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType!
"The SalesQuotation ExternalSalesQuotationNumber"
externalSalesQuotationNumber: String
}
"Provides key figures for a sales quotation."
type SalesQuotationKeyFigures {
"The unique identifier for the sales quotation."
salesQuotationId: ID!
"The total gross amount of the sales quotation including shipping costs, in the quotation's transaction currency."
totalGrossAmount: Decimal!
"The total net amount of the sales quotation including shipping costs, in the quotation's transaction currency."
totalNetAmount: Decimal!
"The total gross amount of the sales quotation's articles only, excluding shipping costs, in the quotation's transaction currency."
totalGrossAmountExcludingShipping: Decimal!
"The total net amount of the sales quotation's articles only, excluding shipping costs, in the quotation's transaction currency."
totalNetAmountExcludingShipping: Decimal!
"The net shipping cost."
shippingCostNet: Decimal!
"The gross shipping cost."
shippingCostGross: Decimal!
"The VAT amounts grouped by tax rate."
vatAmounts: [SalesQuotationVatAmountPerRate!]!
}
"A single line item of a sales quotation"
type SalesQuotationLineItem {
"Id of this position"
id: ID!
"Id of the SalesQuotation this position belongs to"
salesQuotationId: ID!
"Unique ID to identify an item."
itemId: ID
"Sku"
sku: String
"Reserved status of that position"
isReserved: Boolean!
"Name of the position."
name: String
"The SalesQuotationLineItem FNSKU"
fnSku: String
"Type of the sales quotation line item."
type: LineItemType!
"The quantity of the line item."
quantity: Decimal!
"The sales unit of the line item."
salesUnit: String
"The net sales price of the item."
salesPriceNet: Decimal!
"The gross sales price per unit (excl. quantity and discount)."
salesPriceGross: Decimal!
"The discount of the line item."
discountPercent: Decimal!
"The purchase price of the item."
purchasePriceNet: Decimal!
"The tax rate of the line item."
taxRate: Decimal!
"The SalesQuotationLineItem TaxClassId"
taxClassId: ID
"The SalesQuotationLineItem TaxCodeId"
taxCodeId: ID
"The SalesQuotationLineItem Note"
note: String
"Total price net."
totalSalesPriceNet: Decimal!
"Total price gross."
totalSalesPriceGross: Decimal!
"Sort order."
sortOrder: Int!
"The default name."
standardName: String
"Information about an uploaded file."
hasUpload: Boolean!
"Id of the parent line item if this is a child line item."
parentSalesQuotationLineItemId: ID
"Configuration item type."
configurationItemType: ConfigurationItemType!
"Bill of materials type."
billOfMaterialsType: BillOfMaterialsType!
"""
Returns the first Wawi image of the article referenced by this line item, or null
when the line item has no article or the article has no Wawi image. The image is resolved
lazily and batched across all line items of the response.
"""
itemImage: LineItemImage @cost(weight: "10")
}
"Single row of the sales quotation overview table"
type SalesQuotationListItem {
"Sales quotation unique identifier"
id: ID!
"Assigned user ID"
assignedUserId: ID!
"Customer ID"
customerId: ID
"Shipping method ID"
shippingMethodId: ID
"Company (firm) ID"
companyId: ID
"Payment method ID"
paymentMethodId: ID
"Official sales quotation number"
salesQuotationNumber: String!
"External reference number for the quotation"
externalSalesQuotationNumber: String
"Name of the platform where the quotation originated"
platformName: String
"Internal comments or remarks"
comment: String
"ISO currency code used for the quotation"
currencyIso: String
"Exchange rate factor for the currency"
currencyFactor: Decimal!
"Date when the quotation was printed"
printDate: DateTime
"Date when the quotation was sent via email"
mailDate: DateTime
"Display text for the current process status"
processStatusName: String
"Additional weight calculated for the quotation"
extraWeight: Decimal!
"Total shipping weight"
shippingWeight: Decimal!
"Date and time when the quotation was created"
salesQuotationDate: DateTime!
"ISO code of the departure\/shipping country"
departureCountryIso: String
"Name of the departure\/shipping country"
departureCountryName: String
"Currency ISO code of the departure country"
departureCountryCurrencyIso: String!
"Currency exchange factor of the departure country"
departureCountryCurrencyFactor: Decimal!
"Billing address company"
billingAddressCompany: String
"Billing address first name"
billingAddressFirstName: String
"Billing address last name"
billingAddressLastName: String
"Billing address street and house number"
billingAddressStreet: String
"Billing address additional address line (e.g., apartment, suite)"
billingAddressAdditionalAddressLine: String
"Billing address postal code"
billingAddressPostalCode: String
"Billing address city"
billingAddressCity: String
"Billing address country name"
billingAddressCountryName: String
"Billing address phone number"
billingAddressPhoneNumber: String
"Billing address fax number"
billingAddressFax: String
"Billing address email address"
billingAddressEmailAddress: String
"Billing address additional company information line"
billingAddressAdditionalCompanyLine: String
"Billing address state or province"
billingAddressState: String
"Shipment address company name"
shipmentAddressCompany: String
"Shipment address contact first name"
shipmentAddressFirstName: String
"Shipment address contact last name"
shipmentAddressLastName: String
"Shipment address street and house number"
shipmentAddressStreet: String
"Shipment address additional address line (e.g., apartment, suite)"
shipmentAddressAdditionalAddressLine: String
"Shipment address postal code"
shipmentAddressPostalCode: String
"Shipment address city"
shipmentAddressCity: String
"Shipment address country name"
shipmentAddressCountryName: String
"Shipment address phone number"
shipmentAddressPhoneNumber: String
"Shipment address fax number"
shipmentAddressFax: String
"Shipment address email address"
shipmentAddressEmailAddress: String
"Shipment address additional company information line"
shipmentAddressAdditionalCompanyLine: String
"Shipment address state or province"
shipmentAddressState: String
"Name of the user currently assigned to this quotation"
assignedUserName: String
"Name of the user who originally created the quotation"
createdByUserName: String
"Display name of the company"
companyName: String
"Name of the sales channel or shop"
salesChannelName: String
"Name of the assigned customer group"
customerGroupName: String
"Display name of the selected payment method"
paymentMethodName: String
"Display name of the selected shipping method"
shippingMethodName: String
"Unique customer business number"
customerNumber: String
"Total gross amount in the system's base currency"
totalGrossAmount: Decimal
"Total net amount in the system's base currency"
totalNetAmount: Decimal
"Total gross amount converted to the shipping country's currency"
shippingCountryTotalGrossAmount: Decimal
"Total net amount converted to the shipping country's currency"
shippingCountryTotalNetAmount: Decimal
"Additional customer-related notes or miscellaneous instructions"
customerComment: String
"ARGB or numeric color code for process highlighting"
processColourCode: Int
"Descriptive name of the assigned process color"
processColourName: String
}
"Payment details for a sales quotation"
type SalesQuotationPaymentDetails {
"The SalesQuotation CashDiscount"
cashDiscount: Decimal!
"The SalesQuotation CashDiscountDays"
cashDiscountDays: Int!
"The SalesQuotation FinancingCosts"
financingCosts: Decimal!
"The SalesQuotation PaymentDueDateInDays"
paymentDueDateInDays: Int!
"The currency ISO code"
currencyIso: String
"The currency factor"
currencyFactor: Decimal!
}
"Payment information and bank details for a sales quotation"
type SalesQuotationPaymentInfo {
"The SalesQuotationPaymentInfo AccountHolder"
accountHolder: String
"The SalesQuotationPaymentInfo BankName"
bankName: String
"The SalesQuotationPaymentInfo BIC"
bic: String
"The SalesQuotationPaymentInfo CreditorId"
creditorId: String
"The SalesQuotationPaymentInfo DueDate"
dueDate: DateTime
"The SalesQuotationPaymentInfo EndToEndId"
endToEndId: String
"The SalesQuotationPaymentInfo IBAN"
iban: String
"The SalesQuotationPaymentInfo MandateReference"
mandateReference: String
"The SalesQuotationPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesQuotationPaymentInfo PaymentInfoType"
paymentInfoType: Byte!
"The SalesQuotationPaymentInfo PaymentReference"
paymentReference: String
"The SalesQuotationPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for a sales quotation"
type SalesQuotationShippingDetails {
"The SalesQuotation DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesQuotation EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesQuotation ExtraWeight"
extraWeight: Decimal!
"The SalesQuotation MaxDeliveryDays"
maxDeliveryDays: Int!
"The SalesQuotation ShippingDate"
shippingDate: DateTime
"The SalesQuotation ShippingPriority"
shippingPriority: Int!
}
"Tax details for a sales quotation"
type SalesQuotationTaxDetails {
"The SalesQuotation TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference!
"The SalesQuotation SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment!
"The SalesQuotation TaxSetting"
taxSetting: TaxSetting!
}
"Text and comment information for a sales quotation"
type SalesQuotationText {
"The SalesQuotationText Comment"
comment: String
"The SalesQuotationText CustomerComment"
customerComment: String
"The SalesQuotationText PrintText"
printText: String
"The SalesQuotationText ProcessStatus"
processStatus: String
}
"VAT amount for a specific tax rate."
type SalesQuotationVatAmountPerRate {
"The tax rate in percent (e.g. 19.0 for 19% VAT)."
taxRate: Decimal!
"The VAT amount for this tax rate."
vatAmount: Decimal!
}
type SaleschannelImages {
"Unique ID to identify a saleschannel."
saleschannelId: ID!
"List of images assigned to the saleschannel."
images: [ItemImage!]!
}
"Single Row of the serial number query"
type SerialNumberListItem {
"Id of the Warehouse."
warehouseId: ID!
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ID!
"Id of the item."
itemId: ID!
"Serial numbers of the item."
serialNumber: String!
"Indicates if the serial number is active."
isActive: Boolean!
}
"Represents a shipping address"
type ShippingAddress {
"Company name"
company: String!
"Salutation"
salutation: String!
"Title"
title: String!
"First name"
firstName: String!
"Last name"
lastName: String!
"Street"
street: String!
"Zip code"
zipCode: String!
"City"
city: String!
"Country"
country: String!
"Phone"
phone: String!
"Address supplement"
addressSupplement: String!
"Address supplement 2"
addressSupplement2: String!
"Post ID"
postId: String!
"Mobile"
mobile: String!
"Mail"
mail: String!
"Fax"
fax: String!
"State"
state: String!
"ISO code"
iso: String!
"Customs documents required"
customsDocumentsRequired: Boolean!
}
"Single row of the shipping boxes overview list."
type ShippingBoxListItem {
"Shipping box identifier."
id: ID!
"Display name of the shipping box."
displayId: String!
"Box type identifier (nullable in DB)."
typeId: ID
"Assigned bin location (can be 0 or null in DB)."
binLocationId: ID
"Parent warehouse."
warehouseId: ID!
"Lock status (false=unlocked, true=locked). Nullable in database."
locked: Boolean
}
"Reference data describing an available shipping box type."
type ShippingBoxType {
"Box type identifier."
value: ID!
"Display name for the box type."
name: String!
}
"Single row of the shipping class overview"
type ShippingClassListItem {
"ShippingClass id"
id: ID!
"The name of the shipping class"
name: String!
}
"Single Row of the shipping method lookup"
type ShippingMethodLookupItem {
"Id of the shipping method."
id: ID!
"Default Category Name"
name: String!
"Is the shipping method active"
isActive: Boolean!
}
"Provides paged access to stock movement history entries filtered by warehouse and optional criteria."
type StockMovementHistoryItem {
"Article number (cArtNr)."
articleNumber: String!
"Article display name."
articleName: String!
"Movement quantity."
quantity: Decimal!
"Best-before date (MHD), if tracked."
bestBeforeDate: DateTime
"Batch\/charge number."
batchNumber: String
"First serial number linked to the movement."
serialNumber: String
"Count of serial numbers linked to the movement."
serialNumberCount: Int!
"Source bin location name."
sourceBinLocation: String
"Target bin location name."
targetBinLocation: String
"Source shipping box display ID."
sourceBoxDisplayId: String
"Target shipping box display ID."
targetBoxDisplayId: String
"Transfer type key (kBuchungsArt)."
transferTypeId: Int
"Transfer type name."
transferTypeName: String
"User name."
userName: String
"Movement timestamp."
timestamp: DateTime!
"Movement comment."
comment: String
}
"Single Row of the stock reservations query"
type StockReservationListItem {
"Id of the item"
itemId: ID!
"Id of the sales order"
salesOrderId: ID!
"Id of the customer"
customerId: ID!
"Reserved amount"
amount: Decimal!
"Creation date of the reservation"
createdAt: DateTime!
"eBay item identifier"
ebayItemId: String!
"Sales platform"
platform: String!
}
"Single Row of the storage location query"
type StorageLocationListItem {
"Id of the storage location."
id: ID!
"Default storage location name"
name: String!
}
"Single row of the supplier overview table"
type Supplier {
"Unique identifier of the supplier"
id: ID!
"Name of the supplier"
name: String!
"Is drop shipping supplier"
canDropship: Boolean!
"Currency ISO code"
currencyIso: String!
}
type SupplierPrice {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal!
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal!
}
"Represents a tax class in the system"
type TaxClass {
"The unique identifier of the tax class"
id: ID!
"Indicates if this tax class is the standard tax class"
isStandard: Boolean!
"The name of the tax class"
name: String!
"The type of the tax class"
taxType: TaxType!
}
"Represents a tax class item in the system"
type TaxClassWithTaxRate {
"The unique identifier of the tax class."
id: ID!
"The name of the tax class"
name: String!
"Indicates if this tax class is the standard tax class"
isStandard: Boolean!
"The tax rate in percent calculated for this tax class with the given parameters."
rate: Decimal
}
"Represents a tax code in the system"
type TaxCode {
"The unique identifier of the tax code"
id: ID!
"The cash discount account of the tax code"
cashDiscountAccount: String!
"The general ledger account of the tax code"
generalLedgerAccount: String!
"Indicates if this tax code is automatic"
isAutomatic: Boolean!
"The name of the tax code"
name: String!
"The number of the tax code"
number: Int
}
"Represents a tax zone with its country assignments, tax rates, and rate key assignments."
type TaxZone {
"The unique identifier of the tax zone."
id: ID!
"The company this tax zone belongs to."
companyId: ID!
"The name of the tax zone."
name: String!
"The ISO code of the departure country this zone is associated with."
departureCountryIso: String!
"The source for VAT ID resolution in B2B transactions."
vatIdB2B: VatIdSource!
"The source for VAT ID resolution in B2C transactions."
vatIdB2C: VatIdSource!
"The country assignments for this zone."
countries: [TaxZoneCountry!]!
"The tax rates for this zone."
taxRates: [TaxZoneRate!]!
}
"Represents a country assigned to a tax zone."
type TaxZoneCountry {
"The ID of the tax zone this country belongs to."
taxZoneId: ID!
"The ISO country code."
countryIso: String!
"The state or province code within the country."
stateCode: String!
}
"Represents a tax rate assigned to a tax zone and tax class."
type TaxZoneRate {
"The unique identifier of the tax rate."
id: ID!
"The tax zone this rate belongs to."
taxZoneId: ID
"The tax class this rate applies to."
taxClassId: ID
"The VAT rate as a decimal value (e.g. 19.0 for 19%)."
vatRate: Decimal!
"The priority of this tax rate."
priority: Byte
"The main tax code (Steuerschlüssel)."
taxCodeId: ID
"The intra-community delivery tax code."
intraCommunityDeliveryTaxCodeId: ID
"The tax code for shipments from EU to non-EU countries (exempt from VAT, not EU)."
exemptFromVatNotEuTaxCodeId: ID
"The reverse charge tax code."
reverseChargeTaxCodeId: ID
"The tax rate key assignments for this rate."
taxRateAssignments: [TaxZoneRateAssignment!]!
}
"Represents a tax rate key assignment mapping tax codes to product groups, shipping methods, and line item types."
type TaxZoneRateAssignment {
"The ID of the tax rate this assignment belongs to."
taxRateId: ID!
"The product group ID."
productGroupId: ID
"The shipping method ID."
shippingMethodId: ID
"The line item type."
lineItemType: TaxLineItemType!
"The main tax code (Steuerschlüssel)."
taxCodeId: ID
"The intra-community delivery tax code."
intraCommunityDeliveryTaxCodeId: ID
"The tax code for shipments from EU to non-EU countries (exempt from VAT, not EU)."
exemptFromVatNotEuTaxCodeId: ID
"The reverse charge tax code."
reverseChargeTaxCodeId: ID
}
"Updates a new Category - Response"
type UpdateCategoryCommandResponse {
"Unique ID of the modified category."
categoryId: ID!
}
"Single row of the company VAT id table"
type UpdateCompanyVatIdDetailsItem {
"Unique VAT ID."
id: ID!
"The company id."
companyId: ID!
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"Updates a customer - Response"
type UpdateCustomerCommandResponse {
"Id of the changed customer"
customerId: ID!
}
"Updates a production order. - Response"
type UpdateProductionOrderCommandResponse {
"The ID of the modified production order."
productionOrderId: ID!
}
"Modifies an existing sales order. - Response"
type UpdateSalesOrderCommandResponse {
"Unique ID of the modified sales order."
salesOrderId: ID!
}
"Modifies an existing sales quotation. - Response"
type UpdateSalesQuotationCommandResponse {
"Unique ID of the modified sales quotation."
salesQuotationId: ID!
}
type Variation {
"Id of the Variation"
variationId: ID!
"Position of this Variation in the List"
position: Int!
"Descriptions of this Variation in multiple Languages"
descriptions: [Description!]!
"Values for this Variation"
values: [VariationValue!]!
"Type of the Variation"
variationType: VariationType!
}
type VariationValue {
"Id of the VariationValue"
variationValueId: ID!
"Itemnumber for this variationvalue"
itemNumber: String
"GTIN for this variationvalue"
gtin: String
"Offset for the weight of this variationvalue"
weightOffset: Decimal!
"Descriptions of this VariationValue in multiple Languages"
descriptions: [Description!]!
"Surcharges of this VariationValue"
surcharges: VariationValueSurcharges!
"Position of this VariationValue in the List"
position: Int!
"Image for this variation value. This image will be used as the main image for the variation combination if this variation value is part of it and the variation combination doesn't have its own image."
image: ID
}
type VariationValueSurcharges {
"Default Surcharge if there is none specified for a specific saleschannel + customergroup"
defaultSurchargeNet: Decimal!
"Default Surcharges for specific customergroups in general, independent of saleschannel"
customerGroupSurcharges: [CustomerGroupSurcharge!]!
"Surcharge for specific saleschannels + customergroups"
salesChannelSurcharges: [SalesChannelSurcharge!]!
}
"Represents a warehouse address"
type WarehouseAddress {
"Warehouse ID"
id: ID!
"Warehouse name"
name: String!
"Shortcut"
shortcut: String!
"Description"
description: String!
"Street"
street: String!
"Zip code"
zipCode: String!
"City"
city: String!
"Country"
country: String!
"Phone"
phone: String!
"Mail"
mail: String!
"Address supplement"
addressSupplement: String!
}
"Single Row of the warehouse query"
type WarehouseListItem {
"Id of the warehouse."
id: ID!
"Default warehouse name"
name: String!
"Describes if the warehouse is active"
active: Boolean!
}
"Single row of the warehouse zones overview list."
type WarehouseZoneListItem {
"Unique zone identifier."
zoneId: ID!
"Zone short code."
code: String!
"Zone description (may be empty)."
description: String
"Warehouse that owns this zone."
warehouseId: ID!
"Zone type enum value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: Int!
}
"Represents a workbench resource."
type WorkbenchResource {
"This workbench resource's unique ID."
id: ID!
"This workbench resource's unique number."
number: String!
"This workbench resource's name."
name: String!
"This workbench resource's description."
description: String!
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ID!
"The name of the host assigned to this workbench resource."
hostName: String!
"The ID of the warehouse assigned to this workbench resource."
warehouseId: ID!
"The reservation mode of this workbench resource."
reservationMode: ReservationMode!
"Specifies whether the dialog for displaying and\/or capturing process parameter values in the context of production should be displayed automatically when process parameter values can\/must be displayed or captured."
autoShowProcessParameterValuesInProduction: Boolean!
"Specifies whether and to what extent the use of expired components is permitted."
expiredComponentsUsage: ExpiredComponentsUsage!
"Specifies wthether and how available stock should be reserved when creating a replenishment order."
replenishmentCreationStockReservationMode: ReplenishmentCreationAvailableStockReservationMode!
}
"Represents a workbench resource type"
type WorkbenchResourceType {
"This workbench resource type's unqiue ID."
id: ID!
"The workbench resource type's name."
name: String!
}
"A single configuration entry of a worker sync."
type WorkerSyncConfig {
"The unique identifier of the configuration entry."
identifier: ID!
"The display name of the configuration entry."
displayName: String
"The display description of the configuration entry."
displayDescription: String
"The type name of the configuration value."
type: String
"The current value of the configuration entry."
currentValue: String
"Indicates whether the configuration entry is required."
isRequired: Boolean!
}
"A worker sync and its configuration."
type WorkerSyncItem {
"The unique identifier of a sync."
identifier: ID!
"The name of the sync."
syncName: String
"The name of the sales channel."
salesChannelName: String
"The sales channel for the sync."
salesChannelId: ID!
"The sync interval."
interval: TimeSpan
"Indicates whether the sync reports progress in percent."
reportProgress: Boolean!
"The configuration entries of the worker sync."
configurations: [WorkerSyncConfig!]!
}
"The current status of a worker sync."
type WorkerSyncStatus {
"The unique identifier of a sync."
identifier: ID!
"The current state of the sync."
state: SyncState!
"The latest progress text reported by the sync."
progressText: String
"The progress in percent. A negative value indicates that no progress is reported."
progress: Float!
"The timestamp of the last sync run."
lastSync: DateTime!
"The timestamp of the next scheduled sync run."
nextSync: DateTime!
}
"Represents a bin location assigned to a warehouse zone."
type ZoneBinLocationItem {
"Zone identifier."
zoneId: ID!
"Bin location identifier."
binLocationId: ID!
}
"Reference data describing an available warehouse zone type."
type ZoneType {
"Zone type numeric value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
value: Int!
"Display name for the zone type."
name: String!
}
"Activates a bin location, making it available for operations. - Request"
input ActivateBinLocationCommandRequestInput {
"Unique identifier of the bin location to activate."
binLocationId: ID!
}
"Activates a language in the system - Request"
input ActivateLanguageCommandRequestInput {
"The culture or ISO code of the language to be activated."
cultureOrIso: String!
}
"Reference data describing available employee tracking activity types."
input ActivityTypeFilterInput {
and: [ActivityTypeFilterInput!]
or: [ActivityTypeFilterInput!]
"Activity type numeric value (kBuchungsart)."
value: ComparableInt32OperationFilterInput
"Display name of the activity type."
name: StringOperationFilterInput
}
"Reference data describing available employee tracking activity types."
input ActivityTypeSortInput {
"Activity type numeric value (kBuchungsart)."
value: SortEnumType @cost(weight: "10")
"Display name of the activity type."
name: SortEnumType @cost(weight: "10")
}
"Adds bin locations to a warehouse zone. - Request"
input AddBinLocationsToZoneCommandRequestInput {
"The zone to add bin locations to."
zoneId: ID!
"Bin locations to add to the zone."
binLocationIds: [ID]!
}
"Adds supplier information to an existing regular item. This command allows the association of suppliers with the item, including details such as purchase prices, delivery times, and order intervals. - Request"
input AddItemSupplierCommandRequestInput {
"Unique ID of the item to be modified - this key is used for all further operations with the item."
itemId: ID!
"Supplier information to be added to the item."
itemSupplier: CreateItemSupplierInput!
}
"Adds a new variation (e.g., color, size) to an existing item. Variations allow customers to select different product options. - Request"
input AddItemVariationCommandRequestInput {
"Unique ID of the item to be modified - this key is used for all further operations with the item."
itemId: ID!
"The variation to add including type (selectbox, radio, etc.), descriptions in multiple languages, and optional variation values."
variation: CreateVariationInput!
}
"Adds a new value to an existing item variation. - Request"
input AddItemVariationValueCommandRequestInput {
"Unique ID of the variation to which the value should be added."
variationId: ID!
"The variation value to add including descriptions in multiple languages, surcharges, GTIN, item number, and weight offset."
variationValue: CreateVariationValueInput!
}
"Add new product groups. - Request"
input AddProductGroupsCommandRequestInput {
"The names of the product groups."
names: [String!]!
}
input ArtikelKeySortInput {
kArtikel: SortEnumType @cost(weight: "10")
}
"Assigns the specified item to the specified marketplace offer. - Request"
input AssignItemToMarketplaceOfferCommandRequestInput {
"Marketplace offer key identifying the offer the item will be assigned to."
offerKey: ID!
"Article key identifying the item to assign to the marketplace offer."
artikelKey: ID!
"Marketplace category key identifying the category the offer belongs to."
categoryKey: ID!
}
"Reassigns a shipping box to a different bin location (Rule SB-5). - Request"
input AssignShippingBoxToLocationCommandRequestInput {
"The shipping box to reassign."
shippingBoxId: ID!
"New bin location."
binLocationId: ID!
}
"A list of batches for specific items and their quantities"
input BatchListItemFilterInput {
and: [BatchListItemFilterInput!]
or: [BatchListItemFilterInput!]
"Id of the Item"
itemId: ComparableArtikelKeyOperationFilterInput
"The batch number"
batch: StringOperationFilterInput
"The quantity of the item in the batch"
quantity: ComparableDecimalOperationFilterInput
"Id of the Warehouse"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
"A list of batches for specific items and their quantities"
input BatchListItemSortInput {
"Id of the Item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"The batch number"
batch: SortEnumType @cost(weight: "10")
"The quantity of the item in the batch"
quantity: SortEnumType @cost(weight: "10")
"Id of the Warehouse"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
input BenutzerKeySortInput {
kBenutzer: SortEnumType @cost(weight: "10")
}
"A list of best before dates (MHDs) for specific items and their quantities"
input BestBeforeListItemFilterInput {
and: [BestBeforeListItemFilterInput!]
or: [BestBeforeListItemFilterInput!]
"Id of the Item"
itemId: ComparableArtikelKeyOperationFilterInput
"The best before date (MHD)"
bestBeforeDate: ComparableDateTimeOperationFilterInput
"The quantity of the item with this best before date"
quantity: ComparableDecimalOperationFilterInput
"Id of the Warehouse"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
"A list of best before dates (MHDs) for specific items and their quantities"
input BestBeforeListItemSortInput {
"Id of the Item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"The best before date (MHD)"
bestBeforeDate: SortEnumType @cost(weight: "10")
"The quantity of the item with this best before date"
quantity: SortEnumType @cost(weight: "10")
"Id of the Warehouse"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
input BildKeySortInput {
kBild: SortEnumType @cost(weight: "10")
}
input BillOfMaterialKeySortInput {
kBillOfMaterial: SortEnumType @cost(weight: "10")
}
"A bill of materials for a production item. It defines which operations must be performed and which components are required to produce the production item."
input BillOfMaterialsFilterInput {
and: [BillOfMaterialsFilterInput!]
or: [BillOfMaterialsFilterInput!]
"The ID of this bill of materials."
id: ComparableBillOfMaterialKeyOperationFilterInput
"The ID of the production item of this bill of materials."
productionItemId: ComparableProdItemKeyOperationFilterInput
"The version of this bill of materials."
version: ComparableInt32OperationFilterInput
"The name of this production bill of materials."
name: StringOperationFilterInput
"The description of this production bill of materials."
description: StringOperationFilterInput
"The status of this production bill of materials."
state: ComparableBillOfMaterialsStateOperationFilterInput
"The timestamp when this bill of materials was created."
createDate: ComparableDateTimeOffsetOperationFilterInput
"The timestamp when this bill of materials was last modified, or NULL if this bill of materials has not been modified yet."
updateDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The ID of the user who last modified this bill of materials, or NULL if this bill of materials has not been modified yet."
updateUserId: ComparableBenutzerKeyOperationFilterInput
"The timestamp when this bill of materials was activated, or NULL if this bill of materials has not been activated yet."
activationDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The last calculated producible stock."
producibleStock: ComparableDecimalOperationFilterInput
"The timestamp when the producible stock was last calculated, or NULL if it has not been calculated yet."
producibleStockCalculationDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Specifies requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsShelfLifeEndDateRequirements: ComparableOverallComponentPostingsInventoryAccountingDataRequirementsOperationFilterInput
"Specifies requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsBatchNumberRequirements: ComparableOverallComponentPostingsInventoryAccountingDataRequirementsOperationFilterInput
"Indicates how the shelf life end date of a product is calculated after completing a lot."
shelfLifeEndDateGenerationMode: ComparableShelfLifeEndDateGenerationModeOperationFilterInput
"A time span that is added when calculating the shelf life end date of a product after completing a lot."
additionalShelfLifeEndDateTime: ComparableNullableOfTimeSpanOperationFilterInput
}
"A bill of materials for a production item. It defines which operations must be performed and which components are required to produce the production item."
input BillOfMaterialsSortInput {
"The ID of this bill of materials."
id: BillOfMaterialKeySortInput @cost(weight: "10")
"The ID of the production item of this bill of materials."
productionItemId: ProdItemKeySortInput @cost(weight: "10")
"The version of this bill of materials."
version: SortEnumType @cost(weight: "10")
"The name of this production bill of materials."
name: SortEnumType @cost(weight: "10")
"The description of this production bill of materials."
description: SortEnumType @cost(weight: "10")
"The status of this production bill of materials."
state: SortEnumType @cost(weight: "10")
"The timestamp when this bill of materials was created."
createDate: SortEnumType @cost(weight: "10")
"The timestamp when this bill of materials was last modified, or NULL if this bill of materials has not been modified yet."
updateDate: SortEnumType @cost(weight: "10")
"The ID of the user who last modified this bill of materials, or NULL if this bill of materials has not been modified yet."
updateUserId: BenutzerKeySortInput @cost(weight: "10")
"The timestamp when this bill of materials was activated, or NULL if this bill of materials has not been activated yet."
activationDate: SortEnumType @cost(weight: "10")
"The last calculated producible stock."
producibleStock: SortEnumType @cost(weight: "10")
"The timestamp when the producible stock was last calculated, or NULL if it has not been calculated yet."
producibleStockCalculationDate: SortEnumType @cost(weight: "10")
"Specifies requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsShelfLifeEndDateRequirements: SortEnumType @cost(weight: "10")
"Specifies requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This specification can be overridden for individual components of this bill of materials."
componentPostingsBatchNumberRequirements: SortEnumType @cost(weight: "10")
"Indicates how the shelf life end date of a product is calculated after completing a lot."
shelfLifeEndDateGenerationMode: SortEnumType @cost(weight: "10")
"A time span that is added when calculating the shelf life end date of a product after completing a lot."
additionalShelfLifeEndDateTime: SortEnumType @cost(weight: "10")
}
"Single row of the bin locations overview list."
input BinLocationListItemFilterInput {
and: [BinLocationListItemFilterInput!]
or: [BinLocationListItemFilterInput!]
"Unique bin location identifier."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Bin location name (unique within the warehouse)."
name: StringOperationFilterInput
"Warehouse that owns this bin location."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Current status of the bin location (0=Active, 1=Deactivated, 2=Locked)."
status: ComparableInt32OperationFilterInput
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: ComparableInt32OperationFilterInput
"Optional sort order."
sort: ComparableNullableOfInt32OperationFilterInput
}
"Single row of the bin locations overview list."
input BinLocationListItemSortInput {
"Unique bin location identifier."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Bin location name (unique within the warehouse)."
name: SortEnumType @cost(weight: "10")
"Current status of the bin location (0=Active, 1=Deactivated, 2=Locked)."
status: SortEnumType @cost(weight: "10")
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: SortEnumType @cost(weight: "10")
"Optional sort order."
sort: SortEnumType @cost(weight: "10")
}
"Occupancy data (fill factors) for a single bin location in a warehouse."
input BinLocationOccupancyItemFilterInput {
and: [BinLocationOccupancyItemFilterInput!]
or: [BinLocationOccupancyItemFilterInput!]
"Unique bin location identifier."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Volume fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
volumeFillFactor: ComparableDecimalOperationFilterInput
"Weight fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
weightFillFactor: ComparableDecimalOperationFilterInput
"Date of the last WMS inventory count for this bin location. Null if never inventoried."
lastInventoryDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
}
"Occupancy data (fill factors) for a single bin location in a warehouse."
input BinLocationOccupancyItemSortInput {
"Unique bin location identifier."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Volume fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
volumeFillFactor: SortEnumType @cost(weight: "10")
"Weight fill factor as a percentage (0 to unlimited). May exceed 100 when overfilled."
weightFillFactor: SortEnumType @cost(weight: "10")
"Date of the last WMS inventory count for this bin location. Null if never inventoried."
lastInventoryDate: SortEnumType @cost(weight: "10")
}
"Single row of the bin location pick heatmap query."
input BinLocationPickHeatmapItemFilterInput {
and: [BinLocationPickHeatmapItemFilterInput!]
or: [BinLocationPickHeatmapItemFilterInput!]
"Id of the bin location."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Warehouse that owns this bin location."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Number of completed pick operations in the selected time period."
pickCount: ComparableInt32OperationFilterInput
"Total quantity picked in the selected time period."
pickQuantity: ComparableDecimalOperationFilterInput
}
"Single row of the bin location pick heatmap query."
input BinLocationPickHeatmapItemSortInput {
"Id of the bin location."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Warehouse that owns this bin location."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Number of completed pick operations in the selected time period."
pickCount: SortEnumType @cost(weight: "10")
"Total quantity picked in the selected time period."
pickQuantity: SortEnumType @cost(weight: "10")
}
"Recalculate prices, discounts, and taxes for a sales entity from a client-supplied state without persisting it. - Request"
input CalculateSalesEntityCommandRequestInput {
"The sales entity calculation request model in the original state before any changes."
calculateSalesEntityRequest: CreateCalculateSalesEntityRequestInput!
"The mode for tax recalculation (NoRecalculation, KeepNetPrices, KeepGrossPrices)."
recalculateTaxMode: RecalculateTaxMode!
"The history of changes made to the sales entity request. Changes are processed in the order specified."
changes: [CreateCalculateSalesEntityRequestChangeInput!]!
}
"Calculate prices, discounts, and taxes for a sales order without persisting it. - Request"
input CalculateSalesOrderCommandRequestInput {
"The sales order calculation request model in the original state before any changes."
calculateSalesOrderRequest: CreateCalculateSalesOrderRequestInput!
"The mode for tax recalculation (NoRecalculation, KeepNetPrices, KeepGrossPrices)."
recalculateTaxMode: RecalculateTaxMode!
"The history of changes made to the sales order request. Changes are processed in the order specified."
changes: [CreateCalculateSalesOrderRequestChangeInput!]!
}
"Cancel marketplace order cancellation request uploads. - Request"
input CancelMarketplaceOrderCancellationRequestUploadCommandRequestInput {
"Marketplace order cancellation event keys whose upload should be cancelled."
orderCancellationEventKeys: [ID]!
}
"Cancel a sales invoice - Request"
input CancelSalesInvoiceCommandRequestInput {
"The ID of the sales invoice to cancel."
salesInvoiceId: ID!
"The reason for cancelling the invoice."
cancellationReasonId: ID!
"An optional comment explaining the cancellation."
cancellationComment: String
}
"Cancel a sales invoice correction - Request"
input CancelSalesInvoiceCorrectionCommandRequestInput {
"The ID of the sales invoice correction to cancel."
salesInvoiceCorrectionId: ID!
"The reason for cancelling the sales invoice correction."
cancellationReasonId: ID!
"An optional comment explaining the cancellation."
cancellationComment: String
}
"Cancel a sales quotation - Request"
input CancelSalesQuotationCommandRequestInput {
"The ID of the sales quotation to cancel."
salesQuotationId: ID!
"The reason for cancelling the quotation."
cancellationReasonId: ID!
"An optional comment explaining the cancellation."
cancellationComment: String
}
"Single Row of the category overview"
input CategoryListItemFilterInput {
and: [CategoryListItemFilterInput!]
or: [CategoryListItemFilterInput!]
"Id of the category."
id: ComparableKategorieKeyOperationFilterInput
"Id of the parent category."
parentId: ComparableKategorieKeyOperationFilterInput
}
"Single Row of the category overview"
input CategoryListItemSortInput {
"Id of the category."
id: KategorieKeySortInput @cost(weight: "10")
"Sortnumber of the category."
sortNumber: SortEnumType @cost(weight: "10")
"Id of the parent category."
parentId: KategorieKeySortInput @cost(weight: "10")
"Default Category Name"
name: SortEnumType @cost(weight: "10")
}
"A command to modify an existing company, including identification, contact, banking, and tax information. - Request"
input ChangeCompanyCommandRequestInput {
"The unique identifier of the company to modify."
companyId: ID!
"The name of the company."
companyName: String
"The owner of the company."
owner: String
"The street address of the company."
street: String
"The postal code of the company."
postalCode: String
"The city of the company."
city: String
"The country name of the company."
country: String
"The country ISO code of the company."
countryIsoCode: String
"The phone number of the company."
phone: String
"The fax number of the company."
fax: String
"The email address of the company."
emailAddress: String
"The website URL of the company."
website: String
"The bank code of the company."
bankCode: String
"The bank account number of the company."
accountNumber: String
"The bank name of the company."
bankName: String
"The tax identification number of the company."
taxId: String
"The International Bank Account Number (IBAN) of the company."
iban: String
"The Bank Identifier Code (BIC) of the company."
bic: String
"The account holder name of the company."
accountHolder: String
"The creditor ID for SEPA direct debit."
creditorId: String
"The PayPal email address of the company."
payPalEmailAddress: String
"A value indicating whether the owner of the company is a small business owner (Kleinunternehmer). This affects the VAT handling of the company."
isSmallBusinessOwner: Boolean
"The DHL Intraship customer ID of the company."
dhlIntrashipCustomerId: String
"The UPS customer ID of the company."
upsCustomerId: String
"The collection of VAT identifiers for this company. When provided, replaces all existing VAT identifiers."
companyVatIdentifiers: [UpdateCompanyVatIdDetailsItemInput]
}
"Modifies an existing regular item with all specified properties. This command enables complete reconfiguration of an item including identifiers, descriptions, prices, measurements, and miscellaneous information. - Request"
input ChangeItemCommandRequestInput {
"Unique ID of the item to be modified - this key is used for all further operations with the item."
itemId: ID!
"The ID of the product group to which the item should be assigned. Product groups serve for categorical classification of items for reports and analyses."
productGroupId: ID
"The ID of the shipping class to which the item should be assigned."
shippingClassId: ID
"The ID of the manufacturer to which the item should be assigned."
manufacturerId: ID
"Category assignments of the item. Defines all categories to which the item should be assigned for better organization and navigation."
categories: UpdateItemCategoriesInput
"Identifiers of the item with all relevant markings and numbers for unique identification of the item in various systems."
identifiers: UpdateItemIdentifiersInput
"Descriptions of the item in different languages and for different platforms\/sales channels. Includes names, short and long descriptions as well as SEO-relevant information."
descriptions: UpdateItemDescriptionsInput
"Price structures of the item for different sales channels, customer groups and individual customers. Includes sales prices, purchase prices and tier prices."
prices: UpdateItemPricesInput
"Physical dimensions and weight specifications of the item for storage, shipping and product presentation. Important for shipping cost calculations and storage space optimization."
measurements: UpdateItemMeasurementsInput
"tbd"
images: UpdateItemImagesInput
"Custom fields defined for the item to store additional information. Useful for special requirements or integrations."
customFields: UpdateItemCustomFieldsInput
"Suppliers associated with the item including supplier-specific information such as purchase prices, delivery times and order intervals."
suppliers: UpdateItemSuppliersInput
"Variations of an item"
variations: UpdateItemVariationsInput
"Delivery status id determining the availability display of the item (e.g. 'immediately available', '2-3 days'). Tab 'Sonstiges'."
deliveryStatusId: ID
"Indicates whether the item can be included in exported price lists. Tab 'Sonstiges'."
includeInPriceList: Boolean
"Indicates whether order suggestions should be ignored for this item. If true, the item will not appear in automatic order suggestions. Tab 'Sonstiges'."
ignoreOrderSuggestions: Boolean
"Indicates whether the item is not eligible for discounts (Rabatte ignorieren \/ Nicht Rabattfähig). Tab 'Sonstiges'."
ignoreDiscounts: Boolean
"Country of origin (Herkunftsland) - ISO code or country name. Max length 64. Tab 'Sonstiges'."
countryOfOrigin: String
"Additional notes (Anmerkung) for the item - unlimited length. Tab 'Sonstiges'."
notes: String
"Features of an item"
features: UpdateItemFeaturesInput
"Attributes of an item"
attributes: UpdateItemAttributesInput
"UnitPricing information of an item"
unitPricing: UpdateItemUnitPricingInput
"SpecialPrices information of an item"
specialPrices: UpdateItemSpecialPricesInput
"ItemStorageConstraints information of an item"
storageConstraints: UpdateItemStorageConstraintsInput
"CrosssellingGroups of an item"
crosssellingGroups: UpdateItemCrosssellingGroupsInput
}
"Modifies an existing Package Weight - Request"
input ChangePackageWeightCommandRequestInput {
"ID of the Package to be modified"
packageId: String!
"The new Weight of the Package"
weight: Decimal!
}
"Single row of the company table"
input CompanyListItemFilterInput {
and: [CompanyListItemFilterInput!]
or: [CompanyListItemFilterInput!]
"Unique ID to identify a company (kFirma)."
id: ComparableFirmaKeyOperationFilterInput
"Name of the company."
companyName: StringOperationFilterInput
"Owner of the company."
owner: StringOperationFilterInput
"Tax identification number."
taxId: StringOperationFilterInput
}
"Single row of the company table"
input CompanyListItemSortInput {
"Unique ID to identify a company (kFirma)."
id: FirmaKeySortInput @cost(weight: "10")
"Name of the company."
companyName: SortEnumType @cost(weight: "10")
"Owner of the company."
owner: SortEnumType @cost(weight: "10")
"Tax identification number."
taxId: SortEnumType @cost(weight: "10")
}
input ComparableArtikelKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBenutzerKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBildKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBillOfMaterialKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableBillOfMaterialsStateOperationFilterInput {
eq: BillOfMaterialsState @cost(weight: "10")
neq: BillOfMaterialsState @cost(weight: "10")
in: [BillOfMaterialsState!] @cost(weight: "10")
nin: [BillOfMaterialsState!] @cost(weight: "10")
gt: BillOfMaterialsState @cost(weight: "10")
ngt: BillOfMaterialsState @cost(weight: "10")
gte: BillOfMaterialsState @cost(weight: "10")
ngte: BillOfMaterialsState @cost(weight: "10")
lt: BillOfMaterialsState @cost(weight: "10")
nlt: BillOfMaterialsState @cost(weight: "10")
lte: BillOfMaterialsState @cost(weight: "10")
nlte: BillOfMaterialsState @cost(weight: "10")
}
input ComparableBooleanOperationFilterInput {
eq: Boolean @cost(weight: "10")
neq: Boolean @cost(weight: "10")
in: [Boolean!] @cost(weight: "10")
nin: [Boolean!] @cost(weight: "10")
gt: Boolean @cost(weight: "10")
ngt: Boolean @cost(weight: "10")
gte: Boolean @cost(weight: "10")
ngte: Boolean @cost(weight: "10")
lt: Boolean @cost(weight: "10")
nlt: Boolean @cost(weight: "10")
lte: Boolean @cost(weight: "10")
nlte: Boolean @cost(weight: "10")
}
input ComparableBuchungsArtKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableByteOperationFilterInput {
eq: Byte @cost(weight: "10")
neq: Byte @cost(weight: "10")
in: [Byte!] @cost(weight: "10")
nin: [Byte!] @cost(weight: "10")
gt: Byte @cost(weight: "10")
ngt: Byte @cost(weight: "10")
gte: Byte @cost(weight: "10")
ngte: Byte @cost(weight: "10")
lt: Byte @cost(weight: "10")
nlt: Byte @cost(weight: "10")
lte: Byte @cost(weight: "10")
nlte: Byte @cost(weight: "10")
}
input ComparableCustomFieldReferenceTypeOperationFilterInput {
eq: CustomFieldReferenceType @cost(weight: "10")
neq: CustomFieldReferenceType @cost(weight: "10")
in: [CustomFieldReferenceType!] @cost(weight: "10")
nin: [CustomFieldReferenceType!] @cost(weight: "10")
gt: CustomFieldReferenceType @cost(weight: "10")
ngt: CustomFieldReferenceType @cost(weight: "10")
gte: CustomFieldReferenceType @cost(weight: "10")
ngte: CustomFieldReferenceType @cost(weight: "10")
lt: CustomFieldReferenceType @cost(weight: "10")
nlt: CustomFieldReferenceType @cost(weight: "10")
lte: CustomFieldReferenceType @cost(weight: "10")
nlte: CustomFieldReferenceType @cost(weight: "10")
}
input ComparableCustomFieldTypeOperationFilterInput {
eq: CustomFieldType @cost(weight: "10")
neq: CustomFieldType @cost(weight: "10")
in: [CustomFieldType!] @cost(weight: "10")
nin: [CustomFieldType!] @cost(weight: "10")
gt: CustomFieldType @cost(weight: "10")
ngt: CustomFieldType @cost(weight: "10")
gte: CustomFieldType @cost(weight: "10")
ngte: CustomFieldType @cost(weight: "10")
lt: CustomFieldType @cost(weight: "10")
nlt: CustomFieldType @cost(weight: "10")
lte: CustomFieldType @cost(weight: "10")
nlte: CustomFieldType @cost(weight: "10")
}
input ComparableDateTimeOffsetOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime!] @cost(weight: "10")
nin: [DateTime!] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableDateTimeOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime!] @cost(weight: "10")
nin: [DateTime!] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableDecimalOperationFilterInput {
eq: Decimal @cost(weight: "10")
neq: Decimal @cost(weight: "10")
in: [Decimal!] @cost(weight: "10")
nin: [Decimal!] @cost(weight: "10")
gt: Decimal @cost(weight: "10")
ngt: Decimal @cost(weight: "10")
gte: Decimal @cost(weight: "10")
ngte: Decimal @cost(weight: "10")
lt: Decimal @cost(weight: "10")
nlt: Decimal @cost(weight: "10")
lte: Decimal @cost(weight: "10")
nlte: Decimal @cost(weight: "10")
}
input ComparableDeliveryCompleteStatusOperationFilterInput {
eq: DeliveryCompleteStatus @cost(weight: "10")
neq: DeliveryCompleteStatus @cost(weight: "10")
in: [DeliveryCompleteStatus!] @cost(weight: "10")
nin: [DeliveryCompleteStatus!] @cost(weight: "10")
gt: DeliveryCompleteStatus @cost(weight: "10")
ngt: DeliveryCompleteStatus @cost(weight: "10")
gte: DeliveryCompleteStatus @cost(weight: "10")
ngte: DeliveryCompleteStatus @cost(weight: "10")
lt: DeliveryCompleteStatus @cost(weight: "10")
nlt: DeliveryCompleteStatus @cost(weight: "10")
lte: DeliveryCompleteStatus @cost(weight: "10")
nlte: DeliveryCompleteStatus @cost(weight: "10")
}
input ComparableDeliveryStatusOperationFilterInput {
eq: DeliveryStatus @cost(weight: "10")
neq: DeliveryStatus @cost(weight: "10")
in: [DeliveryStatus!] @cost(weight: "10")
nin: [DeliveryStatus!] @cost(weight: "10")
gt: DeliveryStatus @cost(weight: "10")
ngt: DeliveryStatus @cost(weight: "10")
gte: DeliveryStatus @cost(weight: "10")
ngte: DeliveryStatus @cost(weight: "10")
lt: DeliveryStatus @cost(weight: "10")
nlt: DeliveryStatus @cost(weight: "10")
lte: DeliveryStatus @cost(weight: "10")
nlte: DeliveryStatus @cost(weight: "10")
}
input ComparableDispositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableEigenesFeldKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableExternalSalesInvoiceTypeOperationFilterInput {
eq: ExternalSalesInvoiceType @cost(weight: "10")
neq: ExternalSalesInvoiceType @cost(weight: "10")
in: [ExternalSalesInvoiceType!] @cost(weight: "10")
nin: [ExternalSalesInvoiceType!] @cost(weight: "10")
gt: ExternalSalesInvoiceType @cost(weight: "10")
ngt: ExternalSalesInvoiceType @cost(weight: "10")
gte: ExternalSalesInvoiceType @cost(weight: "10")
ngte: ExternalSalesInvoiceType @cost(weight: "10")
lt: ExternalSalesInvoiceType @cost(weight: "10")
nlt: ExternalSalesInvoiceType @cost(weight: "10")
lte: ExternalSalesInvoiceType @cost(weight: "10")
nlte: ExternalSalesInvoiceType @cost(weight: "10")
}
input ComparableExternerBelegKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableExternerBelegPositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableExternerBelegTransaktionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableFirmaKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableGutschriftKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableGutschriftPosKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableHerstellerKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableInt32OperationFilterInput {
eq: Int @cost(weight: "10")
neq: Int @cost(weight: "10")
in: [Int!] @cost(weight: "10")
nin: [Int!] @cost(weight: "10")
gt: Int @cost(weight: "10")
ngt: Int @cost(weight: "10")
gte: Int @cost(weight: "10")
ngte: Int @cost(weight: "10")
lt: Int @cost(weight: "10")
nlt: Int @cost(weight: "10")
lte: Int @cost(weight: "10")
nlte: Int @cost(weight: "10")
}
input ComparableInvoicePaymentStatusOperationFilterInput {
eq: InvoicePaymentStatus @cost(weight: "10")
neq: InvoicePaymentStatus @cost(weight: "10")
in: [InvoicePaymentStatus!] @cost(weight: "10")
nin: [InvoicePaymentStatus!] @cost(weight: "10")
gt: InvoicePaymentStatus @cost(weight: "10")
ngt: InvoicePaymentStatus @cost(weight: "10")
gte: InvoicePaymentStatus @cost(weight: "10")
ngte: InvoicePaymentStatus @cost(weight: "10")
lt: InvoicePaymentStatus @cost(weight: "10")
nlt: InvoicePaymentStatus @cost(weight: "10")
lte: InvoicePaymentStatus @cost(weight: "10")
nlte: InvoicePaymentStatus @cost(weight: "10")
}
input ComparableInvoiceStatusOperationFilterInput {
eq: InvoiceStatus @cost(weight: "10")
neq: InvoiceStatus @cost(weight: "10")
in: [InvoiceStatus!] @cost(weight: "10")
nin: [InvoiceStatus!] @cost(weight: "10")
gt: InvoiceStatus @cost(weight: "10")
ngt: InvoiceStatus @cost(weight: "10")
gte: InvoiceStatus @cost(weight: "10")
ngte: InvoiceStatus @cost(weight: "10")
lt: InvoiceStatus @cost(weight: "10")
nlt: InvoiceStatus @cost(weight: "10")
lte: InvoiceStatus @cost(weight: "10")
nlte: InvoiceStatus @cost(weight: "10")
}
input ComparableItemDescriptionTypeOperationFilterInput {
eq: ItemDescriptionType @cost(weight: "10")
neq: ItemDescriptionType @cost(weight: "10")
in: [ItemDescriptionType!] @cost(weight: "10")
nin: [ItemDescriptionType!] @cost(weight: "10")
gt: ItemDescriptionType @cost(weight: "10")
ngt: ItemDescriptionType @cost(weight: "10")
gte: ItemDescriptionType @cost(weight: "10")
ngte: ItemDescriptionType @cost(weight: "10")
lt: ItemDescriptionType @cost(weight: "10")
nlt: ItemDescriptionType @cost(weight: "10")
lte: ItemDescriptionType @cost(weight: "10")
nlte: ItemDescriptionType @cost(weight: "10")
}
input ComparableKategorieKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableKundeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableKundenGruppeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableKundenKategorieKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLhmKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLhmTypeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLieferantKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLieferantenArtikelKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLotSizeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableLotTypeOperationFilterInput {
eq: LotType @cost(weight: "10")
neq: LotType @cost(weight: "10")
in: [LotType!] @cost(weight: "10")
nin: [LotType!] @cost(weight: "10")
gt: LotType @cost(weight: "10")
ngt: LotType @cost(weight: "10")
gte: LotType @cost(weight: "10")
ngte: LotType @cost(weight: "10")
lt: LotType @cost(weight: "10")
nlt: LotType @cost(weight: "10")
lte: LotType @cost(weight: "10")
nlte: LotType @cost(weight: "10")
}
input ComparableMarketplaceExternalDocumentTypeOperationFilterInput {
eq: MarketplaceExternalDocumentType @cost(weight: "10")
neq: MarketplaceExternalDocumentType @cost(weight: "10")
in: [MarketplaceExternalDocumentType!] @cost(weight: "10")
nin: [MarketplaceExternalDocumentType!] @cost(weight: "10")
gt: MarketplaceExternalDocumentType @cost(weight: "10")
ngt: MarketplaceExternalDocumentType @cost(weight: "10")
gte: MarketplaceExternalDocumentType @cost(weight: "10")
ngte: MarketplaceExternalDocumentType @cost(weight: "10")
lt: MarketplaceExternalDocumentType @cost(weight: "10")
nlt: MarketplaceExternalDocumentType @cost(weight: "10")
lte: MarketplaceExternalDocumentType @cost(weight: "10")
nlte: MarketplaceExternalDocumentType @cost(weight: "10")
}
input ComparableMarketplaceInvoiceCorrectionUploadStatusOperationFilterInput {
eq: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
neq: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
in: [MarketplaceInvoiceCorrectionUploadStatus!] @cost(weight: "10")
nin: [MarketplaceInvoiceCorrectionUploadStatus!] @cost(weight: "10")
gt: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
ngt: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
gte: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
ngte: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
lt: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
nlt: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
lte: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
nlte: MarketplaceInvoiceCorrectionUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceInvoicePdfPrintStatusOperationFilterInput {
eq: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
neq: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
in: [MarketplaceInvoicePdfPrintStatus!] @cost(weight: "10")
nin: [MarketplaceInvoicePdfPrintStatus!] @cost(weight: "10")
gt: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
ngt: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
gte: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
ngte: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
lt: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
nlt: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
lte: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
nlte: MarketplaceInvoicePdfPrintStatus @cost(weight: "10")
}
input ComparableMarketplaceInvoicePdfUploadStatusOperationFilterInput {
eq: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
neq: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
in: [MarketplaceInvoicePdfUploadStatus!] @cost(weight: "10")
nin: [MarketplaceInvoicePdfUploadStatus!] @cost(weight: "10")
gt: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
ngt: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
gte: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
ngte: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
lt: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
nlt: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
lte: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
nlte: MarketplaceInvoicePdfUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceNotificationSeverityOperationFilterInput {
eq: MarketplaceNotificationSeverity @cost(weight: "10")
neq: MarketplaceNotificationSeverity @cost(weight: "10")
in: [MarketplaceNotificationSeverity!] @cost(weight: "10")
nin: [MarketplaceNotificationSeverity!] @cost(weight: "10")
gt: MarketplaceNotificationSeverity @cost(weight: "10")
ngt: MarketplaceNotificationSeverity @cost(weight: "10")
gte: MarketplaceNotificationSeverity @cost(weight: "10")
ngte: MarketplaceNotificationSeverity @cost(weight: "10")
lt: MarketplaceNotificationSeverity @cost(weight: "10")
nlt: MarketplaceNotificationSeverity @cost(weight: "10")
lte: MarketplaceNotificationSeverity @cost(weight: "10")
nlte: MarketplaceNotificationSeverity @cost(weight: "10")
}
input ComparableMarketplaceNotificationTypeOperationFilterInput {
eq: MarketplaceNotificationType @cost(weight: "10")
neq: MarketplaceNotificationType @cost(weight: "10")
in: [MarketplaceNotificationType!] @cost(weight: "10")
nin: [MarketplaceNotificationType!] @cost(weight: "10")
gt: MarketplaceNotificationType @cost(weight: "10")
ngt: MarketplaceNotificationType @cost(weight: "10")
gte: MarketplaceNotificationType @cost(weight: "10")
ngte: MarketplaceNotificationType @cost(weight: "10")
lt: MarketplaceNotificationType @cost(weight: "10")
nlt: MarketplaceNotificationType @cost(weight: "10")
lte: MarketplaceNotificationType @cost(weight: "10")
nlte: MarketplaceNotificationType @cost(weight: "10")
}
input ComparableMarketplaceOfferTypeOperationFilterInput {
eq: MarketplaceOfferType @cost(weight: "10")
neq: MarketplaceOfferType @cost(weight: "10")
in: [MarketplaceOfferType!] @cost(weight: "10")
nin: [MarketplaceOfferType!] @cost(weight: "10")
gt: MarketplaceOfferType @cost(weight: "10")
ngt: MarketplaceOfferType @cost(weight: "10")
gte: MarketplaceOfferType @cost(weight: "10")
ngte: MarketplaceOfferType @cost(weight: "10")
lt: MarketplaceOfferType @cost(weight: "10")
nlt: MarketplaceOfferType @cost(weight: "10")
lte: MarketplaceOfferType @cost(weight: "10")
nlte: MarketplaceOfferType @cost(weight: "10")
}
input ComparableMarketplaceOfferViewStatusOperationFilterInput {
eq: MarketplaceOfferViewStatus @cost(weight: "10")
neq: MarketplaceOfferViewStatus @cost(weight: "10")
in: [MarketplaceOfferViewStatus!] @cost(weight: "10")
nin: [MarketplaceOfferViewStatus!] @cost(weight: "10")
gt: MarketplaceOfferViewStatus @cost(weight: "10")
ngt: MarketplaceOfferViewStatus @cost(weight: "10")
gte: MarketplaceOfferViewStatus @cost(weight: "10")
ngte: MarketplaceOfferViewStatus @cost(weight: "10")
lt: MarketplaceOfferViewStatus @cost(weight: "10")
nlt: MarketplaceOfferViewStatus @cost(weight: "10")
lte: MarketplaceOfferViewStatus @cost(weight: "10")
nlte: MarketplaceOfferViewStatus @cost(weight: "10")
}
input ComparableMarketplaceOrderCancellationRequestUploadStatusOperationFilterInput {
eq: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
neq: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
in: [MarketplaceOrderCancellationRequestUploadStatus!] @cost(weight: "10")
nin: [MarketplaceOrderCancellationRequestUploadStatus!] @cost(weight: "10")
gt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
ngt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
gte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
ngte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
lt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
nlt: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
lte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
nlte: MarketplaceOrderCancellationRequestUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceOrderCancellationUploadStatusOperationFilterInput {
eq: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
neq: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
in: [MarketplaceOrderCancellationUploadStatus!] @cost(weight: "10")
nin: [MarketplaceOrderCancellationUploadStatus!] @cost(weight: "10")
gt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
ngt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
gte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
ngte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
lt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
nlt: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
lte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
nlte: MarketplaceOrderCancellationUploadStatus @cost(weight: "10")
}
input ComparableMarketplacePaymentUploadStatusOperationFilterInput {
eq: MarketplacePaymentUploadStatus @cost(weight: "10")
neq: MarketplacePaymentUploadStatus @cost(weight: "10")
in: [MarketplacePaymentUploadStatus!] @cost(weight: "10")
nin: [MarketplacePaymentUploadStatus!] @cost(weight: "10")
gt: MarketplacePaymentUploadStatus @cost(weight: "10")
ngt: MarketplacePaymentUploadStatus @cost(weight: "10")
gte: MarketplacePaymentUploadStatus @cost(weight: "10")
ngte: MarketplacePaymentUploadStatus @cost(weight: "10")
lt: MarketplacePaymentUploadStatus @cost(weight: "10")
nlt: MarketplacePaymentUploadStatus @cost(weight: "10")
lte: MarketplacePaymentUploadStatus @cost(weight: "10")
nlte: MarketplacePaymentUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceReturnUploadStatusOperationFilterInput {
eq: MarketplaceReturnUploadStatus @cost(weight: "10")
neq: MarketplaceReturnUploadStatus @cost(weight: "10")
in: [MarketplaceReturnUploadStatus!] @cost(weight: "10")
nin: [MarketplaceReturnUploadStatus!] @cost(weight: "10")
gt: MarketplaceReturnUploadStatus @cost(weight: "10")
ngt: MarketplaceReturnUploadStatus @cost(weight: "10")
gte: MarketplaceReturnUploadStatus @cost(weight: "10")
ngte: MarketplaceReturnUploadStatus @cost(weight: "10")
lt: MarketplaceReturnUploadStatus @cost(weight: "10")
nlt: MarketplaceReturnUploadStatus @cost(weight: "10")
lte: MarketplaceReturnUploadStatus @cost(weight: "10")
nlte: MarketplaceReturnUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceShippingInformationUploadStatusOperationFilterInput {
eq: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
neq: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
in: [MarketplaceShippingInformationUploadStatus!] @cost(weight: "10")
nin: [MarketplaceShippingInformationUploadStatus!] @cost(weight: "10")
gt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
ngt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
gte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
ngte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
lt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
nlt: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
lte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
nlte: MarketplaceShippingInformationUploadStatus @cost(weight: "10")
}
input ComparableMarketplaceUploadQueueStatusOperationFilterInput {
eq: MarketplaceUploadQueueStatus @cost(weight: "10")
neq: MarketplaceUploadQueueStatus @cost(weight: "10")
in: [MarketplaceUploadQueueStatus!] @cost(weight: "10")
nin: [MarketplaceUploadQueueStatus!] @cost(weight: "10")
gt: MarketplaceUploadQueueStatus @cost(weight: "10")
ngt: MarketplaceUploadQueueStatus @cost(weight: "10")
gte: MarketplaceUploadQueueStatus @cost(weight: "10")
ngte: MarketplaceUploadQueueStatus @cost(weight: "10")
lt: MarketplaceUploadQueueStatus @cost(weight: "10")
nlt: MarketplaceUploadQueueStatus @cost(weight: "10")
lte: MarketplaceUploadQueueStatus @cost(weight: "10")
nlte: MarketplaceUploadQueueStatus @cost(weight: "10")
}
input ComparableNullableOfByteOperationFilterInput {
eq: Byte @cost(weight: "10")
neq: Byte @cost(weight: "10")
in: [Byte] @cost(weight: "10")
nin: [Byte] @cost(weight: "10")
gt: Byte @cost(weight: "10")
ngt: Byte @cost(weight: "10")
gte: Byte @cost(weight: "10")
ngte: Byte @cost(weight: "10")
lt: Byte @cost(weight: "10")
nlt: Byte @cost(weight: "10")
lte: Byte @cost(weight: "10")
nlte: Byte @cost(weight: "10")
}
input ComparableNullableOfDateTimeOffsetOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime] @cost(weight: "10")
nin: [DateTime] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableNullableOfDateTimeOperationFilterInput {
eq: DateTime @cost(weight: "10")
neq: DateTime @cost(weight: "10")
in: [DateTime] @cost(weight: "10")
nin: [DateTime] @cost(weight: "10")
gt: DateTime @cost(weight: "10")
ngt: DateTime @cost(weight: "10")
gte: DateTime @cost(weight: "10")
ngte: DateTime @cost(weight: "10")
lt: DateTime @cost(weight: "10")
nlt: DateTime @cost(weight: "10")
lte: DateTime @cost(weight: "10")
nlte: DateTime @cost(weight: "10")
}
input ComparableNullableOfDecimalOperationFilterInput {
eq: Decimal @cost(weight: "10")
neq: Decimal @cost(weight: "10")
in: [Decimal] @cost(weight: "10")
nin: [Decimal] @cost(weight: "10")
gt: Decimal @cost(weight: "10")
ngt: Decimal @cost(weight: "10")
gte: Decimal @cost(weight: "10")
ngte: Decimal @cost(weight: "10")
lt: Decimal @cost(weight: "10")
nlt: Decimal @cost(weight: "10")
lte: Decimal @cost(weight: "10")
nlte: Decimal @cost(weight: "10")
}
input ComparableNullableOfInt32OperationFilterInput {
eq: Int @cost(weight: "10")
neq: Int @cost(weight: "10")
in: [Int] @cost(weight: "10")
nin: [Int] @cost(weight: "10")
gt: Int @cost(weight: "10")
ngt: Int @cost(weight: "10")
gte: Int @cost(weight: "10")
ngte: Int @cost(weight: "10")
lt: Int @cost(weight: "10")
nlt: Int @cost(weight: "10")
lte: Int @cost(weight: "10")
nlte: Int @cost(weight: "10")
}
input ComparableNullableOfTaxSettingOperationFilterInput {
eq: TaxSetting @cost(weight: "10")
neq: TaxSetting @cost(weight: "10")
in: [TaxSetting] @cost(weight: "10")
nin: [TaxSetting] @cost(weight: "10")
gt: TaxSetting @cost(weight: "10")
ngt: TaxSetting @cost(weight: "10")
gte: TaxSetting @cost(weight: "10")
ngte: TaxSetting @cost(weight: "10")
lt: TaxSetting @cost(weight: "10")
nlt: TaxSetting @cost(weight: "10")
lte: TaxSetting @cost(weight: "10")
nlte: TaxSetting @cost(weight: "10")
}
input ComparableNullableOfTimeSpanOperationFilterInput {
eq: TimeSpan @cost(weight: "10")
neq: TimeSpan @cost(weight: "10")
in: [TimeSpan] @cost(weight: "10")
nin: [TimeSpan] @cost(weight: "10")
gt: TimeSpan @cost(weight: "10")
ngt: TimeSpan @cost(weight: "10")
gte: TimeSpan @cost(weight: "10")
ngte: TimeSpan @cost(weight: "10")
lt: TimeSpan @cost(weight: "10")
nlt: TimeSpan @cost(weight: "10")
lte: TimeSpan @cost(weight: "10")
nlte: TimeSpan @cost(weight: "10")
}
input ComparableOverallComponentPostingsInventoryAccountingDataRequirementsOperationFilterInput {
eq: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
neq: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
in: [OverallComponentPostingsInventoryAccountingDataRequirements!] @cost(weight: "10")
nin: [OverallComponentPostingsInventoryAccountingDataRequirements!] @cost(weight: "10")
gt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
ngt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
gte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
ngte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
lt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
nlt: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
lte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
nlte: OverallComponentPostingsInventoryAccountingDataRequirements @cost(weight: "10")
}
input ComparablePlattformKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableProdItemKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableProductionOrderKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableProductionTypeOperationFilterInput {
eq: ProductionType @cost(weight: "10")
neq: ProductionType @cost(weight: "10")
in: [ProductionType!] @cost(weight: "10")
nin: [ProductionType!] @cost(weight: "10")
gt: ProductionType @cost(weight: "10")
ngt: ProductionType @cost(weight: "10")
gte: ProductionType @cost(weight: "10")
ngte: ProductionType @cost(weight: "10")
lt: ProductionType @cost(weight: "10")
nlt: ProductionType @cost(weight: "10")
lte: ProductionType @cost(weight: "10")
nlte: ProductionType @cost(weight: "10")
}
input ComparableReadOnlyTypeOperationFilterInput {
eq: ReadOnlyType @cost(weight: "10")
neq: ReadOnlyType @cost(weight: "10")
in: [ReadOnlyType!] @cost(weight: "10")
nin: [ReadOnlyType!] @cost(weight: "10")
gt: ReadOnlyType @cost(weight: "10")
ngt: ReadOnlyType @cost(weight: "10")
gte: ReadOnlyType @cost(weight: "10")
ngte: ReadOnlyType @cost(weight: "10")
lt: ReadOnlyType @cost(weight: "10")
nlt: ReadOnlyType @cost(weight: "10")
lte: ReadOnlyType @cost(weight: "10")
nlte: ReadOnlyType @cost(weight: "10")
}
input ComparableRechnungKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableRechnungPositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableRechnungStornogrundKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableResourceCategoryKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableResourceTypeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableRueckhaltegrundKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSalesInvoiceTaxSettingOperationFilterInput {
eq: SalesInvoiceTaxSetting @cost(weight: "10")
neq: SalesInvoiceTaxSetting @cost(weight: "10")
in: [SalesInvoiceTaxSetting!] @cost(weight: "10")
nin: [SalesInvoiceTaxSetting!] @cost(weight: "10")
gt: SalesInvoiceTaxSetting @cost(weight: "10")
ngt: SalesInvoiceTaxSetting @cost(weight: "10")
gte: SalesInvoiceTaxSetting @cost(weight: "10")
ngte: SalesInvoiceTaxSetting @cost(weight: "10")
lt: SalesInvoiceTaxSetting @cost(weight: "10")
nlt: SalesInvoiceTaxSetting @cost(weight: "10")
lte: SalesInvoiceTaxSetting @cost(weight: "10")
nlte: SalesInvoiceTaxSetting @cost(weight: "10")
}
input ComparableScxChannelKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableScxShopKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSerialNumberTrackingModeOperationFilterInput {
eq: SerialNumberTrackingMode @cost(weight: "10")
neq: SerialNumberTrackingMode @cost(weight: "10")
in: [SerialNumberTrackingMode!] @cost(weight: "10")
nin: [SerialNumberTrackingMode!] @cost(weight: "10")
gt: SerialNumberTrackingMode @cost(weight: "10")
ngt: SerialNumberTrackingMode @cost(weight: "10")
gte: SerialNumberTrackingMode @cost(weight: "10")
ngte: SerialNumberTrackingMode @cost(weight: "10")
lt: SerialNumberTrackingMode @cost(weight: "10")
nlt: SerialNumberTrackingMode @cost(weight: "10")
lte: SerialNumberTrackingMode @cost(weight: "10")
nlte: SerialNumberTrackingMode @cost(weight: "10")
}
input ComparableShelfLifeEndDateGenerationModeOperationFilterInput {
eq: ShelfLifeEndDateGenerationMode @cost(weight: "10")
neq: ShelfLifeEndDateGenerationMode @cost(weight: "10")
in: [ShelfLifeEndDateGenerationMode!] @cost(weight: "10")
nin: [ShelfLifeEndDateGenerationMode!] @cost(weight: "10")
gt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
ngt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
gte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
ngte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
lt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
nlt: ShelfLifeEndDateGenerationMode @cost(weight: "10")
lte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
nlte: ShelfLifeEndDateGenerationMode @cost(weight: "10")
}
input ComparableShopKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSpracheKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSteuerklasseKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSteuerschluesselKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableSteuerzoneKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableTaxTypeOperationFilterInput {
eq: TaxType @cost(weight: "10")
neq: TaxType @cost(weight: "10")
in: [TaxType!] @cost(weight: "10")
nin: [TaxType!] @cost(weight: "10")
gt: TaxType @cost(weight: "10")
ngt: TaxType @cost(weight: "10")
gte: TaxType @cost(weight: "10")
ngte: TaxType @cost(weight: "10")
lt: TaxType @cost(weight: "10")
nlt: TaxType @cost(weight: "10")
lte: TaxType @cost(weight: "10")
nlte: TaxType @cost(weight: "10")
}
input ComparableVatIdSourceOperationFilterInput {
eq: VatIdSource @cost(weight: "10")
neq: VatIdSource @cost(weight: "10")
in: [VatIdSource!] @cost(weight: "10")
nin: [VatIdSource!] @cost(weight: "10")
gt: VatIdSource @cost(weight: "10")
ngt: VatIdSource @cost(weight: "10")
gte: VatIdSource @cost(weight: "10")
ngte: VatIdSource @cost(weight: "10")
lt: VatIdSource @cost(weight: "10")
nlt: VatIdSource @cost(weight: "10")
lte: VatIdSource @cost(weight: "10")
nlte: VatIdSource @cost(weight: "10")
}
input ComparableVerkaufAuftragKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVerkaufAuftragPositionKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVersandartKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVersandklasseKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableVorlagenSetKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWaehrungKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenLagerBereichKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenLagerEingangKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenLagerPlatzKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarengruppeKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWarenlagerKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableWorkbenchResourceKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableZahlungsartKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
input ComparableZustandKeyOperationFilterInput {
eq: ID @cost(weight: "10")
neq: ID @cost(weight: "10")
in: [ID] @cost(weight: "10")
nin: [ID] @cost(weight: "10")
gt: ID @cost(weight: "10")
ngt: ID @cost(weight: "10")
gte: ID @cost(weight: "10")
ngte: ID @cost(weight: "10")
lt: ID @cost(weight: "10")
nlt: ID @cost(weight: "10")
lte: ID @cost(weight: "10")
nlte: ID @cost(weight: "10")
}
"Configures a worker sync (interval and configuration values). - Request"
input ConfigureWorkerSyncCommandRequestInput {
"The id of the sync to configure."
syncId: ID!
"The new sync interval. When not sent the interval is left unchanged."
interval: TimeSpan
"The configuration values to assign. When not sent no configuration value is changed."
configurations: [WorkerSyncConfigAssignmentInput]
}
"Controls a worker sync (start, stop or restart). - Request"
input ControlWorkerSyncCommandRequestInput {
"The id of the sync to control."
syncId: ID!
"The control action to execute."
action: WorkerControlAction!
}
"- Request"
input CopyItemdetailsCommandRequestInput {
"The unique identifier of the source itemdetails to be copied."
copyDetailsFromItemId: ID!
"Transfer the itemdetails into the items identified by these unique identifiers."
copyDetailsIntoItemIds: [ID]!
"Specifies which properties and aspects of the source item should be duplicated to the new items."
copyOptions: CreateItemdetailsCopyOptionsInput!
}
"Definition of a country item"
input CountryItemFilterInput {
and: [CountryItemFilterInput!]
or: [CountryItemFilterInput!]
"The ISO code of the country"
countryIso: StringOperationFilterInput
"The name of the country"
name: StringOperationFilterInput
"The numeric ISO code of the country"
numericIso: ComparableInt32OperationFilterInput
"Indicates if the country is part of the European Union"
isEu: ComparableBooleanOperationFilterInput
"The continent of the country"
continent: StringOperationFilterInput
}
"Definition of a country item"
input CountryItemSortInput {
"The ISO code of the country"
countryIso: SortEnumType @cost(weight: "10")
"The name of the country"
name: SortEnumType @cost(weight: "10")
"The numeric ISO code of the country"
numericIso: SortEnumType @cost(weight: "10")
"The continent of the country"
continent: SortEnumType @cost(weight: "10")
"The ISO code of the currency used in the country"
currencyIso: SortEnumType @cost(weight: "10")
}
input CreateAttributeSalesChannelValuesInput {
"Identifies the saleschannel for this attributevalue"
salesChannelId: ID!
"Contains the values for a saleschannel"
values: [CreateAttributeValueInput]
}
input CreateAttributeValueInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Value of this attribute as string. Please consider the Attribute Type for correct formatting."
value: String!
}
input CreateAttributeValuesInput {
"Identifies the attribute"
attributeId: ID!
"Defines the default values for the attribute and item in different languages."
defaultValues: [CreateAttributeValueInput]
"Contains all values for saleschannels for this attribute and item"
salesChannelValues: [CreateAttributeSalesChannelValuesInput]
}
"Options for copying item attributes."
input CreateAttributesCopyOptionsInput {
"Indicates whether attributes should be copied."
isActive: Boolean!
"Specifies whether to replace existing attributes or attach\/merge new attributes with existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating item attributes."
input CreateAttributesDuplicationOptionsInput {
"Indicates whether item attributes should be duplicated."
isActive: Boolean
}
"Creates a new bill of materials for a production item, including its components. - Request"
input CreateBillOfMaterialsCommandRequestInput {
"The ID of the production item for which the bill of materials is to be created."
productionItemId: ID!
"The input for creating a bill of materials as part of a production item."
input: CreateBillOfMaterialsInput!
}
"Represents the input for creating a bill of materials as part of a production item."
input CreateBillOfMaterialsInput {
"The name of the bill of materials."
name: String!
"An optional description of the bill of materials."
description: String
"Requirements for the production input of all components of this bill of materials regarding the shelf life end dates of the stock accounts to be debited. This requirement can be overridden for individual components. Optional; defaults to None. Must not be set to a value other than None if no component's underlying item has a shelf life end date configured."
componentPostingsShelfLifeEndDateRequirements: CreateOverallComponentPostingsInventoryAccountingDataRequirements
"Requirements for the production input of all components of this bill of materials regarding the batch numbers of the stock accounts to be debited. This requirement can be overridden for individual components. Optional; defaults to None. Must not be set to a value other than None if no component's underlying item has a batch number configured."
componentPostingsBatchNumberRequirements: CreateOverallComponentPostingsInventoryAccountingDataRequirements
"Indicates how the shelf life end date of the produced item is calculated after completing a lot."
shelfLifeEndDateGenerationMode: CreateShelfLifeEndDateGenerationMode
"A time span that is added when calculating the shelf life end date of the produced item after completing a lot. Required when ShelfLifeEndDateGenerationMode is ProductionDate; optional when ShelfLifeEndDateGenerationMode is Earliest or Latest; is ignored when ShelfLifeEndDateGenerationMode is not specified."
additionalShelfLifeEndDateTime: TimeSpan
"The operations of this bill of materials. At least one operation is required, and across all operations at least one item must be present."
operations: [CreateBillOfMaterialsOperationInput!]!
}
"Creates a new bill of materials item for a bill of materials operation. - Request"
input CreateBillOfMaterialsItemCommandRequestInput {
"The ID of the production item."
productionItemId: ID!
"The ID of the bill of materials."
billOfMaterialsId: ID!
"The ID of the bill of materials operation."
billOfMaterialsOperationId: ID!
"The input for creating a bill of materials item."
input: CreateBillOfMaterialsItemInput!
}
"Represents the input for creating a bill of materials item as part of a bill of materials operation."
input CreateBillOfMaterialsItemInput {
"The ID of the item to be used as a bill of materials item."
itemId: ID!
"The required quantity of this component for the production of the production item. Must be greater than zero."
quantity: Decimal!
"The ID of the measurement unit in which the quantity is managed, or NULL to use the sales unit of the underlying item."
measurementUnitId: ID
"Requirements for the production input of this component regarding the shelf life end dates of the stock accounts to be debited. Overrides the corresponding setting on the bill of materials level for this component. Optional; defaults to Inherited, which applies the requirement specified at the bill of materials level. Must not be set to a value other than Inherited if the underlying item does not have a shelf life end date configured."
componentPostingsShelfLifeEndDateRequirements: CreateComponentPostingsInventoryAccountingDataRequirements
"Requirements for the production input of this component regarding the batch numbers of the stock accounts to be debited. Overrides the corresponding setting on the bill of materials level for this component. Optional; defaults to Inherited, which applies the requirement specified at the bill of materials level. Must not be set to a value other than Inherited if the underlying item does not have a batch number configured."
componentPostingsBatchNumberRequirements: CreateComponentPostingsInventoryAccountingDataRequirements
}
"Creates a new bill of materials operation for a bill of materials, including its items. - Request"
input CreateBillOfMaterialsOperationCommandRequestInput {
"The ID of the production item."
productionItemId: ID!
"The ID of the bill of materials."
billOfMaterialsId: ID!
"The input for creating a bill of materials operation."
input: CreateBillOfMaterialsOperationInput!
}
"Represents the input for creating a bill of materials operation as part of a new bill of materials."
input CreateBillOfMaterialsOperationInput {
"The ID of the operation to be assigned to this bill of materials operation. The operation must exist."
operationId: ID!
"The bill of materials items assigned to this operation. Optional per individual operation, but at least one component must be present across all operations within the bill of materials."
items: [CreateBillOfMaterialsItemInput]
}
"Creates a new bin location in a warehouse. - Request"
input CreateBinLocationCommandRequestInput {
"Warehouse where the bin location should be created."
warehouseId: ID!
"Name of the bin location (must be unique within the warehouse, max 50 chars, no apostrophes)."
name: String!
"Type of the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: Int!
"Optional sort order."
sort: Int
}
"Options for copying bill of materials (BOM) components."
input CreateBomComponentsCopyOptionsInput {
"Indicates whether BOM components should be copied."
isActive: Boolean!
"Specifies whether to replace all existing BOM components or attach\/add new components to the existing BOM structure."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating bill of materials components."
input CreateBomDuplicationOptionsInput {
"Indicates whether bill of materials components should be duplicated."
isActive: Boolean
}
"Address information for sales entity calculation (tax determination)."
input CreateCalculateSalesEntityAddressInput {
"The ISO code of the address country for tax calculation."
countryIso: String!
"The state of the address for tax calculation."
state: String
"The VAT ID of the address for tax calculation."
vatId: String
}
"Request model for a new sales entity line item to be added via a change."
input CreateCalculateSalesEntityLineItemRequestAddInput {
"The synchronization identifier for the new line item. Must be unique and greater than 0."
syncNumber: Int!
"The unique identifier of the item\/article. If omitted, a free-text position is created."
itemId: ID
"The quantity of the item. Must be greater than 0."
quantity: Decimal!
"The type of the line item (e.g., Item, Custom, Shipping)."
lineItemType: LineItemType
}
"Represents a change to apply to an existing line item."
input CreateCalculateSalesEntityLineItemRequestChangeInput {
"The synchronization identifier for the line item to update."
syncNumber: Int!
"The new quantity of the item."
quantity: Decimal
"Determines how the line item price is recalculated when the quantity changes (use the calculated item price or keep the current price)."
recalculatePriceMode: RecalculateLineItemPriceChangeMode
"Manual override for the net sales price per unit. Cannot be set simultaneously with SalesPriceGross."
salesPriceNet: Decimal
"Manual override for the gross sales price per unit. When set, the net price is recalculated. Cannot be set simultaneously with SalesPriceNet."
salesPriceGross: Decimal
"The discount percentage for the line item (e.g., 10.0 for 10% discount)."
discountPercent: Decimal
"The tax class identifier for this line item. If set, overrides the automatically determined tax class."
taxClassId: ID
}
"Represents a set of changes to apply to line items."
input CreateCalculateSalesEntityLineItemRequestChangeSetInput {
"The list of new line items to create."
create: [CreateCalculateSalesEntityLineItemRequestAddInput]
"The list of existing line items to update."
update: [CreateCalculateSalesEntityLineItemRequestChangeInput]
"The list of sync numbers of line items to delete."
delete: [Int!]
}
"Request model for an existing sales entity line item. Carries the full current state of the line item."
input CreateCalculateSalesEntityLineItemRequestInput {
"The synchronization identifier for the line item. Must be unique and greater than 0. This ID is assigned by the client and remains constant."
syncNumber: Int!
"The unique identifier of the item\/article. If omitted, a free-text position is assumed."
itemId: ID
"The quantity of the item. Must be greater than 0."
quantity: Decimal!
"The current net sales price per unit."
salesPriceNet: Decimal
"The discount percentage for the line item (e.g., 10.0 for 10% discount)."
discountPercent: Decimal
"The tax class identifier for this line item."
taxClassId: ID!
"The tax code identifier for this line item."
taxCodeId: ID!
"The tax rate for this line item (e.g., 19.0 for 19%)."
taxRate: Decimal!
"The total net sales price for the line item after applying quantity and discount."
totalSalesPriceNet: Decimal!
"The total gross sales price for the line item after applying quantity and discount."
totalSalesPriceGross: Decimal!
"The type of the line item (e.g., Item, Custom, Shipping)."
lineItemType: LineItemType!
"The SyncNumber of the parent line item. Used to assign configuration components to their parent configuration item."
parentSyncNumber: Int
}
"Represents a change to apply to the sales entity calculation request."
input CreateCalculateSalesEntityRequestChangeInput {
"The company ID to use for the calculation."
companyId: ID
"The customer ID to use for the calculation."
customerId: ID
"The shipping method ID to use for the calculation."
shippingMethodId: ID
"The billing address information for tax calculation."
billingAddress: CreateCalculateSalesEntityAddressInput
"The shipment address information for tax calculation."
shipmentAddress: CreateCalculateSalesEntityAddressInput
"The line item changes to apply."
lineItemChanges: CreateCalculateSalesEntityLineItemRequestChangeSetInput
"The ISO code of the currency for price calculation."
currencyIso: String
"Manual override for the currency conversion factor."
currencyFactor: Decimal
"The ISO code of the departure country for tax calculation."
departureCountryIso: String
"The departure country state\/region code for state-level tax calculation."
departureCountryStateCode: String
"Additional weight in kg to add to the order for shipping cost calculation."
extraWeight: Decimal
"The tax special treatment mode for the sales entity."
specialTaxTreatment: SpecialTaxTreatment
"The tax reference of the sales entity. This setting controls which data is used during tax calculation."
taxReference: TaxReference
}
"Request model for calculating prices, discounts, taxes, and shipping costs for a sales entity."
input CreateCalculateSalesEntityRequestInput {
"The unique identifier of the company for the sales entity."
companyId: ID!
"Vat id of the seller."
vatId: String!
"The unique identifier of the customer for whom the sales entity is being calculated."
customerId: ID!
"The shipping method ID for shipping cost calculation and tax determination."
shippingMethodId: ID
"The shop ID for shop-specific price calculation."
shopId: ID
"The billing address information for tax calculation."
billingAddress: CreateCalculateSalesEntityAddressInput
"The shipment address information for tax calculation."
shipmentAddress: CreateCalculateSalesEntityAddressInput
"The list of sales entity line items to be calculated. Each line item carries its full current state."
lineItems: [CreateCalculateSalesEntityLineItemRequestInput!]!
"The ISO code of the currency for price calculation (e.g., EUR, USD)."
currencyIso: String!
"The currency conversion factor. Must be greater than 0."
currencyFactor: Decimal!
"The ISO code of the departure country for tax calculation."
departureCountryIso: String!
"The departure country state\/region code for state-level tax calculation (e.g., US states like CA, NY)."
departureCountryStateCode: String
"Additional weight in kg to add to the order for shipping cost calculation."
extraWeight: Decimal
"The tax special treatment mode for the sales entity (e.g., ReverseCharge, ExemptFromVat)."
specialTaxTreatment: SpecialTaxTreatment
"The tax setting for the sales entity."
taxSetting: TaxSetting!
"The tax reference of the sales entity. This setting controls which data is used during tax calculation."
taxReference: TaxReference
}
"Address information for sales order calculation (tax determination)."
input CreateCalculateSalesOrderAddressInput {
"The ISO code of the address country for tax calculation."
countryIso: String!
"The state of the address for tax calculation."
state: String
"The VAT ID of the address for tax calculation."
vatId: String
}
"Represents a change to apply to an existing line item."
input CreateCalculateSalesOrderLineItemRequestChangeInput {
"The synchronization identifier for the line item to update."
syncNumber: Int!
"The quantity of the item."
quantity: Decimal
"Manual override for the net sales price per unit. Cannot be set simultaneously with SalesPriceGross."
salesPriceNet: Decimal
"Manual override for the gross sales price per unit. When set, the net price is recalculated. Cannot be set simultaneously with SalesPriceNet."
salesPriceGross: Decimal
"The discount percentage for the line item (e.g., 10.0 for 10% discount)."
discountPercent: Decimal
"The tax class identifier for this line item. If set, overrides the automatically determined tax class."
taxClassId: ID
}
"Represents a set of changes to apply to line items."
input CreateCalculateSalesOrderLineItemRequestChangeSetInput {
"The list of new line items to create."
create: [CreateCalculateSalesOrderLineItemRequestInput]
"The list of existing line items to update."
update: [CreateCalculateSalesOrderLineItemRequestChangeInput]
"The list of sync numbers of line items to delete."
delete: [Int!]
}
"Request model for a sales order line item calculation."
input CreateCalculateSalesOrderLineItemRequestInput {
"The synchronization identifier for the line item. Must be unique and greater than 0. This ID is assigned by the client and remains constant."
syncNumber: Int!
"The unique identifier of the item\/article. If omitted, a free-text position is created."
itemId: ID
"The quantity of the item. Must be greater than 0."
quantity: Decimal!
"Manual override for the net sales price per unit. If set, overrides the calculated price. Cannot be set simultaneously with SalesPriceGross."
salesPriceNet: Decimal
"Manual override for the gross sales price per unit. When set, the net price is recalculated. Cannot be set simultaneously with SalesPriceNet."
salesPriceGross: Decimal
"The discount percentage for the line item (e.g., 10.0 for 10% discount)."
discountPercent: Decimal
"The tax class identifier for this line item. If set, overrides the automatically determined tax class."
taxClassId: ID
"The SyncNumber of the parent line item. Used to assign configuration components to their parent configuration item."
parentSyncNumber: Int
}
"Represents a change to apply to the sales order calculation request."
input CreateCalculateSalesOrderRequestChangeInput {
"The company ID to use for the calculation."
companyId: ID
"The customer ID to use for the calculation."
customerId: ID
"The shipping method ID to use for the calculation."
shippingMethodId: ID
"The billing address information for tax calculation."
billingAddress: CreateCalculateSalesOrderAddressInput
"The shipment address information for tax calculation."
shipmentAddress: CreateCalculateSalesOrderAddressInput
"The line item changes to apply."
lineItemChanges: CreateCalculateSalesOrderLineItemRequestChangeSetInput
"The ISO code of the currency for price calculation."
currencyIso: String
"Manual override for the currency conversion factor."
currencyFactor: Decimal
"The ISO code of the departure country for tax calculation."
departureCountryIso: String
"The departure country state\/region code for state-level tax calculation."
departureCountryStateCode: String
"Additional weight in kg to add to the order for shipping cost calculation."
extraWeight: Decimal
"The tax special treatment mode for the sales order."
specialTaxTreatment: SpecialTaxTreatment
"The tax reference of the sales order. This setting controls which data is used during tax calculation."
taxReference: TaxReference
}
"Request model for calculating prices, discounts, taxes, and shipping costs for a sales order."
input CreateCalculateSalesOrderRequestInput {
"The unique identifier of the company for the sales order."
companyId: ID!
"The unique identifier of the customer for whom the sales order is being calculated."
customerId: ID!
"The shipping method ID for shipping cost calculation and tax determination."
shippingMethodId: ID
"The shop ID for shop-specific price calculation."
shopId: ID
"The billing address information for tax calculation."
billingAddress: CreateCalculateSalesOrderAddressInput
"The shipment address information for tax calculation."
shipmentAddress: CreateCalculateSalesOrderAddressInput
"The list of sales order line items to be calculated."
lineItems: [CreateCalculateSalesOrderLineItemRequestInput!]!
"The ISO code of the currency for price calculation (e.g., EUR, USD). If not specified, the default currency will be used."
currencyIso: String
"Manual override for the currency conversion factor. If set (greater than 0), overrides the default factor from the currency settings."
currencyFactor: Decimal
"The ISO code of the departure country for tax calculation."
departureCountryIso: String!
"The departure country state\/region code for state-level tax calculation (e.g., US states like CA, NY)."
departureCountryStateCode: String
"Additional weight in kg to add to the order for shipping cost calculation."
extraWeight: Decimal
"The tax special treatment mode for the sales order (e.g., ReverseCharge, TaxExempt)."
specialTaxTreatment: SpecialTaxTreatment
"The tax reference of the sales order. This setting controls which data is used during tax calculation."
taxReference: TaxReference
}
"Creates a new Category. - Request"
input CreateCategoryCommandRequestInput {
"The parent category of the category."
parentId: ID
"The sort number of the category."
sortNumber: Int
"The category name."
name: String!
}
"Options for copying item characteristics (Merkmale)."
input CreateCharacteristicsCopyOptionsInput {
"Indicates whether characteristics should be copied."
isActive: Boolean!
"Specifies whether to replace all existing characteristics or attach\/add new characteristics to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating item characteristics."
input CreateCharacteristicsDuplicationOptionsInput {
"Indicates whether item characteristics should be duplicated."
isActive: Boolean
}
"A command to create a new company, including identification, contact, banking, and tax information. - Request"
input CreateCompanyCommandRequestInput {
"The name of the company to be created."
companyName: String!
"The owner of the company."
owner: String
"The street address of the company."
street: String
"The postal code of the company."
postalCode: String
"The city of the company."
city: String
"The country name of the company."
country: String
"The country ISO code of the company."
countryIsoCode: String!
"The phone number of the company."
phone: String
"The fax number of the company."
fax: String
"The email address of the company."
emailAddress: String
"The website URL of the company."
website: String
"The bank code of the company."
bankCode: String
"The bank account number of the company."
accountNumber: String
"The bank name of the company."
bankName: String
"The tax identification number of the company."
taxId: String
"The International Bank Account Number (IBAN) of the company."
iban: String
"The Bank Identifier Code (BIC) of the company."
bic: String
"The account holder name of the company."
accountHolder: String
"The creditor ID for SEPA direct debit."
creditorId: String
"The PayPal email address of the company."
payPalEmailAddress: String
"A value indicating whether the owner of the company is a small business owner (Kleinunternehmer). This affects the VAT handling of the company."
isSmallBusinessOwner: Boolean!
"The DHL Intraship customer ID of the company."
dhlIntrashipCustomerId: String
"The UPS customer ID of the company."
upsCustomerId: String
"The collection of VAT identifiers for this company."
companyVatIdentifiers: [CreateCompanyVatIdDetailsItemInput]
}
"Single row of the company VAT id table"
input CreateCompanyVatIdDetailsItemInput {
"Unique VAT ID."
id: ID
"The company id."
companyId: ID
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"Options for copying item configurations."
input CreateConfigurationsCopyOptionsInput {
"Indicates whether configurations should be copied."
isActive: Boolean!
"Specifies whether to replace all existing configurations or attach\/add new configurations to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating configurations."
input CreateConfigurationsDuplicationOptionsInput {
"Indicates whether configurations should be duplicated."
isActive: Boolean
}
input CreateCreateCustomerAddressInput {
"Name of the street (including number)."
street: String!
"Additional address information."
additionalAddressLine: String
"City name of the customer."
city: String!
"Postal code of the customer."
postalCode: String
"Name of the state."
state: String
"ISO code of the country (2 letters)."
countryIso: String!
"The customers email address."
emailAddress: String
"The customers phone number."
phoneNumber: String
"The customers mobile phone number."
mobilePhoneNumber: String
"The customers fax number."
faxNumber: String
"The customers VAT ID."
vatId: String
"The customers salutation (e.g. Mr., Mrs., etc.)"
salutation: String
"The customers title (e.g. Dr., Prof., etc.)"
title: String
"The customers first name"
firstName: String
"The customers last name"
lastName: String
"The customers company name"
companyName: String
"The customers company additional line"
additionalCompanyLine: String
}
input CreateCreateCustomerPaymentSettingsInput {
"The customers credit limit."
creditLimit: Int
"Payment target (in days)."
paymentDueDateInDays: Int
"The customers discount percentage."
discount: Decimal
"Whether the customer is blocked for dunning notices."
isDunningBlocked: Boolean
}
"Address details for the sales order."
input CreateCreateSalesOrderAddressInput {
"The SalesOrderAddress Salutation"
salutation: String
"The SalesOrderAddress Title"
title: String
"The SalesOrderAddress FirstName"
firstName: String
"The SalesOrderAddress LastName"
lastName: String
"The SalesOrderAddress Company"
company: String
"The SalesOrderAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesOrderAddress Street"
street: String!
"The SalesOrderAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesOrderAddress City"
city: String!
"The SalesOrderAddress PostalCode"
postalCode: String
"The SalesOrderAddress State"
state: String
"The SalesOrderAddress CountryISO"
countryIso: String!
"The SalesOrderAddress PostId"
postId: String
"The SalesOrderAddress EmailAddress"
emailAddress: String
"The SalesOrderAddress PhoneNumber"
phoneNumber: String
"The SalesOrderAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesOrderAddress Fax"
fax: String
"The SalesOrderAddress VAT ID"
vatId: String
}
"Defines the departure country information for a sales order during its creation."
input CreateCreateSalesOrderDepartureCountryInput {
"The ISO code of the departure country."
countryIso: String!
"The sales order departure country currency iso"
currencyIso: String!
"The sales order departure country currency factor"
currencyFactor: Decimal
"DEPRECATED: do not use; use StateCode instead. The SalesOrder State."
state: String
"The SalesOrder State code"
stateCode: String
}
"External details for the sales order."
input CreateCreateSalesOrderExternalDetailsInput {
"The SalesOrder ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType
"The SalesOrder ExternalSalesOrderNumber"
externalSalesOrderNumber: String
}
"Line item details for the new sales order."
input CreateCreateSalesOrderLineItemInput {
"Unique ID to identify an item."
itemId: ID
"The SalesOrderLineItem ParentSalesOrderLineItemId"
parentSalesOrderLineItemId: ID
"The SalesOrderLineItem TaxClassId"
taxClassId: ID
"The SalesOrderLineItem TaxCodeId"
taxCodeId: ID
"The SalesOrderLineItem BillOfMaterialsType"
billOfMaterialsType: BillOfMaterialsType
"The SalesOrderLineItem ConfigurationItemType"
configurationItemType: ConfigurationItemType
"The discount of the line item."
discountPercent: Decimal
"The SalesOrderLineItem FNSKU"
fnSku: String
"Name of the position."
name: String
"The SalesOrderLineItem Note"
note: String
"The purchase price of the item."
purchasePriceNet: Decimal
"The quantity of the line item."
quantity: Decimal
"The net sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales order line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesOrderLineItem LineItemType"
type: LineItemType
"List of SalesOrderLineItemVariant"
variants: [CreateCreateSalesOrderLineItemVariantInput]
}
"Sales order line item variant details."
input CreateCreateSalesOrderLineItemVariantInput {
"The SalesOrderLineItemVariant ExtraWeight"
extraWeight: Decimal
"The SalesOrderLineItemVariant Name"
name: String!
"The SalesOrderLineItemVariant SurchargeNet"
surchargeNet: Decimal
"The SalesOrderLineItemVariant Value"
value: String
"The SalesOrderLineItemVariant ItemVariantId"
itemVariantId: ID!
"The SalesOrderLineItemVariant ItemVariantValueId"
itemVariantValueId: ID
}
"Payment details for the new sales order."
input CreateCreateSalesOrderPaymentDetailsInput {
"The SalesOrder CashDiscount"
cashDiscount: Decimal
"The SalesOrder CashDiscountDays"
cashDiscountDays: Int
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int
"The sales order departure country currency iso"
currencyIso: String!
"The sales order departure country currency factor"
currencyFactor: Decimal
}
"Payment info for the new sales order."
input CreateCreateSalesOrderPaymentInfoInput {
"The SalesOrderPaymentInfo AccountHolder"
accountHolder: String
"The SalesOrderPaymentInfo BankName"
bankName: String
"The SalesOrderPaymentInfo BIC"
bic: String
"The SalesOrderPaymentInfo CreditorId"
creditorId: String
"The SalesOrderPaymentInfo DueDate"
dueDate: DateTime
"The SalesOrderPaymentInfo EndToEndId"
endToEndId: String
"The SalesOrderPaymentInfo IBAN"
iban: String
"The SalesOrderPaymentInfo MandateReference"
mandateReference: String
"The SalesOrderPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesOrderPaymentInfo PaymentReference"
paymentReference: String
"The SalesOrderPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for the new sales order."
input CreateCreateSalesOrderShippingDetailsInput {
"The SalesOrder DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesOrder EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesOrder ExtraWeight"
extraWeight: Decimal
"The SalesOrder MaxDeliveryDays"
maxDeliveryDays: Int
"The SalesOrder ShippingDate"
shippingDate: DateTime
"The SalesOrder ShippingPriority"
shippingPriority: Int
}
"Tax details for the new sales order."
input CreateCreateSalesOrderTaxDetailsInput {
"The SalesOrder TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference
"The SalesOrder SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment
"The SalesOrder TaxSetting"
taxSetting: TaxSetting
}
"Tax details for the new sales order."
input CreateCreateSalesOrderTextInput {
"The SalesOrderText Comment"
comment: String
"The SalesOrderText CustomerComment"
customerComment: String
"The SalesOrderText PrintText"
printText: String
"The SalesOrderText ProcessStatus"
processStatus: String
}
"Billing address details for the sales quotation."
input CreateCreateSalesQuotationAddressInput {
"The SalesQuotationAddress Salutation"
salutation: String
"The SalesQuotationAddress Title"
title: String
"The SalesQuotationAddress FirstName"
firstName: String
"The SalesQuotationAddress LastName"
lastName: String
"The SalesQuotationAddress Company"
company: String
"The SalesQuotationAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesQuotationAddress Street"
street: String!
"The SalesQuotationAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesQuotationAddress City"
city: String!
"The SalesQuotationAddress PostalCode"
postalCode: String
"The SalesQuotationAddress State"
state: String
"The SalesQuotationAddress CountryISO"
countryIso: String!
"The SalesQuotationAddress PostId"
postId: String
"The SalesQuotationAddress EmailAddress"
emailAddress: String
"The SalesQuotationAddress PhoneNumber"
phoneNumber: String
"The SalesQuotationAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesQuotationAddress Fax"
fax: String
}
"Defines the departure country information for a sales quotation during its creation."
input CreateCreateSalesQuotationDepartureCountryInput {
"The ISO code of the departure country."
countryIso: String!
"The sales quotation departure country currency iso"
currencyIso: String!
"The sales quotation departure country currency factor"
currencyFactor: Decimal
"The SalesQuotation State"
state: String
}
"External details for the sales quotation."
input CreateCreateSalesQuotationExternalDetailsInput {
"The SalesQuotation ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesQuotation ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType
"The SalesQuotation ExternalSalesQuotationNumber"
externalSalesQuotationNumber: String
}
"Line item details for the new sales quotation."
input CreateCreateSalesQuotationLineItemInput {
"Unique ID to identify an item."
itemId: ID
"The SalesQuotationLineItem ParentSalesQuotationLineItemId"
parentSalesQuotationLineItemId: ID
"The SalesQuotationLineItem TaxClassId"
taxClassId: ID
"The SalesQuotationLineItem TaxCodeId"
taxCodeId: ID
"The SalesQuotationLineItem BillOfMaterialsType"
billOfMaterialsType: BillOfMaterialsType
"The SalesQuotationLineItem ConfigurationItemType"
configurationItemType: ConfigurationItemType
"The discount of the line item."
discountPercent: Decimal
"The SalesQuotationLineItem FNSKU"
fnSku: String
"Name of the position."
name: String
"The SalesQuotationLineItem Note"
note: String
"The purchase price of the item."
purchasePriceNet: Decimal
"The quantity of the line item."
quantity: Decimal
"The net sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales quotation line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesQuotationLineItem LineItemType"
type: LineItemType
"List of SalesQuotationLineItemVariant"
variants: [CreateCreateSalesQuotationLineItemVariantInput]
}
"Sales quotation line item variant details."
input CreateCreateSalesQuotationLineItemVariantInput {
"The SalesQuotationLineItemVariant ExtraWeight"
extraWeight: Decimal
"The SalesQuotationLineItemVariant Name"
name: String!
"The SalesQuotationLineItemVariant SurchargeNet"
surchargeNet: Decimal
"The SalesQuotationLineItemVariant Value"
value: String
"The SalesQuotationLineItemVariant ItemVariantId"
itemVariantId: ID!
"The SalesQuotationLineItemVariant ItemVariantValueId"
itemVariantValueId: ID
}
"Payment details for the new sales quotation."
input CreateCreateSalesQuotationPaymentDetailsInput {
"The SalesQuotation CashDiscount"
cashDiscount: Decimal
"The SalesQuotation CashDiscountDays"
cashDiscountDays: Int
"The SalesQuotation FinancingCosts"
financingCosts: Decimal
"The SalesQuotation PaymentDueDateInDays"
paymentDueDateInDays: Int
"The sales quotation departure country currency iso"
currencyIso: String!
"The sales quotation departure country currency factor"
currencyFactor: Decimal
}
"Payment info for the new sales quotation."
input CreateCreateSalesQuotationPaymentInfoInput {
"The SalesQuotationPaymentInfo AccountHolder"
accountHolder: String
"The SalesQuotationPaymentInfo BankName"
bankName: String
"The SalesQuotationPaymentInfo BIC"
bic: String
"The SalesQuotationPaymentInfo CreditorId"
creditorId: String
"The SalesQuotationPaymentInfo DueDate"
dueDate: DateTime
"The SalesQuotationPaymentInfo EndToEndId"
endToEndId: String
"The SalesQuotationPaymentInfo IBAN"
iban: String
"The SalesQuotationPaymentInfo MandateReference"
mandateReference: String
"The SalesQuotationPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesQuotationPaymentInfo PaymentReference"
paymentReference: String
"The SalesQuotationPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for the new sales quotation."
input CreateCreateSalesQuotationShippingDetailsInput {
"The SalesQuotation DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesQuotation EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesQuotation ExtraWeight"
extraWeight: Decimal
"The SalesQuotation MaxDeliveryDays"
maxDeliveryDays: Int
"The SalesQuotation ShippingDate"
shippingDate: DateTime
"The SalesQuotation ShippingPriority"
shippingPriority: Int
}
"Tax details for the new sales quotation."
input CreateCreateSalesQuotationTaxDetailsInput {
"The SalesQuotation SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment
"The SalesQuotation TaxSetting"
taxSetting: TaxSetting
}
"Text details for the new sales quotation."
input CreateCreateSalesQuotationTextInput {
"The SalesQuotationText Comment"
comment: String
"The SalesQuotationText CustomerComment"
customerComment: String
"The SalesQuotationText PrintText"
printText: String
"The SalesQuotationText ProcessStatus"
processStatus: String
}
"Represents a single cross-selling item."
input CreateCrossSellItemInput {
"Id of the item"
id: ID!
"Sku of the item"
sku: String
}
"Options for copying cross-selling data."
input CreateCrossSellingCopyOptionsInput {
"Indicates whether cross-selling data should be copied."
isActive: Boolean!
"Specifies whether to replace existing cross-selling relations or attach\/add new ones to existing cross-selling data."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating cross-selling data."
input CreateCrossSellingDuplicationOptionsInput {
"Indicates whether cross-selling data should be duplicated."
isActive: Boolean
}
"Options for copying custom fields (eigene Felder)."
input CreateCustomFieldsCopyOptionsInput {
"Indicates whether custom fields should be copied."
isActive: Boolean!
"Specifies whether to replace all existing custom field values or attach\/merge new custom field values with existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating custom fields."
input CreateCustomFieldsDuplicationOptionsInput {
"Indicates whether custom fields should be duplicated."
isActive: Boolean
}
"Creates a customer - Request"
input CreateCustomerCommandRequestInput {
"Id of the company the customer belongs to. Optional — defaults to 0 (no company) when omitted."
companyId: ID
"Customer group for the customer to be in."
customerGroupId: ID!
"The customers category ID."
customerCategoryId: ID
"The customers preferred payment method ID."
paymentMethodId: ID
"The accounts receivable number of the customer."
accountsReceivableNumber: Int
"The customer's date of birth."
birthday: DateTime
"The customer's commercial register number."
commercialRegisterNumber: String
"Number of the customer. If no number is given when posting a customer, the number will be generated automatically."
customerNumber: String
"The customers ebay name."
ebayName: String
"The customers homepage URL."
homepage: String
"The source of initial contact. This could be for example a specific sales channel, a convention or a marketing campaign."
initialContact: String
"States if a customer is from a cash-register or point of sale and if their data should be synchronized with JTL-POS, for example."
isCashRegisterBased: Boolean
"The customer's locked status."
isLocked: Boolean
"The customer's preferred language in ISO format (e.g. \"de\", \"en\")."
languageIso: String
"The customer's tax identification number."
taxIdentificationNumber: String
"Default billing address of the customer."
billingAddress: CreateCreateCustomerAddressInput!
"Default shipping address of the customer."
shipmentAddress: CreateCreateCustomerAddressInput
"Settings relevant to payment for the customer."
paymentSettings: CreateCreateCustomerPaymentSettingsInput
}
input CreateCustomerGroupSurchargeInput {
"Id of the customergroup"
customerGroupId: ID!
"Surcharge for that customergroup"
surcharge: Decimal
"Defines if the surcharges will be synchronized to online saleschannels. Does not apply for the default customer group surcharges, which are always synchronized when not overriden."
isActive: Boolean
}
"Defines a default description of an item in a specific language. This description is used as a fallback when no more specific platform or sales channel descriptions are available."
input CreateDefaultDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the actual description data such as name, short and long description as well as SEO-relevant information."
descriptionData: CreateDescriptionDataInput!
}
"Delivers an existing Package - Request"
input CreateDeliverPackageCommandRequestInput {
"ID of the Package to be modified"
packageId: String!
"The Tracking Code of the Package. Only required if configured in the Shipping Method"
trackingCode: String
"The Shipping Date of the Package. Only required if configured in the Shipping Method"
shippingDate: DateTime
}
"Options for copying delivery options and constraints."
input CreateDeliveryOptionsCopyOptionsInput {
"Indicates whether delivery options should be copied."
isActive: Boolean!
"Specifies whether to replace existing delivery options. Only Replace is applicable for delivery options, as they are exclusive settings."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating delivery options."
input CreateDeliveryOptionsDuplicationOptionsInput {
"Indicates whether delivery options should be duplicated."
isActive: Boolean
}
"Defines the actual description data of an item. This structure contains all textual information of an item including SEO-relevant metadata for online shops."
input CreateDescriptionDataInput {
"The name of the item as displayed in the user interface or shop."
itemName: String
"Short description of the item for overview displays and search results."
shortDescription: String
"Detailed description of the item with comprehensive product information and properties."
description: String
"Meta description for search engine optimization (SEO) that is displayed in search results."
metaDescription: String
"Meta keywords for search engine optimization to improve discoverability of the item."
metaKeywords: String
"HTML title tag for the item that is displayed in the browser tab and search results."
titleTag: String
"URL path for the item to create SEO-friendly and speaking URLs."
urlPath: String
}
input CreateDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Name of the Variation in the specific language"
name: String!
}
"Options for copying item texts and descriptions."
input CreateDescriptionsCopyOptionsInput {
"Indicates whether texts and descriptions should be copied."
isActive: Boolean!
"Indicates whether the item name should be copied."
considerItemName: Boolean!
"Indicates whether the item description (long text) should be copied."
considerItemDescription: Boolean!
"Indicates whether item metadata (meta description, meta keywords, title tag) should be copied."
considerItemMetadata: Boolean!
"Indicates whether the item URL path (SEO URL) should be copied."
considerItemUrlPath: Boolean!
"Specifies whether to replace existing texts or attach\/merge new texts with existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating descriptions."
input CreateDescriptionsDuplicationOptionsInput {
"Indicates whether descriptions should be duplicated."
isActive: Boolean
"Indicates whether the item description should be considered during duplication. When true, the full description text will be duplicated."
considerDescriptions: Boolean
"Indicates whether the item metadata (such as meta description, meta keywords, and title tags) should be considered during duplication."
considerMetadata: Boolean
"Indicates whether the URL path should be considered during duplication. When true, the SEO-friendly URL path will be duplicated."
considerUrlPaths: Boolean
"Indicates whether the item name should be considered during duplication. When true, the item name from descriptions will be duplicated."
considerNames: Boolean
}
"Options for copying download files."
input CreateDownloadFilesCopyOptionsInput {
"Indicates whether download files should be copied."
isActive: Boolean!
"Specifies whether to replace all existing download files or attach\/add new download files to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating download files."
input CreateDownloadFilesDuplicationOptionsInput {
"Indicates whether download files should be duplicated."
isActive: Boolean
}
input CreateEbayImagesInput {
"Unique ID to identify an ebay account."
ebayAccountId: ID!
"List of images assigned to the eBay account."
images: [CreateItemImageInput]
}
"Options for copying item identifiers (EAN, ISBN, HAN, UPC, TARIC, etc.)."
input CreateIdentifiersCopyOptionsInput {
"Indicates whether identifiers should be copied."
isActive: Boolean!
"Specifies whether to replace existing identifiers. Only Replace is applicable for identifiers as they are unique values."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating identifiers."
input CreateIdentifiersDuplicationOptionsInput {
"Indicates whether identifiers should be duplicated."
isActive: Boolean
"Indicates whether the EAN (European Article Number) should be considered during duplication."
considerEan: Boolean
"Indicates whether the ISBN (International Standard Book Number) should be considered during duplication."
considerIsbn: Boolean
"Indicates whether the UPC (Universal Product Code) should be considered during duplication."
considerUpc: Boolean
"Indicates whether the HAN (manufacturer number) should be considered during duplication."
considerHan: Boolean
"Indicates whether the TARIC code should be considered during duplication."
considerTaricCode: Boolean
"Indicates whether the country of origin code should be considered during duplication."
considerCountryCode: Boolean
"Indicates whether the hazard identification number should be considered during duplication."
considerHazardNumber: Boolean
"Indicates whether the series information should be considered during duplication."
considerSeries: Boolean
"Indicates whether the UN number should be considered during duplication."
considerUnNumber: Boolean
"Indicates whether the Amazon FNSKU should be considered during duplication."
considerAmazonFnsku: Boolean
"Indicates whether item notes should be considered during duplication."
considerNotes: Boolean
"Indicates whether search terms should be considered during duplication."
considerSearchTerms: Boolean
"Indicates whether the include in price list flag should be considered during duplication."
considerIncludeInPriceList: Boolean
"Indicates whether order suggestions should be considered during duplication."
considerOrderSuggestions: Boolean
}
"Options for copying item images."
input CreateImagesCopyOptionsInput {
"Indicates whether images should be copied."
isActive: Boolean!
"Specifies whether to replace all existing images or attach\/add new images to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating images."
input CreateImagesDuplicationOptionsInput {
"Indicates whether images should be duplicated."
isActive: Boolean
}
input CreateItemAttributesInput {
"Contains all attribute values assigned to the item"
values: [CreateAttributeValuesInput]
}
"Defines the category assignments of an item for creation. This structure manages all categories to which an item can be assigned and enables hierarchical classification for better organization and navigation."
input CreateItemCategoriesInput {
"Contains all categories to which the item is assigned. An item can be assigned to multiple categories simultaneously to enable flexible categorization and better discoverability."
categories: [CreateItemCategoryInput!]!
}
"Defines a single category assignment for an item. This structure represents the link between an item and a specific category in the hierarchical category system of the ERP system."
input CreateItemCategoryInput {
"Unique key of the category that identifies the specific category to which the item should be assigned. This key establishes the connection to the category data."
categoryId: ID!
}
"Creates a new regular item with all specified properties. This command enables complete configuration of an item including identifiers, descriptions, prices, and measurements. - Request"
input CreateItemCommandRequestInput {
"The ID of the product group to which the item should be assigned. Product groups serve for categorical classification of items for reports and analyses."
productGroupId: ID
"The ID of the shipping class to which the item should be assigned."
shippingClassId: ID
"The ID of the manufacturer to which the item should be assigned."
manufacturerId: ID
"Category assignments of the item. Defines all categories to which the item should be assigned for better organization and navigation."
categories: CreateItemCategoriesInput!
"Identifiers of the item with all relevant markings and numbers for unique identification of the item in various systems."
identifiers: CreateItemIdentifiersInput!
"Descriptions of the item in different languages and for different platforms\/sales channels. Includes names, short and long descriptions as well as SEO-relevant information."
descriptions: CreateItemDescriptionsInput!
"Price structures of the item for different sales channels, customer groups and individual customers. Includes sales prices, purchase prices and tier prices."
prices: CreateItemPricesInput
"Suppliers associated with the item including supplier-specific information such as purchase prices, delivery times and order intervals."
suppliers: CreateItemSuppliersInput
"Physical dimensions and weight specifications of the item for storage, shipping and product presentation. Important for shipping cost calculations and storage space optimization."
measurements: CreateItemMeasurementsInput
"tbd"
images: CreateItemImagesInput
"Custom fields defined for the item to store additional information. Useful for special requirements or integrations."
customFields: CreateItemCustomFieldsInput
"Variations of an item"
variations: CreateItemVariationsInput
"Features of an item"
features: CreateItemFeaturesInput
"Attributes of an item"
attributes: CreateItemAttributesInput
"UnitPricing information of an item"
unitPricing: CreateItemUnitPricingInput
"SpecialPrices information of an item"
specialPrices: CreateItemSpecialPricesInput
"ItemStorageConstraints information of an item"
storageConstraints: CreateItemStorageConstraintsInput
"CrosssellingGroups of an item"
crosssellingGroups: CreateItemCrosssellingGroupsInput
}
"Represents a single cross-selling group with its assigned items."
input CreateItemCrosssellingGroupInput {
"Unique identifier of the cross-selling group."
crosssellingGroupId: ID!
"List of item keys that belong to this cross-selling group."
items: [CreateCrossSellItemInput]
}
"Manages cross-selling groups assigned to an item. Cross-selling groups define related products that should be promoted together."
input CreateItemCrosssellingGroupsInput {
"Collection of cross-selling groups associated with the item."
groups: [CreateItemCrosssellingGroupInput]
}
"Defines a single custom field value for an item. This structure connects a custom field definition with its actual value for a specific item."
input CreateItemCustomFieldValueInput {
"Unique identifier of the custom field definition. References the custom field that was previously created in the system."
fieldId: ID!
"The actual value stored in this custom field. The format and content depend on the custom field type definition (text, number, date, etc.)."
value: String!
"The culture name (e.g., \"en-US\", \"de-DE\") associated with the custom field value. This is important for localized fields where the value may vary based on the user's language or region. When returning those values from the server side this Format is always InvariantCulture. When sending values to the server side the culture name is optional and if not provided, it will be treated as InvariantCulture. Otherwise this value initializes a CultureInfo Object."
valueCultureName: String!
}
"Defines custom fields for an item to store additional, user-defined information. Custom fields allow flexible extension of item data beyond standard properties and can be used for special business requirements, integrations, or custom workflows."
input CreateItemCustomFieldsInput {
"List of custom field values assigned to the item. Each entry represents a custom field with its corresponding value."
fieldValues: [CreateItemCustomFieldValueInput!]!
}
"Defines customer group-specific prices for an item. This structure enables differentiated pricing by customer groups, allowing different price levels for different customer segments."
input CreateItemCustomerGroupPricesInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers)."
customerGroupId: ID!
"List of prices for this customer group - can contain different tier prices or volume discounts."
prices: [CreateItemPriceInput!]!
}
"Defines a customer group-specific special price for an item. This structure represents a single promotional price for a specific customer group in a sales channel."
input CreateItemCustomerGroupSpecialPriceInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers) for which this special price applies."
customerGroupId: ID!
"Net special price for this customer group without taxes. Setting this to null will deactivate the special price for this customer group."
netPrice: Decimal
"Indicates whether this special price is active for this customer group. Automatically set to false when NetPrice is set to null."
isActive: Boolean
}
"Defines customer-specific prices for an item. This structure enables individual price agreements for specific customers that can deviate from standard or customer group prices."
input CreateItemCustomerPricesInput {
"Key of the customer that identifies the specific customer for whom these individual prices apply."
customerId: ID!
"List of individual prices for this customer - can contain different tier prices or special conditions."
prices: [CreateItemPriceInput!]!
}
"Defines the collection of all descriptions of an item for creation. This structure manages default, platform, and sales channel-specific item descriptions for different languages and distribution channels."
input CreateItemDescriptionsInput {
"Default descriptions of the item. This is used when no more specific platform or sales channel descriptions are available and serves as a fallback description."
defaultDescriptions: [CreateDefaultDescriptionInput!]!
"List of sales channel-specific descriptions for sales platforms like JTL-Shop. Enables individual customization of item descriptions for specific sales channels."
salesChannelDescriptions: [CreateSalesChannelDescriptionInput]
"List of platform-specific descriptions for non-sales platforms like print. Allows different descriptions for various output platforms."
platformDescriptions: [CreatePlatformDescriptionInput]
}
"Represents the basic information for a duplicated item including SKU and name."
input CreateItemDuplicateInput {
"The stock keeping unit (SKU) for the duplicated item. Must be unique."
sku: String!
"The name of the duplicated item."
name: String!
}
"Defines which item properties should be duplicated when creating item copies. This structure controls the duplication behavior for all relevant item aspects."
input CreateItemDuplicationOptionsInput {
"Options for duplicating over-sales settings."
oversalesDuplicationOptions: CreateOversalesDuplicationOptionsInput
"Options for duplicating item attributes."
attributesDuplicationOptions: CreateAttributesDuplicationOptionsInput
"Options for duplicating images."
imagesDuplicationOptions: CreateImagesDuplicationOptionsInput
"Options for duplicating download files."
downloadFilesDuplicationOptions: CreateDownloadFilesDuplicationOptionsInput
"Options for duplicating upload files."
uploadFilesDuplicationOptions: CreateUploadFilesDuplicationOptionsInput
"Options for duplicating media files."
mediaFilesDuplicationOptions: CreateMediaFilesDuplicationOptionsInput
"Options for duplicating item characteristics."
characteristicsDuplicationOptions: CreateCharacteristicsDuplicationOptionsInput
"Options for duplicating bill of materials components."
bomDuplicationOptions: CreateBomDuplicationOptionsInput
"Options for duplicating variations."
variationsDuplicationOptions: CreateVariationsDuplicationOptionsInput
"Options for duplicating configurations."
configurationsDuplicationOptions: CreateConfigurationsDuplicationOptionsInput
"Options for duplicating descriptions."
descriptionsDuplicationOptions: CreateDescriptionsDuplicationOptionsInput
"Options for duplicating cross-selling data."
crossSellingDuplicationOptions: CreateCrossSellingDuplicationOptionsInput
"Options for duplicating custom fields."
customFieldsDuplicationOptions: CreateCustomFieldsDuplicationOptionsInput
"Options for duplicating purchase prices."
purchasePricesDuplicationOptions: CreatePurchasePricesDuplicationOptionsInput
"Options for duplicating identifiers."
identifiersDuplicationOptions: CreateIdentifiersDuplicationOptionsInput
"Options for duplicating sales prices."
salesPricesDuplicationOptions: CreateSalesPricesDuplicationOptionsInput
"Options for duplicating master data."
masterDataDuplicationOptions: CreateMasterDataDuplicationOptionsInput
"Options for duplicating special prices."
specialPricesDuplicationOptions: CreateSpecialPricesDuplicationOptionsInput
"Options for duplicating delivery options."
deliveryOptionsDuplicationOptions: CreateDeliveryOptionsDuplicationOptionsInput
"Options for duplicating dimensions and weights."
measurementssDuplicationOptions: CreateMeasurementssDuplicationOptionsInput
"Options for duplicating supplier data."
suppliersDuplicationOptions: CreateSuppliersDuplicationOptionsInput
"Options for duplicating saleschannel settings."
saleschannelDuplicationOptions: CreateSaleschannelDuplicationOptionsInput
"Options for duplicating SCX data."
scxDuplicationOptions: CreateScxDuplicationOptionsInput
"Options for duplicating packaging data."
packagingDuplicationOptions: CreatePackagingDuplicationOptionsInput
}
"Defines a single feature assignment for an item. This structure represents the link between an item and a specific feature value from the feature system, allowing detailed product characterization."
input CreateItemFeatureInput {
"Unique key of the feature value that identifies the specific feature characteristic to be assigned to the item. This key establishes the connection to a predefined feature value in the feature system."
featureId: ID!
}
"Defines the feature assignments of an item. This structure manages all features (characteristics\/attributes) that describe specific properties or attributes of an item, such as color, size, material, or other custom characteristics used for product differentiation and filtering."
input CreateItemFeaturesInput {
"Contains all features assigned to the item. Each feature represents a specific characteristic or attribute that describes the item in more detail, enabling better product differentiation and advanced filtering capabilities."
features: [CreateItemFeatureInput]
}
"Defines various identifiers of an item for creation. This structure includes all relevant markings and numbers used for unique identification of an item."
input CreateItemIdentifiersInput {
"Unique item number (Stock Keeping Unit) - the user-assigned main identification of the item."
sku: String
"Amazon FNSKU (Fulfillment Network Stock Keeping Unit) - used by Amazon for inventory management."
amazonFnsku: String
"GTIN (Global Trade Item Number, formerly EAN) - internationally standardized product identification for global trade."
gtin: String
"Manufacturer's item number - the official product number assigned by the manufacturer."
manufacturerNumber: String
"ISBN (International Standard Book Number) - mainly used for books and other publications."
isbn: String
"Taric code - customs tariff number for international trade and customs processing."
tariccode: String
"UPC (Universal Product Code) - barcode standard mainly used in North America."
upc: String
"UN number - used for marking dangerous goods in transport."
unNumber: String
"Hazard number - identifies the type of danger for hazardous goods in transport."
hazardNumber: String
"Own identifier - user-defined internal identification for company-specific purposes."
ownIdentifier: String
"Default ASIN (Amazon Standard Identification Number) - primary Amazon product identification."
defaultAsin: String
"JTL-Fulfillment-SKU (JFSKU) - unique identifier in the JTL Fulfillment Network (FFN) for item identification."
jfsku: String
}
input CreateItemImageInput {
"Unique ID to identify an image."
blobIdentifier: UUID!
"Sort order of the image."
sortNumber: Int!
"Declares the main image of the item. Typically the image with sort order 1."
isMainImage: Boolean!
}
input CreateItemImagesInput {
"List of default images assigned to the item."
defaultImages: [CreateItemImageInput]
"List of images assigned to different platforms."
platformImages: [CreatePlatformImagesInput]
"List of images assigned to different saleschannels."
saleschannelImages: [CreateSaleschannelImagesInput]
"List of images assigned to different eBay accounts."
ebayImages: [CreateEbayImagesInput]
}
"Defines the physical dimensions and weight specifications of an item for creation. This structure includes all relevant measurements for storage, shipping and product presentation and is used for shipping cost calculations and storage space optimizations."
input CreateItemMeasurementsInput {
"Height of the item in the configured unit of measurement (usually centimeters or millimeters)."
height: Decimal
"Length of the item in the configured unit of measurement (usually centimeters or millimeters)."
length: Decimal
"Shipping weight of the item for shipping cost calculation in the configured weight unit (usually kilograms or grams). May differ from the actual item weight."
shippingWeight: Decimal
"Actual weight of the item without packaging in the configured weight unit (usually kilograms or grams)."
weight: Decimal
"Width of the item in the configured unit of measurement (usually centimeters or millimeters)."
width: Decimal
}
"Defines a single price with tiering options and discount possibilities. This structure forms the basis for complex price structures with volume discounts and percentage price reductions from the standard price."
input CreateItemPriceInput {
"Minimum quantity from which this price applies - enables tier prices based on order quantity (e.g., from 10 pieces)."
fromQuantity: Int!
"Net price for this price tier without taxes - the actual selling price for the specified quantity tier."
netPrice: Decimal
"Percentage discount on the standard price - indicates by what percentage the standard price is reduced for this price tier. Used as an alternative to NetPrice."
reduceStandardPriceByPercent: Decimal
}
"Defines the complete price structure of an item for creation. This structure includes all price information for different sales channels, customer groups and individual customer prices as well as basic price information."
input CreateItemPricesInput {
"Indicates whether discounts should be ignored for this item. When set to true, no automatic discounts will be applied to the item prices."
ignoreDiscounts: Boolean
"Net sales price of the item without taxes and discounts - the basic selling price of the item."
salesPriceNet: Decimal
"Manufacturer's suggested retail price (MSRP) - the selling price recommended by the manufacturer."
suggestedRetailPrice: Decimal
"Net purchase price without taxes - the price at which the item was purchased."
purchasePriceNet: Decimal
"eBay-specific selling price - special price for eBay sales."
ebayPrice: Decimal
"Amazon-specific selling price - special price for Amazon sales."
amazonPrice: Decimal
"List of sales channel-specific prices - enables different pricing for various sales channels or shops."
salesChannelPrices: [CreateItemSaleschannelPricesInput]
"List of customer-specific prices - allows individual price agreements for specific customers."
customerPrices: [CreateItemCustomerPricesInput]
"List of default prices for different customer groups - these prices serve as fallback when no more specific prices are defined."
defaultPrices: [CreateItemCustomerGroupPricesInput]
}
"Defines sales channel-specific special prices for an item. This structure enables different promotional pricing for a specific sales channel or shop with customer group-related special price structures."
input CreateItemSalesChannelSpecialPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this special price structure applies."
salesChannelId: ID!
"List of special prices for different customer groups within this sales channel - enables differentiated promotional pricing by customer groups."
specialPrices: [CreateItemCustomerGroupSpecialPriceInput!]!
}
"Defines sales channel-specific prices for an item. This structure enables different pricing for various sales channels or shops with customer group-related price structures."
input CreateItemSaleschannelPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this price structure applies."
saleschannelId: ID!
"List of prices for different customer groups within this sales channel - enables differentiated pricing by customer groups."
customerGroupPrices: [CreateItemCustomerGroupPricesInput!]!
"Indicates whether this sales channel is active for the item - determines whether the item can be sold in this sales channel."
isActive: Boolean
}
"Defines the special prices (promotional prices) structure of an item. This structure includes time-based and stock-based special pricing for different sales channels and customer groups, as well as Amazon-specific special prices."
input CreateItemSpecialPricesInput {
"Indicates whether special prices are active for this item. When set to true, the special price rules defined below will be applied according to their conditions."
isActive: Boolean
"Date from which the special price becomes active. The special price will only be valid from this date onwards."
startDate: DateTime
"Date until which the special price remains active. The special price will expire after this date. Only evaluated if IsEndDateActive is true."
endDate: DateTime
"Indicates whether the end date should be considered. If false, the special price has no expiration date."
isEndDateActive: Boolean
"Minimum stock quantity that must be available for the special price to remain active. Only evaluated if IsStockRestrictionActive is true."
minimumStockQuantity: Int
"Indicates whether the stock restriction should be applied. When true, the special price is only active if the stock level is greater than or equal to MinimumStockQuantity. Can only be activated for items that use stock management."
isStockRestrictionActive: Boolean
"List of sales channel-specific special prices - enables different promotional pricing for various sales channels or shops with customer group differentiation."
salesChannelSpecialPrices: [CreateItemSalesChannelSpecialPricesInput]
}
"Defines the storage and inventory management constraints of an item. This structure includes settings for negative stock handling, inventory management, serial numbers, batch tracking, and best-before date management."
input CreateItemStorageConstraintsInput {
"Allows selling a higher quantity of the item than is actually in stock. This global setting must be activated first before platform-specific or sales channel-specific negative stock settings can be enabled."
allowNegativeStock: Boolean
"List of platform-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific platforms (e.g., eBay, Amazon). AllowNegativeStock must be activated as well for these settings to take effect."
itemPlatformNegativeStocks: [CreateNegativeStockPlatformInput]
"List of sales channel-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific sales channels or shops. AllowNegativeStock must be activated as well for these settings to take effect."
itemSalesChannelNegativeStocks: [CreateNegativeStockSalesChannelInput]
"Item buffer quantity - defines a safety stock buffer that is reserved and not available for sale. This helps prevent overselling and ensures availability for important orders."
buffer: Int
"Global minimum stock level across all warehouses. When the total stock falls below this value, the item is flagged for reordering. Used for automatic order suggestions and low-stock warnings."
globalMinimumStockLevel: Decimal
"Indicates whether the item uses batch management. When enabled, the item requires batch numbers to be assigned for each stock movement to enable tracking and traceability."
hasBatch: Boolean
"Determines if the item is working with inventory management. When active, stock levels are tracked and managed; when inactive, the item is treated as always available regardless of stock levels."
isInventoryManagementActive: Boolean
"Determines if the item is working with best-before date (MHD - Mindesthaltbarkeitsdatum) management. When enabled, stock items must have an assigned best-before date for tracking perishable goods."
isBestBeforeManaged: Boolean
"Determines if the item can be sold in split quantities (fractional units). When enabled, stock can be managed in decimal quantities (e.g., 2.5 pieces) instead of only whole numbers."
isStockDivisible: Boolean
"Determines the type of serial number processing. Defines whether serial numbers are inactive, active, or tracked for this item."
serialNumberType: SerialNumberType
}
input CreateItemSupplierInput {
"Id of the supplier"
supplierId: ID!
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Stock level of the item at the supplier."
stockLevel: Decimal
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"VAT rate of the item at the supplier."
vatRate: Decimal
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal
"Scale prices defined by the supplier for this item."
scalePrices: [CreateSupplierPriceInput]
}
input CreateItemSuppliersInput {
"Sets the default supplier for the item."
defaultSupplier: ID
"Sets the default supplier for dropshipping for the item."
defaultDropshippingSupplier: ID
"Assigned suppliers for the item"
suppliers: [CreateItemSupplierInput]
}
"Defines the item unit pricing settings for creation and modification. This structure includes all relevant information about the sales unit, packaging unit, inner quantity and base price details for an item."
input CreateItemUnitPricingInput {
"Id of the sales unit in which the item is sold (e.g. piece or box)."
salesUnitId: ID
"Id of the packaging unit of the item."
packagingUnitId: ID
"The amount of content for one piece of the sales unit, relative to the inner quantity unit."
innerQuantity: Decimal
"The measurement unit for the inner quantity (e.g. kg or liter)."
innerQuantityUnitId: ID
"Indicates whether the base price should be automatically calculated and displayed."
isBasePriceDeclared: Boolean
"The measurement unit to which the base price refers (e.g. per liter or per 100 grams)."
basePriceReferenceUnitId: ID
"The reference amount used when calculating the base price (e.g. 1 for per liter, 100 for per 100 grams)."
basePriceReferenceAmount: Decimal
}
input CreateItemVariationsInput {
"Contains all Variations"
variations: [CreateVariationInput]
}
"Defines which item properties should be copied when copying item details. This structure controls the copy behavior for all relevant item aspects."
input CreateItemdetailsCopyOptionsInput {
"Options for copying item attributes."
attributesCopyOptions: CreateAttributesCopyOptionsInput
"Options for copying item texts and descriptions."
descriptionsCopyOptions: CreateDescriptionsCopyOptionsInput
"Options for copying item images."
imagesCopyOptions: CreateImagesCopyOptionsInput
"Options for copying cross-selling data."
crossSellingCopyOptions: CreateCrossSellingCopyOptionsInput
"Options for copying download files."
downloadFilesCopyOptions: CreateDownloadFilesCopyOptionsInput
"Options for copying custom fields."
customFieldsCopyOptions: CreateCustomFieldsCopyOptionsInput
"Options for copying purchase prices."
purchasePricesCopyOptions: CreatePurchasePricesCopyOptionsInput
"Options for copying item identifiers."
identifiersCopyOptions: CreateIdentifiersCopyOptionsInput
"Options for copying item configurations."
configurationsCopyOptions: CreateConfigurationsCopyOptionsInput
"Options for copying supplier data."
suppliersCopyOptions: CreateSuppliersCopyOptionsInput
"Options for copying delivery options."
deliveryOptionsCopyOptions: CreateDeliveryOptionsCopyOptionsInput
"Options for copying dimensions and weights."
measurementsCopyOptions: CreateMeasurementsCopyOptionsInput
"Options for copying media files."
mediaFilesCopyOptions: CreateMediaFilesCopyOptionsInput
"Options for copying item characteristics."
characteristicsCopyOptions: CreateCharacteristicsCopyOptionsInput
"Options for copying online shop settings."
onlineShopsCopyOptions: CreateOnlineShopsCopyOptionsInput
"Options for copying over-sales settings."
oversalesCopyOptions: CreateOversalesCopyOptionsInput
"Options for copying SCX marketplace data."
scxCopyOptions: CreateScxCopyOptionsInput
"Options for copying special prices."
specialPricesCopyOptions: CreateSpecialPricesCopyOptionsInput
"Options for copying master data."
masterDataCopyOptions: CreateMasterDataCopyOptionsInput
"Options for copying bill of materials components."
bomComponentsCopyOptions: CreateBomComponentsCopyOptionsInput
"Options for copying upload files."
uploadFilesCopyOptions: CreateUploadFilesCopyOptionsInput
"Options for copying variations."
variationsCopyOptions: CreateVariationsCopyOptionsInput
"Options for copying sales prices."
salesPricesCopyOptions: CreateSalesPricesCopyOptionsInput
"Options for copying packaging settings."
packagingCopyOptions: CreatePackagingCopyOptionsInput
}
"Creates a new lot size for a production item. - Request"
input CreateLotSizeCommandRequestInput {
"The ID of the production item for which the lot size is to be created."
productionItemId: ID!
"The input for creating a lot size as part of a production item."
input: CreateLotSizeInput!
}
"Represents the input for creating a lot size as part of a production item."
input CreateLotSizeInput {
"The lot size value. Must be greater than zero."
lotSize: Int!
}
"Options for copying master data (manufacturer, product group, shipping class, tax class, etc.)."
input CreateMasterDataCopyOptionsInput {
"Indicates whether master data should be copied."
isActive: Boolean!
"Specifies whether to replace existing master data. Only Replace is applicable for master data as these are exclusive assignments."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating master data."
input CreateMasterDataDuplicationOptionsInput {
"Indicates whether master data should be duplicated."
isActive: Boolean
"Indicates whether the manufacturer should be considered during duplication."
considerManufacturer: Boolean
"Indicates whether the product group should be considered during duplication."
considerProductGroup: Boolean
"Indicates whether the tax class should be considered during duplication."
considerTaxClass: Boolean
"Indicates whether the shipping class should be considered during duplication."
considerShippingClass: Boolean
"Indicates whether the base price unit should be considered during duplication."
considerBasePriceUnit: Boolean
"Indicates whether minimum purchase settings should be considered during duplication."
considerMinimumPurchaseSettings: Boolean
"Indicates whether packaging information should be considered during duplication."
considerPackaging: Boolean
"Indicates whether the non-discountable flag should be considered during duplication."
considerNonDiscountable: Boolean
"Indicates whether the item type should be considered during duplication."
considerItemType: Boolean
"Indicates whether inventory management settings should be considered during duplication."
considerInventoryManagement: Boolean
"Indicates whether minimum and maximum inventory levels should be considered during duplication."
considerMinMaxInventory: Boolean
"Indicates whether the product compliance responsible person should be considered during duplication."
considerProductCompliancePerson: Boolean
}
"Options for copying dimensions and weights."
input CreateMeasurementsCopyOptionsInput {
"Indicates whether dimensions and weights should be copied."
isActive: Boolean!
"Specifies whether to replace existing dimensions and weights. Only Replace is applicable for measurements."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating dimensions and weights."
input CreateMeasurementssDuplicationOptionsInput {
"Indicates whether dimensions and weights should be duplicated."
isActive: Boolean
}
"Options for copying media files."
input CreateMediaFilesCopyOptionsInput {
"Indicates whether media files should be copied."
isActive: Boolean!
"Specifies whether to replace all existing media files or attach\/add new media files to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating media files."
input CreateMediaFilesDuplicationOptionsInput {
"Indicates whether media files should be duplicated."
isActive: Boolean
}
"Defines negative stock settings for a specific platform. This structure enables individual configuration of negative stock handling per platform (e.g., eBay, Amazon), allowing overselling for specific marketplaces when the global AllowNegativeStock is enabled."
input CreateNegativeStockPlatformInput {
"Key of the platform that identifies the specific marketplace or platform (e.g., eBay, Amazon) for which this negative stock setting applies."
platformId: ID!
"Determines if negative stock is allowed for this platform. When true, orders can be accepted even when the item is out of stock on this specific marketplace."
isNegativeStockAllowed: Boolean!
}
"Defines negative stock settings for a specific sales channel. This structure enables individual configuration of negative stock handling per sales channel, allowing overselling for specific online shops when the global AllowNegativeStock is enabled."
input CreateNegativeStockSalesChannelInput {
"Key of the sales channel that identifies the specific shop or sales channel for which this negative stock setting applies."
salesChannelId: ID!
"Determines if negative stock is allowed for this sales channel. When true, orders can be accepted even when the item is out of stock in this specific channel."
isNegativeStockAllowed: Boolean!
}
"Options for copying online shop settings and visibility."
input CreateOnlineShopsCopyOptionsInput {
"Indicates whether online shop settings should be copied."
isActive: Boolean!
"Specifies whether to replace all existing online shop settings or attach\/add new shop settings to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for copying over-sales settings."
input CreateOversalesCopyOptionsInput {
"Indicates whether over-sales settings should be copied."
isActive: Boolean!
"Specifies whether to replace existing over-sales settings or attach new ones. Only Replace is applicable for over-sales settings."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating over-sales settings."
input CreateOversalesDuplicationOptionsInput {
"Indicates whether over-sales settings should be duplicated."
isActive: Boolean
}
"Options for copying item packaging settings."
input CreatePackagingCopyOptionsInput {
"Indicates whether configurations should be copied."
isActive: Boolean!
"Specifies whether to replace all existing configurations or attach\/add new configurations to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for copying item packaging settings."
input CreatePackagingDuplicationOptionsInput {
"Indicates whether packaging settings should be duplicated."
isActive: Boolean!
}
"Defines a platform-specific description of an item. This enables different descriptions for various output platforms like print or other non-sales platforms."
input CreatePlatformDescriptionInput {
"Unique key of the platform for which this description is intended (e.g., print, labels)."
platformId: ID!
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the platform-specific description data with all relevant texts and SEO information."
descriptionData: CreateDescriptionDataInput!
}
input CreatePlatformImagesInput {
"Unique ID to identify a platform."
platformId: ID!
"List of images assigned to the platform."
images: [CreateItemImageInput]
}
"Creates a new production item, including its bills of materials with their components. - Request"
input CreateProductionItemCommandRequestInput {
"The input for creating the production item, including the details of the production item itself and the bills of materials and lot sizes to be created for the production item."
input: CreateProductionItemInput!
}
"Represents the input for creating a new production item, including the details of the production item itself and the bills of materials and lot sizes to be created for the production item."
input CreateProductionItemInput {
"The ID of the item for which the production item is to be created."
itemId: ID!
"Indicates whether this production item is a customized production item (true) or a regular production item (false)."
isCustomized: Boolean
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateId: ID
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no per-unit item label should be printed on completion. Optional."
singleItemLabelTemplateId: ID
"The bills of materials to create for this production item. At least one bill of materials is required. Each bill of materials must contain at least one operation, and across all operations, at least one component must be present."
billsOfMaterials: [CreateBillOfMaterialsInput!]!
"The optional lot sizes to create for this production item."
lotSizes: [CreateLotSizeInput]
}
"Creates a new production order. - Request"
input CreateProductionOrderCommandRequestInput {
"The input for creating the production order, including the production item, bill of materials, lot configuration, and optional scheduling details."
input: CreateProductionOrderInput!
}
"Represents the input for creating a new production order, including references to the production item, the bill of materials as well as the lot configuration and scheduling details."
input CreateProductionOrderInput {
"The ID of the production item for which the production order is to be created."
productionItemId: ID!
"The ID of the bill of materials to be used for production."
billOfMaterialsId: ID!
"The number of lots to be produced."
lotCount: Int!
"The size of each lot to be produced."
lotSize: Decimal!
"The planned total quantity to be produced."
targetTotalQuantity: Decimal!
"Indicates whether it is allowed for this order to have a target total quantity below the lot size (true) or not (false). Defaults to false."
isTargetTotalQuantityBelowLotSizeAllowed: Boolean
"The reference number associated with the production order."
referenceNumber: String
"The project number associated with the production order."
projectNumber: String
"Additional note on the order that will be displayed during production."
notice: String
"The planned start time of the production order."
targetStartTimestamp: DateTime
"The planned completion time of the production order."
targetCompletionTimestamp: DateTime
}
"Options for copying purchase prices."
input CreatePurchasePricesCopyOptionsInput {
"Indicates whether purchase prices should be copied."
isActive: Boolean!
"Specifies whether to replace existing purchase prices. Only Replace is applicable for purchase prices."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating purchase prices."
input CreatePurchasePricesDuplicationOptionsInput {
"Indicates whether purchase prices should be duplicated."
isActive: Boolean
}
"Defines a sales channel-specific description of an item. This enables individual customization of item descriptions for specific sales channels or shops."
input CreateSalesChannelDescriptionInput {
"Unique key of the sales channel or shop for which this description is intended."
salesChannelId: ID!
"ISO2 language code that determines the language for this sales channel-specific description."
languageIso: String!
"Contains the sales channel-specific description data with all relevant texts and SEO information."
descriptionData: CreateDescriptionDataInput!
}
input CreateSalesChannelSurchargeInput {
"Id of the saleschannel"
salesChannelId: ID!
"Contains the surcharges for that saleschannel and customergroup"
surcharges: [CreateCustomerGroupSurchargeInput!]!
}
"Create a new sales invoice for a salesorder - Request"
input CreateSalesInvoiceCommandRequestInput {
"The ID of the sales order to create the invoice for."
salesOrderId: ID!
"If true, only the delivered quantities of the sales order line items are added to the new invoice."
invoiceOnlyDeliveredQuantity: Boolean
"If true, the invoice will be created as a draft. An invoice draft has no invoice number yet and can be edited until finalized."
asDraft: Boolean
}
"Create a new sales invoice correction from an existing invoice - Request"
input CreateSalesInvoiceCorrectionCommandRequestInput {
"The ID of the sales invoice to create the correction for."
salesInvoiceId: ID!
"Indicates if the sales invoice correction should be created as draft."
asDraft: Boolean
"Indicates if only undelivered quantities should be used."
useUndeliveredQuantities: Boolean
"If true, the workflows do not trigger automatic."
disableAutomaticWorkflows: Boolean
"If true, the sales order quantities will be reduced."
reduceSalesOrderQuantities: Boolean
"If true, the delivery quantities will be reduced."
reduceDeliveryQuantities: Boolean
"If true, the web shop order will be canceled"
cancelWebShopOrder: Boolean
}
"Creates a new sales order. - Request"
input CreateSalesOrderCommandRequestInput {
"Indicates whether automatic workflows should be disabled for this sales order."
disableAutomaticWorkflows: Boolean
"Indicates whether the billing address should be used as the shipment address. If no shipment address is provided and the flag ist not set, the billing address will also be used as shipment address. If the shipment address is provided, this flag will be ignored."
useBillingAddressAsShipmentAddress: Boolean
"The SalesOrder CartonItemId"
cartonItemId: ID
"The SalesOrder CompanyId"
companyId: ID!
"The customer ID."
customerId: ID!
"The SalesOrder OnHoldReasonId"
onHoldReasonId: ID
"The SalesOrder PaymentMethodId"
paymentMethodId: ID
"The SalesOrder ProcessColourId"
processColourId: ID
"The SalesOrder ProcessStatusId"
processStatusId: ID
"SalesOrderBillingAddress"
billingAddress: CreateCreateSalesOrderAddressInput!
"DepartureCountry"
departureCountry: CreateCreateSalesOrderDepartureCountryInput!
"ExternalDetails"
externalDetails: CreateCreateSalesOrderExternalDetailsInput
"List of SalesOrderLineItem"
lineItems: [CreateCreateSalesOrderLineItemInput!]!
"PaymentDetails"
paymentDetails: CreateCreateSalesOrderPaymentDetailsInput!
"SalesOrderPaymentInfo"
paymentInfo: CreateCreateSalesOrderPaymentInfoInput
"SalesOrderShipmentAddress"
shipmentAddress: CreateCreateSalesOrderAddressInput
"ShippingDetails"
shippingDetails: CreateCreateSalesOrderShippingDetailsInput
"TaxDetails"
taxDetails: CreateCreateSalesOrderTaxDetailsInput
"SalesOrderText"
text: CreateCreateSalesOrderTextInput
"The SalesOrder CustomerSalesOrderNumber"
customerSalesOrderNumber: String
"The SalesOrder ItemDescriptionType"
itemDescriptionType: ItemDescriptionType
"The SalesOrder LanguageISO"
languageIso: String!
"The SalesOrder ReadOnlyType"
readOnlyType: ReadOnlyType
"The SalesOrder Date"
salesOrderDate: DateTime
"The SalesOrder SalesOrderNumber"
salesOrderNumber: String
"The SalesOrder ShippingMethodId"
shippingMethodId: ID
"The SalesOrder VATId"
vatId: String!
}
"Create a new sales order for a sales quotation - Request"
input CreateSalesOrderFromSalesQuotationCommandRequestInput {
"The ID of the sales quotation to create the order from."
salesQuotationId: ID!
}
"Options for copying sales prices including shop-specific and customer group prices."
input CreateSalesPricesCopyOptionsInput {
"Indicates whether sales prices should be copied."
isActive: Boolean!
"Specifies whether to replace all existing sales prices or attach\/add new price entries to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating sales prices."
input CreateSalesPricesDuplicationOptionsInput {
"Indicates whether sales prices should be duplicated."
isActive: Boolean
}
"Creates a new sales quotation. - Request"
input CreateSalesQuotationCommandRequestInput {
"Indicates whether automatic workflows should be disabled for this sales quotation."
disableAutomaticWorkflows: Boolean
"Indicates whether the billing address should be used as the shipment address. If no shipment address is provided and the flag ist not set, the billing address will also be used as shipment address. If the shipment address is provided, this flag will be ignored."
useBillingAddressAsShipmentAddress: Boolean
"The SalesQuotation CartonItemId"
cartonItemId: ID
"The SalesQuotation CompanyId"
companyId: ID!
"The customer ID."
customerId: ID!
"The SalesQuotation OnHoldReasonId"
onHoldReasonId: ID
"The SalesQuotation PaymentMethodId"
paymentMethodId: ID
"The SalesQuotation ProcessColourId"
processColourId: ID
"The SalesQuotation ProcessStatusId"
processStatusId: ID
"SalesQuotationBillingAddress"
billingAddress: CreateCreateSalesQuotationAddressInput!
"DepartureCountry"
departureCountry: CreateCreateSalesQuotationDepartureCountryInput!
"ExternalDetails"
externalDetails: CreateCreateSalesQuotationExternalDetailsInput
"List of SalesQuotationLineItem"
lineItems: [CreateCreateSalesQuotationLineItemInput!]!
"PaymentDetails"
paymentDetails: CreateCreateSalesQuotationPaymentDetailsInput!
"SalesQuotationPaymentInfo"
paymentInfo: CreateCreateSalesQuotationPaymentInfoInput
"SalesQuotationShipmentAddress"
shipmentAddress: CreateCreateSalesQuotationAddressInput
"ShippingDetails"
shippingDetails: CreateCreateSalesQuotationShippingDetailsInput
"TaxDetails"
taxDetails: CreateCreateSalesQuotationTaxDetailsInput
"SalesQuotationText"
text: CreateCreateSalesQuotationTextInput
"The SalesQuotation CustomerSalesQuotationNumber"
customerSalesQuotationNumber: String
"The VAT ID of the customer."
customerVatId: String
"The SalesQuotation ItemDescriptionType"
itemDescriptionType: ItemDescriptionType
"The SalesQuotation LanguageISO"
languageIso: String!
"The SalesQuotation ReadOnlyType"
readOnlyType: ReadOnlyType
"The SalesQuotation Date"
salesQuotationDate: DateTime
"The SalesQuotation SalesQuotationNumber"
salesQuotationNumber: String
"The SalesQuotation ShippingMethodId"
shippingMethodId: ID
"The SalesQuotation VATId"
vatId: String!
}
"Options for duplicating saleschannel settings."
input CreateSaleschannelDuplicationOptionsInput {
"Indicates whether saleschannel settings should be duplicated."
isActive: Boolean
"Indicates whether item highlight options should be considered during duplication. When true, special highlighting and promotional settings for sales channels will be duplicated."
considerHighlightOptions: Boolean
}
input CreateSaleschannelImagesInput {
"Unique ID to identify a saleschannel."
saleschannelId: ID!
"List of images assigned to the saleschannel."
images: [CreateItemImageInput]
}
"Options for copying SCX (shopping.com XML) marketplace data."
input CreateScxCopyOptionsInput {
"Indicates whether SCX data should be copied."
isActive: Boolean!
"Specifies whether to replace existing SCX data or attach\/add new SCX data to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating SCX data."
input CreateScxDuplicationOptionsInput {
"Indicates whether SCX data should be duplicated."
isActive: Boolean
"Indicates whether assigned categories should be considered during duplication. When true, category assignments for sales channels will be duplicated."
considerCategoryMappings: Boolean
"Indicates whether custom field values should be considered during duplication. When true, sales channel-specific custom field values will be duplicated."
considerSalesChannelFieldValues: Boolean
"Indicates whether all shops should be considered during duplication. When true, SCX data will be duplicated for all configured sales channels."
considerEveryShop: Boolean
"List of sales channel keys for which the SCX data should be duplicated. Only data for the specified sales channels will be copied to the new item."
shopsToConsider: [ID]
}
"Creates a new shipping box within a warehouse. - Request"
input CreateShippingBoxCommandRequestInput {
"Warehouse to create the box in."
warehouseId: ID!
"Display name for the box (must be unique within warehouse)."
displayId: String!
"Box type (immutable after creation)."
typeId: ID!
"Bin location to assign the box to."
binLocationId: ID!
"Optional list of free-form attributes."
attributes: [String!]!
}
"Creates a new shipping class - Request"
input CreateShippingClassCommandRequestInput {
"The name of the shipping class."
name: String!
}
"Options for copying special prices (Sonderpreise) including time-based promotional prices."
input CreateSpecialPricesCopyOptionsInput {
"Indicates whether special prices should be copied."
isActive: Boolean!
"Specifies whether to replace all existing special prices or attach\/add new special price entries to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating special prices."
input CreateSpecialPricesDuplicationOptionsInput {
"Indicates whether special prices should be duplicated."
isActive: Boolean
}
input CreateSupplierPriceInput {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal
}
"Options for copying supplier data."
input CreateSuppliersCopyOptionsInput {
"Indicates whether supplier data should be copied."
isActive: Boolean!
"Indicates whether the supplier-specific item SKU (article number) should be copied. When true, the SKU used by the supplier will be copied to the target items."
keepItemNumber: Boolean!
"Indicates whether the supplier-specific item name should be copied. When true, the item name used by the supplier will be copied to the target items."
keepItemName: Boolean!
"Specifies whether to replace all existing suppliers or attach\/add new suppliers to the existing supplier list."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating supplier data."
input CreateSuppliersDuplicationOptionsInput {
"Indicates whether supplier data should be duplicated."
isActive: Boolean
"Indicates whether the supplier-specific item SKU (article number) should be kept during duplication. When true, the SKU used by the supplier will be duplicated."
keepItemNumber: Boolean
"Indicates whether the supplier-specific item name should be kept during duplication. When true, the item name used by the supplier will be duplicated."
keepItemName: Boolean
}
"Creates a new tax class in the system - Request"
input CreateTaxClassCommandRequestInput {
"Whether this tax class is the standard tax class. Setting this to true will set all other tax classes to non-standard."
isStandard: Boolean!
"The name of the new tax class"
name: String!
"The type of the tax class"
taxType: TaxType!
}
"Creates a new tax code in the system - Request"
input CreateTaxCodeCommandRequestInput {
"The cash discount account of the new tax code"
cashDiscountAccount: String!
"The general ledger account of the new tax code"
generalLedgerAccount: String!
"Whether this tax code is automatic"
isAutomatic: Boolean!
"The name of the new tax code"
name: String!
"The number of the new tax code. If not provided, a number will be auto-assigned."
number: Int
}
"Options for copying upload files."
input CreateUploadFilesCopyOptionsInput {
"Indicates whether upload files should be copied."
isActive: Boolean!
"Specifies whether to replace all existing upload files or attach\/add new upload files to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating upload files."
input CreateUploadFilesDuplicationOptionsInput {
"Indicates whether upload files should be duplicated."
isActive: Boolean
}
input CreateVariationInput {
"Id of the Variation"
variationId: ID
"Position of this Variation in the List"
position: Int
"Descriptions of this Variation in multiple Languages"
descriptions: [CreateDescriptionInput!]!
"Values for this Variation"
values: [CreateVariationValueInput]
"Type of the Variation"
variationType: VariationType!
}
input CreateVariationValueInput {
"Id of the VariationValue"
variationValueId: ID
"Itemnumber for this variationvalue"
itemNumber: String
"GTIN for this variationvalue"
gtin: String
"Offset for the weight of this variationvalue"
weightOffset: Decimal
"Descriptions of this VariationValue in multiple Languages"
descriptions: [CreateDescriptionInput!]!
"Surcharges of this VariationValue"
surcharges: CreateVariationValueSurchargesInput
"Position of this VariationValue in the List"
position: Int
"Image for this variation value. This image will be used as the main image for the variation combination if this variation value is part of it and the variation combination doesn't have its own image."
image: ID
}
input CreateVariationValueSurchargesInput {
"Default Surcharge if there is none specified for a specific saleschannel + customergroup"
defaultSurchargeNet: Decimal
"Default Surcharges for specific customergroups in general, independent of saleschannel"
customerGroupSurcharges: [CreateCustomerGroupSurchargeInput]
"Surcharge for specific saleschannels + customergroups"
salesChannelSurcharges: [CreateSalesChannelSurchargeInput]
}
"Options for copying item variations."
input CreateVariationsCopyOptionsInput {
"Indicates whether variations should be copied."
isActive: Boolean!
"Specifies whether to replace all existing variations or attach\/add new variations to existing ones."
copyAction: ItemSettingCopyAction!
}
"Options for duplicating variations."
input CreateVariationsDuplicationOptionsInput {
"Indicates whether variations should be duplicated."
isActive: Boolean
}
"Creates a new warehouse zone. - Request"
input CreateWarehouseZoneCommandRequestInput {
"Warehouse to create the zone in."
warehouseId: ID!
"Zone short code (must be unique within the warehouse)."
code: String!
"Zone type (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: Int!
"Optional zone description."
description: String
}
"Creates a new workbench resource - Request"
input CreateWorkbenchResourceCommandRequestInput {
"This workbench resource's unique number."
number: String!
"This workbench resource's name."
name: String!
"This workbench resource's description."
description: String!
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ID!
"The name of the host assigned to this workbench resource."
hostName: String!
"The ID of the warehouse assigned to this workbench resource."
warehouseId: ID!
"The reservation mode of this workbench resource."
reservationMode: ReservationMode!
"Specifies whether the dialog for displaying and\/or capturing process parameter values in the context of production should be displayed automatically when process parameter values can\/must be displayed or captured."
autoShowProcessParameterValuesInProduction: Boolean!
"Specifies whether and to what extent the use of expired components is permitted."
expiredComponentsUsage: ExpiredComponentsUsage!
"Specifies wthether and how available stock should be reserved when creating a replenishment order."
replenishmentCreationStockReservationMode: ReplenishmentCreationAvailableStockReservationMode!
}
"Creates a new workbench resource type - Request"
input CreateWorkbenchResourceTypeCommandRequestInput {
"The workbench resource type's name."
name: String!
}
"Single row of the currencies overview table"
input CurrencyFilterInput {
and: [CurrencyFilterInput!]
or: [CurrencyFilterInput!]
"Currency id"
id: ComparableWaehrungKeyOperationFilterInput
"ISO code of the currency"
iso: StringOperationFilterInput
"Name of the currency"
name: StringOperationFilterInput
"Currency factor"
factor: ComparableDecimalOperationFilterInput
"Is default currency"
isDefault: ComparableBooleanOperationFilterInput
"Date and time of the last update"
updated: ComparableNullableOfDateTimeOffsetOperationFilterInput
}
"Single row of the currencies overview table"
input CurrencySortInput {
"Currency id"
id: WaehrungKeySortInput @cost(weight: "10")
"ISO code of the currency"
iso: SortEnumType @cost(weight: "10")
"Name of the currency"
name: SortEnumType @cost(weight: "10")
"Currency factor"
factor: SortEnumType @cost(weight: "10")
"Is default currency"
isDefault: SortEnumType @cost(weight: "10")
"Date and time of the last update"
updated: SortEnumType @cost(weight: "10")
}
"Metadata definition of custom fields (Eigene Felder)"
input CustomFieldListItemFilterInput {
and: [CustomFieldListItemFilterInput!]
or: [CustomFieldListItemFilterInput!]
"Unique identifier of the custom field."
customFieldKey: ComparableEigenesFeldKeyOperationFilterInput
"Name of the custom field in the specified language."
name: StringOperationFilterInput
"Group name where the custom field belongs to."
group: StringOperationFilterInput
"Data type of the custom field. Possible values: Kein = No specific type, Ganzzahl = Integer number, FliesskommaZahl = Floating point number, Text = Free text, Checkbox = Boolean checkbox, Liste = Selection list, Url = Website URL, EMail = Email address, TelNr = Phone number, LandIso = Country ISO code, Preis = Price\/Currency, Datum = Date, KurzText = Short text"
customFieldType: ComparableCustomFieldTypeOperationFilterInput
"The underlying .NET data type of the CustomFieldType: 'int' for Ganzzahl and Checkbox, 'string' for Text, KurzText, Url, EMail, TelNr, LandIso, Liste, and Kein, 'decimal' for FliesskommaZahl and Preis, 'DateTime' for Datum"
dataType: StringOperationFilterInput
"Entity type the custom field belongs to (e.g., Artikel, Kategorie, Kunde)."
referenceType: ComparableCustomFieldReferenceTypeOperationFilterInput
"Indicates whether the field is mandatory."
isRequired: ComparableBooleanOperationFilterInput
"Indicates whether the field value is readonly."
isReadonly: ComparableBooleanOperationFilterInput
"Indicates whether the field is hidden in UI."
isInvisible: ComparableBooleanOperationFilterInput
}
"Metadata definition of custom fields (Eigene Felder)"
input CustomFieldListItemSortInput {
"Unique identifier of the custom field."
customFieldKey: EigenesFeldKeySortInput @cost(weight: "10")
"Name of the custom field in the specified language."
name: SortEnumType @cost(weight: "10")
"Group name where the custom field belongs to."
group: SortEnumType @cost(weight: "10")
"Sort order within the group."
sort: SortEnumType @cost(weight: "10")
"Data type of the custom field. Possible values: Kein = No specific type, Ganzzahl = Integer number, FliesskommaZahl = Floating point number, Text = Free text, Checkbox = Boolean checkbox, Liste = Selection list, Url = Website URL, EMail = Email address, TelNr = Phone number, LandIso = Country ISO code, Preis = Price\/Currency, Datum = Date, KurzText = Short text"
customFieldType: SortEnumType @cost(weight: "10")
"The underlying .NET data type of the CustomFieldType: 'int' for Ganzzahl and Checkbox, 'string' for Text, KurzText, Url, EMail, TelNr, LandIso, Liste, and Kein, 'decimal' for FliesskommaZahl and Preis, 'DateTime' for Datum"
dataType: SortEnumType @cost(weight: "10")
}
"Model Class: CustomerCategory"
input CustomerCategoryFilterInput {
and: [CustomerCategoryFilterInput!]
or: [CustomerCategoryFilterInput!]
"Unique internal ID of the customer category."
id: ComparableKundenKategorieKeyOperationFilterInput
"The name of the customer category."
name: StringOperationFilterInput
}
"Model Class: CustomerCategory"
input CustomerCategorySortInput {
"Unique internal ID of the customer category."
id: KundenKategorieKeySortInput @cost(weight: "10")
"The name of the customer category."
name: SortEnumType @cost(weight: "10")
}
"Model Class: CustomerGroup"
input CustomerGroupFilterInput {
and: [CustomerGroupFilterInput!]
or: [CustomerGroupFilterInput!]
"Unique internal ID of the customer group."
id: ComparableKundenGruppeKeyOperationFilterInput
"The name of the customer group."
name: StringOperationFilterInput
"Indicates if the customer group is the default group. Only one group can be selected as the default group."
isDefault: ComparableBooleanOperationFilterInput
"The discounted percentage for the customer group."
discount: ComparableDecimalOperationFilterInput
"Indicates if the customer group sees the net price in the online shop."
isNetPrice: ComparableBooleanOperationFilterInput
}
"Model Class: CustomerGroup"
input CustomerGroupSortInput {
"Unique internal ID of the customer group."
id: KundenGruppeKeySortInput @cost(weight: "10")
"The name of the customer group."
name: SortEnumType @cost(weight: "10")
"Indicates if the customer group is the default group. Only one group can be selected as the default group."
isDefault: SortEnumType @cost(weight: "10")
"The discounted percentage for the customer group."
discount: SortEnumType @cost(weight: "10")
"Indicates if the customer group sees the net price in the online shop."
isNetPrice: SortEnumType @cost(weight: "10")
}
"Single row of the customers overview table"
input CustomerListItemFilterInput {
and: [CustomerListItemFilterInput!]
or: [CustomerListItemFilterInput!]
"Customer id"
id: ComparableKundeKeyOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer's eBay user name."
ebayName: StringOperationFilterInput
"Customer's date of birth."
birthday: StringOperationFilterInput
"Customer's homepage URL."
homepage: StringOperationFilterInput
"Last name of the customer"
lastName: StringOperationFilterInput
"First name of the customer"
firstName: StringOperationFilterInput
"Phone number."
phoneNumber: StringOperationFilterInput
"Fax number."
faxNumber: StringOperationFilterInput
"Email address."
emailAddress: StringOperationFilterInput
"Company name (if applicable)."
companyName: StringOperationFilterInput
"Postal code."
postalCode: StringOperationFilterInput
"City."
city: StringOperationFilterInput
"Country name."
countryName: StringOperationFilterInput
"ISO-Code of the country."
countryIso: StringOperationFilterInput
"Company extension."
additionalCompanyLine: StringOperationFilterInput
"Formal salutation (e.g., Mr., Ms.)."
salutation: StringOperationFilterInput
"Academic or professional title."
title: StringOperationFilterInput
"Street and house number."
street: StringOperationFilterInput
"Additional address information."
additionalAddressLine: StringOperationFilterInput
"Date the customer record was created."
createdDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Mobile phone number."
mobilePhoneNumber: StringOperationFilterInput
"Customer-specific discount rate."
discountRate: ComparableNullableOfDecimalOperationFilterInput
"VAT identification number."
vatId: StringOperationFilterInput
"Subscription status for the newsletter."
hasNewsletter: ComparableBooleanOperationFilterInput
"Customer's PostID (specific delivery identifier)."
postId: StringOperationFilterInput
"Number of days for payment terms."
paymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Federal state or province."
state: StringOperationFilterInput
"Source or origin of the customer."
initialContact: StringOperationFilterInput
"Flag indicating if the customer is a cash register\/POS customer."
isCashRegisterBased: ComparableBooleanOperationFilterInput
"Account lock status."
isLocked: ComparableBooleanOperationFilterInput
"Commercial register number."
commercialRegisterNumber: StringOperationFilterInput
"Accounts receivable number for accounting."
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Name of the customer category."
customerCategoryName: StringOperationFilterInput
"Name of the customer group."
customerGroupName: StringOperationFilterInput
"Key\/ID of the customer category."
customerCategoryId: ComparableKundenKategorieKeyOperationFilterInput
"Key\/ID of the customer group."
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Flag indicating participation in JTL Fulfillment."
isJtlFulfillment: ComparableBooleanOperationFilterInput
"Comma-separated list of all assigned customer labels."
labels: StringOperationFilterInput
"The language iso code of the customer"
languageIso: StringOperationFilterInput
}
"Single row of the customers overview table"
input CustomerListItemSortInput {
"Customer id"
id: KundeKeySortInput @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer's eBay user name."
ebayName: SortEnumType @cost(weight: "10")
"Customer's date of birth."
birthday: SortEnumType @cost(weight: "10")
"Customer's homepage URL."
homepage: SortEnumType @cost(weight: "10")
"Last name of the customer"
lastName: SortEnumType @cost(weight: "10")
"First name of the customer"
firstName: SortEnumType @cost(weight: "10")
"Phone number."
phoneNumber: SortEnumType @cost(weight: "10")
"Fax number."
faxNumber: SortEnumType @cost(weight: "10")
"Email address."
emailAddress: SortEnumType @cost(weight: "10")
"Company name (if applicable)."
companyName: SortEnumType @cost(weight: "10")
"Postal code."
postalCode: SortEnumType @cost(weight: "10")
"City."
city: SortEnumType @cost(weight: "10")
"Country name."
countryName: SortEnumType @cost(weight: "10")
"ISO-Code of the country."
countryIso: SortEnumType @cost(weight: "10")
"Company extension."
additionalCompanyLine: SortEnumType @cost(weight: "10")
"Formal salutation (e.g., Mr., Ms.)."
salutation: SortEnumType @cost(weight: "10")
"Academic or professional title."
title: SortEnumType @cost(weight: "10")
"Street and house number."
street: SortEnumType @cost(weight: "10")
"Additional address information."
additionalAddressLine: SortEnumType @cost(weight: "10")
"Date the customer record was created."
createdDate: SortEnumType @cost(weight: "10")
"Mobile phone number."
mobilePhoneNumber: SortEnumType @cost(weight: "10")
"Customer-specific discount rate."
discountRate: SortEnumType @cost(weight: "10")
"VAT identification number."
vatId: SortEnumType @cost(weight: "10")
"Subscription status for the newsletter."
hasNewsletter: SortEnumType @cost(weight: "10")
"Customer's PostID (specific delivery identifier)."
postId: SortEnumType @cost(weight: "10")
"Number of days for payment terms."
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Federal state or province."
state: SortEnumType @cost(weight: "10")
"Source or origin of the customer."
initialContact: SortEnumType @cost(weight: "10")
"Flag indicating if the customer is a cash register\/POS customer."
isCashRegisterBased: SortEnumType @cost(weight: "10")
"Account lock status."
isLocked: SortEnumType @cost(weight: "10")
"Commercial register number."
commercialRegisterNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number for accounting."
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Name of the customer category."
customerCategoryName: SortEnumType @cost(weight: "10")
"Name of the customer group."
customerGroupName: SortEnumType @cost(weight: "10")
"Key\/ID of the customer category."
customerCategoryId: KundenKategorieKeySortInput @cost(weight: "10")
"Key\/ID of the customer group."
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Flag indicating participation in JTL Fulfillment."
isJtlFulfillment: SortEnumType @cost(weight: "10")
"Comma-separated list of all assigned customer labels."
labels: SortEnumType @cost(weight: "10")
"The language iso code of the customer"
languageIso: SortEnumType @cost(weight: "10")
}
"Deactivates a bin location, making it unavailable for operations. - Request"
input DeactivateBinLocationCommandRequestInput {
"Unique identifier of the bin location to deactivate."
binLocationId: ID!
}
"Deactivates a language in the system - Request"
input DeactivateLanguageCommandRequestInput {
"The culture or ISO code of the language to be deactivate."
cultureOrIso: String!
}
"Deletes a bill of materials. - Request"
input DeleteBillOfMaterialsCommandRequestInput {
"The ID of the bill of materials to be deleted."
id: ID!
}
"Deletes a bill of materials item from a bill of materials. - Request"
input DeleteBillOfMaterialsItemCommandRequestInput {
"The ID of the bill of materials item to be deleted."
id: ID!
}
"Deletes a bill of materials operation from a bill of materials. - Request"
input DeleteBillOfMaterialsOperationCommandRequestInput {
"The ID of the bill of materials operation to be deleted."
id: ID!
}
"Deletes a bin location from the warehouse. - Request"
input DeleteBinLocationCommandRequestInput {
"Unique identifier of the bin location to delete."
binLocationId: ID!
}
"Delete a Category - Request"
input DeleteCategoryCommandRequestInput {
"The category to delete"
id: ID!
"The destination category to which all remaining child categories will be moved."
moveChildrenTargetId: ID
}
"Removes an existing variation from an item. All associated variation values and combinations will also be removed. - Request"
input DeleteItemVariationCommandRequestInput {
"Unique ID of the variation to be deleted."
variationId: ID!
}
"Removes a specific value from an item variation. - Request"
input DeleteItemVariationValueCommandRequestInput {
"Unique ID of the variation value to be deleted."
variationValueId: ID!
}
"Deletes the specified marketplace offers. - Request"
input DeleteMarketplaceOfferCommandRequestInput {
"Marketplace offer keys to delete."
offerKeys: [ID]!
"If true, related marketplace assignment data is removed from items as well."
removeDataFromItem: Boolean!
}
"Deletes an existing payment. - Request"
input DeletePaymentCommandRequestInput {
"The ID of the payment to delete."
id: ID!
}
"Delete existing product groups. - Request"
input DeleteProductGroupsCommandRequestInput {
"IDs of the product groups to delete."
ids: [ID]!
}
"Permanently deletes a shipping box and all its attributes (Rule SB-8). - Request"
input DeleteShippingBoxCommandRequestInput {
"The shipping box to delete."
shippingBoxId: ID!
}
"Deletes an existing tax class - Request"
input DeleteTaxClassCommandRequestInput {
"The ID of the tax class to delete"
id: ID!
}
"Deletes an existing tax code - Request"
input DeleteTaxCodeCommandRequestInput {
"The ID of the tax code to delete"
id: ID!
}
"Deletes a warehouse zone. - Request"
input DeleteWarehouseZoneCommandRequestInput {
"The zone to delete."
zoneId: ID!
}
"Creates one or more duplicates of an existing item with specified duplication options. - Request"
input DuplicateItemsCommandRequestInput {
"The unique identifier of the source item to be duplicated."
duplicateItemId: ID!
"The basic information (SKU and name) for the items to be created as duplicates."
duplicatesToCreate: [CreateItemDuplicateInput!]!
"Indicates whether the item creation workflow should be executed after creating the duplicates."
executeItemCreatedWorkflowOnCreation: Boolean!
"Specifies which properties and aspects of the source item should be duplicated to the new items."
itemDuplicationOptions: CreateItemDuplicationOptionsInput!
}
input EigenesFeldKeySortInput {
kAttribut: SortEnumType @cost(weight: "10")
}
"Last tracked bin location activity per employee."
input EmployeeLocationItemFilterInput {
and: [EmployeeLocationItemFilterInput!]
or: [EmployeeLocationItemFilterInput!]
"Employee user ID (kBenutzer)."
userIdentifier: ComparableInt32OperationFilterInput
"Employee display name."
userName: StringOperationFilterInput
"Timestamp of the last tracked activity."
lastActivityTimestamp: ComparableDateTimeOperationFilterInput
"Bin location where the last activity occurred."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Activity type of the last activity."
activityTypeId: ComparableBuchungsArtKeyOperationFilterInput
"Display name of the activity type."
activityTypeName: StringOperationFilterInput
}
"Last tracked bin location activity per employee."
input EmployeeLocationItemSortInput {
"Employee user ID (kBenutzer)."
userIdentifier: SortEnumType @cost(weight: "10")
"Employee display name."
userName: SortEnumType @cost(weight: "10")
"Timestamp of the last tracked activity."
lastActivityTimestamp: SortEnumType @cost(weight: "10")
"Display name of the activity type."
activityTypeName: SortEnumType @cost(weight: "10")
}
"Ends the specified marketplace offers for a shop. - Request"
input EndMarketplaceOfferCommandRequestInput {
"Shop key identifying the shop where the offers are listed."
shopKey: ID!
"Marketplace offer keys to end."
offerKeys: [ID]!
}
"Exclude marketplace invoice corrections from upload. - Request"
input ExcludeMarketplaceInvoiceCorrectionFromUploadCommandRequestInput {
"Marketplace order keys of invoice corrections to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace invoice correction PDFs from upload. - Request"
input ExcludeMarketplaceInvoiceCorrectionPdfFromUploadCommandRequestInput {
"Upload document IDs of invoice correction PDFs to exclude from upload."
documentUploadQueueKeys: [ID]!
}
"Exclude marketplace invoice PDFs from upload. - Request"
input ExcludeMarketplaceInvoicePdfFromUploadCommandRequestInput {
"Upload document IDs of invoice PDFs to exclude from upload."
documentUploadQueueKeys: [ID]!
}
"Exclude marketplace order cancellation uploads from upload. - Request"
input ExcludeMarketplaceOrderCancellationUploadFromUploadCommandRequestInput {
"Marketplace order keys of cancellation uploads to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace payment uploads from upload. - Request"
input ExcludeMarketplacePaymentUploadFromUploadCommandRequestInput {
"Marketplace order keys of payment uploads to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace return uploads from upload. - Request"
input ExcludeMarketplaceReturnUploadFromUploadCommandRequestInput {
"Marketplace order keys of return uploads to exclude from upload."
orderKeys: [ID]!
}
"Exclude marketplace shipping information uploads from upload. - Request"
input ExcludeMarketplaceShippingInformationUploadFromUploadCommandRequestInput {
"Marketplace order shipping keys of shipping information uploads to exclude from upload."
orderShippingKeys: [ID]!
}
input ExternalDocumentInternalFilterInput {
and: [ExternalDocumentInternalFilterInput!]
or: [ExternalDocumentInternalFilterInput!]
"Primary key of document"
externalDocumentTransactionId: ComparableExternerBelegTransaktionKeyOperationFilterInput
"Primary key of company"
companyId: ComparableFirmaKeyOperationFilterInput
"Primary key of customer"
customerId: ComparableKundeKeyOperationFilterInput
"Primary key of platform"
platformId: ComparablePlattformKeyOperationFilterInput
"Primary key of payment type document"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Primary key of invoice"
externalInvoiceDocumentId: ComparableExternerBelegKeyOperationFilterInput
"Invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Credit note number"
externalDocumentNumber: StringOperationFilterInput
"Document date"
externalDocumentDate: ComparableDateTimeOffsetOperationFilterInput
"External order number"
externalDocumentOrderNumber: StringOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Currency code"
currency: StringOperationFilterInput
"Shipping currency code"
departureCountryCurrencyIso: StringOperationFilterInput
"Shipping currency factor"
departureCountryCurrenyFactor: ComparableNullableOfDecimalOperationFilterInput
"Service date"
serviceDate: ComparableDateTimeOffsetOperationFilterInput
"Payment date"
payDate: ComparableDateTimeOffsetOperationFilterInput
"Platform ID"
platformIdentifier: StringOperationFilterInput
"Debtor number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Tax setting"
taxSetting: ComparableByteOperationFilterInput
"Document type"
externalDocumentType: ComparableByteOperationFilterInput
"Country VAT ID"
companyVatIdNumber: StringOperationFilterInput
"Seller VAT ID"
customerVatIdNumber: StringOperationFilterInput
"Shipping country ISO code"
departureCountryIso: StringOperationFilterInput
"Payment information"
paymentMethodName: StringOperationFilterInput
"Order date"
orderDate: ComparableDateTimeOffsetOperationFilterInput
"Shipping company name"
shipmentAddressCompany: StringOperationFilterInput
"Shipping last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipping street address"
shipmentAddressStreet: StringOperationFilterInput
"Shipping ZIP code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipping city"
shipmentAddressCity: StringOperationFilterInput
"Shipping phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipping additional address information"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipping country ISO code"
shipmentAddressCountryIso: StringOperationFilterInput
"Shipping VAT ID"
shipmentAddressVatIdNumber: StringOperationFilterInput
"Customer company name"
customerDefaultBillingAddressCompany: StringOperationFilterInput
"Customer salutation"
customerDefaultBillingAddressSalutation: StringOperationFilterInput
"Customer title"
customerDefaultBillingAddressTitle: StringOperationFilterInput
"Customer first name"
customerDefaultBillingAddressFirstName: StringOperationFilterInput
"Customer last name"
customerDefaultBillingAddressLastName: StringOperationFilterInput
"Customer street address"
customerDefaultBillingAddressStreet: StringOperationFilterInput
"Customer ZIP code"
customerDefaultBillingAddressPostalCode: StringOperationFilterInput
"Customer city"
customerDefaultBillingAddressCity: StringOperationFilterInput
"Customer country"
customerDefaultBillingAddressCountry: StringOperationFilterInput
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerDefaultBillingAddressFaxNumber: StringOperationFilterInput
"Customer additional information"
customerDefaultBillingAddressForTheAttentionOf: StringOperationFilterInput
"Customer country ISO code"
customerDefaultBillingAddressCountryIso: StringOperationFilterInput
"Customer email address"
customerDefaultBillingAddressEmailAddress: StringOperationFilterInput
"Customer VAT ID"
customerDefaultBillingAddressVatIdNumber: StringOperationFilterInput
"Customer number from sales order"
salesOrderCustomerNumber: StringOperationFilterInput
"Customer group"
customerGroupName: StringOperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableInt32OperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Invoice company name"
billingAddressCompany: StringOperationFilterInput
"Invoice last name"
billingAddressLastName: StringOperationFilterInput
"Invoice street address"
billingAddressStreet: StringOperationFilterInput
"Invoice ZIP code"
billingAddressPostalCode: StringOperationFilterInput
"Invoice city"
billingAddressCity: StringOperationFilterInput
"Invoice phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Invoice additional address information"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Invoice country ISO code"
billingAddressCountryIso: StringOperationFilterInput
"Invoice VAT ID"
billingAddressVatIdNumber: StringOperationFilterInput
"Document total gross value"
externalDocumentTotalGrossValue: ComparableDecimalOperationFilterInput
"Document total net value"
externalDocumentTotalNetValue: ComparableDecimalOperationFilterInput
"Shipping date"
shipmentDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Order payment type"
orderPaymentMethodName: StringOperationFilterInput
"Shipping country count"
shipmentCountryCount: ComparableInt32OperationFilterInput
}
input ExternalDocumentInternalSortInput {
"Primary key of document"
externalDocumentTransactionId: ExternerBelegTransaktionKeySortInput @cost(weight: "10")
"Primary key of company"
companyId: FirmaKeySortInput @cost(weight: "10")
"Primary key of customer"
customerId: KundeKeySortInput @cost(weight: "10")
"Primary key of platform"
platformId: PlattformKeySortInput @cost(weight: "10")
"Primary key of payment type document"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Primary key of invoice"
externalInvoiceDocumentId: ExternerBelegKeySortInput @cost(weight: "10")
"Invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Credit note number"
externalDocumentNumber: SortEnumType @cost(weight: "10")
"Document date"
externalDocumentDate: SortEnumType @cost(weight: "10")
"External order number"
externalDocumentOrderNumber: SortEnumType @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Currency code"
currency: SortEnumType @cost(weight: "10")
"Shipping currency code"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Shipping currency factor"
departureCountryCurrenyFactor: SortEnumType @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Payment date"
payDate: SortEnumType @cost(weight: "10")
"Platform ID"
platformIdentifier: SortEnumType @cost(weight: "10")
"Debtor number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"Document type"
externalDocumentType: SortEnumType @cost(weight: "10")
"Country VAT ID"
companyVatIdNumber: SortEnumType @cost(weight: "10")
"Seller VAT ID"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"Shipping country ISO code"
departureCountryIso: SortEnumType @cost(weight: "10")
"Payment information"
paymentMethodName: SortEnumType @cost(weight: "10")
"Order date"
orderDate: SortEnumType @cost(weight: "10")
"Shipping company name"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipping last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipping street address"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipping ZIP code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipping city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipping phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipping additional address information"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipping country ISO code"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipping VAT ID"
shipmentAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer company name"
customerDefaultBillingAddressCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerDefaultBillingAddressSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerDefaultBillingAddressTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerDefaultBillingAddressFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerDefaultBillingAddressLastName: SortEnumType @cost(weight: "10")
"Customer street address"
customerDefaultBillingAddressStreet: SortEnumType @cost(weight: "10")
"Customer ZIP code"
customerDefaultBillingAddressPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerDefaultBillingAddressCity: SortEnumType @cost(weight: "10")
"Customer country"
customerDefaultBillingAddressCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerDefaultBillingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Customer additional information"
customerDefaultBillingAddressForTheAttentionOf: SortEnumType @cost(weight: "10")
"Customer country ISO code"
customerDefaultBillingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer email address"
customerDefaultBillingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer VAT ID"
customerDefaultBillingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number from sales order"
salesOrderCustomerNumber: SortEnumType @cost(weight: "10")
"Customer group"
customerGroupName: SortEnumType @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Invoice company name"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Invoice last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Invoice street address"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Invoice ZIP code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Invoice city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Invoice phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Invoice additional address information"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Invoice country ISO code"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Invoice VAT ID"
billingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Document total gross value"
externalDocumentTotalGrossValue: SortEnumType @cost(weight: "10")
"Document total net value"
externalDocumentTotalNetValue: SortEnumType @cost(weight: "10")
"Shipping date"
shipmentDate: SortEnumType @cost(weight: "10")
"Order payment type"
orderPaymentMethodName: SortEnumType @cost(weight: "10")
"Shipping country count"
shipmentCountryCount: SortEnumType @cost(weight: "10")
}
input ExternalDocumentLineItemInternalFilterInput {
and: [ExternalDocumentLineItemInternalFilterInput!]
or: [ExternalDocumentLineItemInternalFilterInput!]
"External document line item ID"
externalDocumentLineItemId: ComparableExternerBelegPositionKeyOperationFilterInput
"External document ID"
externalDocumentId: ComparableExternerBelegKeyOperationFilterInput
"Sales price gross"
externalDocumentSalesPriceGross: ComparableDecimalOperationFilterInput
"External document sales price net"
externalDocumentSalesPriceNet: ComparableDecimalOperationFilterInput
"External document purchase price net"
externalDocumentPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Quantity"
quantity: ComparableDecimalOperationFilterInput
"Item name"
itemName: StringOperationFilterInput
"SKU"
sku: StringOperationFilterInput
"Tax rate"
taxRate: ComparableDecimalOperationFilterInput
"Tax class ID"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Taric code"
taric: StringOperationFilterInput
"Item weight"
itemWeight: ComparableNullableOfDecimalOperationFilterInput
"Item volume"
itemVolume: ComparableNullableOfDecimalOperationFilterInput
"Product group ID"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Purchase price net"
purchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Product group"
productGroup: StringOperationFilterInput
"Warehouse ID"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"External document invoice line item ID"
externalDocumentInvoiceLineItemId: ComparableExternerBelegPositionKeyOperationFilterInput
}
input ExternalDocumentLineItemInternalSortInput {
"External document line item ID"
externalDocumentLineItemId: ExternerBelegPositionKeySortInput @cost(weight: "10")
"External document ID"
externalDocumentId: ExternerBelegKeySortInput @cost(weight: "10")
"Sales price gross"
externalDocumentSalesPriceGross: SortEnumType @cost(weight: "10")
"External document sales price net"
externalDocumentSalesPriceNet: SortEnumType @cost(weight: "10")
"External document purchase price net"
externalDocumentPurchasePriceNet: SortEnumType @cost(weight: "10")
"Quantity"
quantity: SortEnumType @cost(weight: "10")
"Item name"
itemName: SortEnumType @cost(weight: "10")
"SKU"
sku: SortEnumType @cost(weight: "10")
"Tax rate"
taxRate: SortEnumType @cost(weight: "10")
"Tax class ID"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Taric code"
taric: SortEnumType @cost(weight: "10")
"Item weight"
itemWeight: SortEnumType @cost(weight: "10")
"Item volume"
itemVolume: SortEnumType @cost(weight: "10")
"Product group ID"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Purchase price net"
purchasePriceNet: SortEnumType @cost(weight: "10")
"Product group"
productGroup: SortEnumType @cost(weight: "10")
"Warehouse ID"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"External document invoice line item ID"
externalDocumentInvoiceLineItemId: ExternerBelegPositionKeySortInput @cost(weight: "10")
}
"ExternerBeleg Key"
input ExternerBelegKeySortInput {
"Gets the identifier for ExternerBeleg"
kExternerBeleg: SortEnumType @cost(weight: "10")
}
"ExternerBeleg Key"
input ExternerBelegPositionKeySortInput {
"Gets the identifier for ExternerBeleg"
kExternerBelegPosition: SortEnumType @cost(weight: "10")
}
"ExternerBeleg Key"
input ExternerBelegTransaktionKeySortInput {
"Gets the identifier for ExternerBelegTransaktion"
kExternerBelegTransaktion: SortEnumType @cost(weight: "10")
}
"Represents a key for identifying a firm within the application."
input FirmaKeySortInput {
"Gets the unique identifier for the firm."
kFirma: SortEnumType @cost(weight: "10")
}
input GutschriftKeySortInput {
kGutschrift: SortEnumType @cost(weight: "10")
}
input GutschriftPosKeySortInput {
kGutschriftPos: SortEnumType @cost(weight: "10")
}
input HerstellerKeySortInput {
kHersteller: SortEnumType @cost(weight: "10")
}
"Single row of the item overview"
input ItemListItemFilterInput {
and: [ItemListItemFilterInput!]
or: [ItemListItemFilterInput!]
"Item id"
id: ComparableArtikelKeyOperationFilterInput
"Bill of materials ID"
billOfMaterialsId: ComparableNullableOfInt32OperationFilterInput
"Parent item ID (for variation children)"
parentItemId: ComparableArtikelKeyOperationFilterInput
"Item id for category search"
itemIdForCategoryItemId: ComparableArtikelKeyOperationFilterInput
"Item number"
sku: StringOperationFilterInput
"Sort number for display ordering"
sortNumber: ComparableInt32OperationFilterInput
"Name of the item in the requested language"
name: StringOperationFilterInput
"Sales unit name"
unit: StringOperationFilterInput
"Item description (first 255 chars)"
description: StringOperationFilterInput
"Short description (first 255 chars)"
shortDescription: StringOperationFilterInput
"Notes of the item"
notes: StringOperationFilterInput
"Label names"
labels: StringOperationFilterInput
"Series name"
series: StringOperationFilterInput
"GTIN (former EAN) of the item"
gtin: StringOperationFilterInput
"Manufacturer number of the item"
manufacturerNumber: StringOperationFilterInput
"ISBN of the item"
isbn: StringOperationFilterInput
"Default ASIN of the item"
defaultAsin: StringOperationFilterInput
"TaricCode of the item"
taricCode: StringOperationFilterInput
"UPC of the item"
upc: StringOperationFilterInput
"UNNumber of the item"
unNumber: StringOperationFilterInput
"HazardNumber of the item"
hazardNumber: StringOperationFilterInput
"Amazon FNSKU"
amazonFnsku: StringOperationFilterInput
"Identifier for JTL Fulfillment Network"
jfsku: StringOperationFilterInput
"Country of origin"
countryOfOrigin: StringOperationFilterInput
"Name of the manufacturer"
manufacturerName: StringOperationFilterInput
"Delivery status name"
deliveryStatus: StringOperationFilterInput
"Automatic delivery time calculation active"
isDeliveryTimeAutomatic: ComparableBooleanOperationFilterInput
"Manual delivery time in days"
manualDeliveryTimeDays: ComparableNullableOfInt32OperationFilterInput
"Item width"
width: ComparableDecimalOperationFilterInput
"Item height"
height: ComparableDecimalOperationFilterInput
"Item length"
length: ComparableDecimalOperationFilterInput
"Shipping weight"
shippingWeight: ComparableDecimalOperationFilterInput
"Item weight (without packaging)"
weight: ComparableDecimalOperationFilterInput
"Creation date of the item"
createdDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Last modification date (date only)"
modifiedDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Last modification timestamp (date and time)"
modifiedTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Release date of the item"
releaseDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date of last purchase"
lastPurchaseDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Name of the last editor"
lastEditor: StringOperationFilterInput
"Item Net Price"
salesPriceNet: ComparableDecimalOperationFilterInput
"Sales price gross (including tax)"
salesPriceGross: ComparableDecimalOperationFilterInput
"UVP"
suggestedRetailPrice: ComparableDecimalOperationFilterInput
"Average purchase price net"
averagePurchasePriceNet: ComparableDecimalOperationFilterInput
"Last Purchase Net Price"
lastPurchasePrice: ComparableDecimalOperationFilterInput
"AmazonPrice Net Price"
amazonPrice: ComparableDecimalOperationFilterInput
"EbayPrice Net Price"
ebayPrice: ComparableDecimalOperationFilterInput
"Profit of this item"
profit: ComparableNullableOfDecimalOperationFilterInput
"Profit in percent"
profitPercent: ComparableDecimalOperationFilterInput
"Special price status (0 = no special price, 1 = expired, 2 = active)"
specialPriceStatus: ComparableInt32OperationFilterInput
"Base price value"
basePriceValue: ComparableNullableOfDecimalOperationFilterInput
"Base price unit display code"
basePriceUnit: StringOperationFilterInput
"Measurement unit name"
measurementUnit: StringOperationFilterInput
"Total stock in all warehouses"
stockTotal: ComparableDecimalOperationFilterInput
"Own Stock (without children\/variations)"
stockOwn: ComparableDecimalOperationFilterInput
"Stock incoming"
stockIncoming: ComparableDecimalOperationFilterInput
"Stock on purchase list"
stockOnPurchaseList: ComparableDecimalOperationFilterInput
"Total stock in orders"
stockInOrders: ComparableDecimalOperationFilterInput
"Available stock"
stockAvailable: ComparableDecimalOperationFilterInput
"Total stock reserved"
stockReservedTotal: ComparableDecimalOperationFilterInput
"Stock in Amazon offers"
stockInAmazonOffers: ComparableInt32OperationFilterInput
"Stock in eBay listings"
ebayStock: ComparableDecimalOperationFilterInput
"Minimum order quantity"
minimumOrderQuantity: ComparableDecimalOperationFilterInput
"Purchase interval"
purchaseInterval: ComparableDecimalOperationFilterInput
"The item buffer"
buffer: ComparableInt32OperationFilterInput
"The Item minimum stock level"
minimumStock: ComparableDecimalOperationFilterInput
"Determines if negative stock is allowed for this item"
allowNegativeStock: ComparableBooleanOperationFilterInput
"Determines if the item is working with inventory management"
isInventoryManagementActive: ComparableBooleanOperationFilterInput
"Determines if the item is working with split quantities in stock"
isDivisible: ComparableBooleanOperationFilterInput
"The Item HasBatch"
hasBatch: ComparableBooleanOperationFilterInput
"Determines if the item is working with best before date (MHD)"
hasBestBeforeDate: ComparableBooleanOperationFilterInput
"If the item uses serial number management."
isSerialNumberManaged: ComparableBooleanOperationFilterInput
"Serial number tracking flag"
serialNumberTrackingMode: ComparableSerialNumberTrackingModeOperationFilterInput
"Indicates if the item is active"
isActive: ComparableBooleanOperationFilterInput
"Is on price list flag"
isOnPriceList: ComparableBooleanOperationFilterInput
"Is top item flag"
isTopItem: ComparableBooleanOperationFilterInput
"Is new item flag"
isNew: ComparableBooleanOperationFilterInput
"Is bill of materials"
isBillOfMaterials: ComparableBooleanOperationFilterInput
"Is bill of materials component"
isBillOfMaterialsComponent: ComparableBooleanOperationFilterInput
"Is variation parent"
isVariationParent: ComparableBooleanOperationFilterInput
"Is variation child"
isVariationChild: ComparableBooleanOperationFilterInput
"Has minimum stock level"
hasMinimumStock: ComparableBooleanOperationFilterInput
"Is blocked for order suggestions"
isBlockedForOrderSuggestions: ComparableBooleanOperationFilterInput
"Is active in at least one shop"
isShopActive: ComparableBooleanOperationFilterInput
"No order process flag"
isOrderProcessProhibited: ComparableBooleanOperationFilterInput
"Sales packaging unit (VPE)"
salesPackagingUnit: ComparableNullableOfByteOperationFilterInput
"Condition ID"
conditionId: ComparableZustandKeyOperationFilterInput
"Condition name"
conditionName: StringOperationFilterInput
"Determines if the item is being shared in the JTL Fulfillment Network"
isFulfillmentActive: ComparableBooleanOperationFilterInput
"Determines if the item is managed by this client"
isFulfillmentOwn: ComparableBooleanOperationFilterInput
"Tax class ID"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Name of the tax class"
taxClassName: StringOperationFilterInput
"Manufacturer ID"
manufacturerId: ComparableHerstellerKeyOperationFilterInput
"Product group ID"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Name of the ProductGroup"
productGroupName: StringOperationFilterInput
"Default supplier ID"
defaultSupplierId: ComparableLieferantKeyOperationFilterInput
"Name of the Default Supplier"
defaultSupplier: StringOperationFilterInput
"Shipping class ID"
shippingClassId: ComparableVersandklasseKeyOperationFilterInput
"Shipping class name"
shippingClassName: StringOperationFilterInput
"The id of the default image."
defaultImageId: ComparableBildKeyOperationFilterInput
"Additional processing time in days"
additionalProcessingTime: ComparableNullableOfInt32OperationFilterInput
"Meta description for SEO (first 255 chars)"
metaDescription: StringOperationFilterInput
"Title tag for SEO (first 255 chars)"
titleTag: StringOperationFilterInput
"Meta keywords for SEO (first 255 chars)"
metaKeywords: StringOperationFilterInput
"Language ID for descriptions"
languageId: ComparableSpracheKeyOperationFilterInput
"Company ID"
companyId: ComparableFirmaKeyOperationFilterInput
}
"Single row of the item overview"
input ItemListItemSortInput {
"Item id"
id: ArtikelKeySortInput @cost(weight: "10")
"Bill of materials ID"
billOfMaterialsId: SortEnumType @cost(weight: "10")
"Parent item ID (for variation children)"
parentItemId: ArtikelKeySortInput @cost(weight: "10")
"Item id for category search"
itemIdForCategoryItemId: ArtikelKeySortInput @cost(weight: "10")
"Item number"
sku: SortEnumType @cost(weight: "10")
"Sort number for display ordering"
sortNumber: SortEnumType @cost(weight: "10")
"Name of the item in the requested language"
name: SortEnumType @cost(weight: "10")
"Sales unit name"
unit: SortEnumType @cost(weight: "10")
"Item description (first 255 chars)"
description: SortEnumType @cost(weight: "10")
"Short description (first 255 chars)"
shortDescription: SortEnumType @cost(weight: "10")
"Notes of the item"
notes: SortEnumType @cost(weight: "10")
"Label names"
labels: SortEnumType @cost(weight: "10")
"Series name"
series: SortEnumType @cost(weight: "10")
"GTIN (former EAN) of the item"
gtin: SortEnumType @cost(weight: "10")
"Manufacturer number of the item"
manufacturerNumber: SortEnumType @cost(weight: "10")
"ISBN of the item"
isbn: SortEnumType @cost(weight: "10")
"Default ASIN of the item"
defaultAsin: SortEnumType @cost(weight: "10")
"TaricCode of the item"
taricCode: SortEnumType @cost(weight: "10")
"UPC of the item"
upc: SortEnumType @cost(weight: "10")
"UNNumber of the item"
unNumber: SortEnumType @cost(weight: "10")
"HazardNumber of the item"
hazardNumber: SortEnumType @cost(weight: "10")
"Amazon FNSKU"
amazonFnsku: SortEnumType @cost(weight: "10")
"Identifier for JTL Fulfillment Network"
jfsku: SortEnumType @cost(weight: "10")
"Country of origin"
countryOfOrigin: SortEnumType @cost(weight: "10")
"Name of the manufacturer"
manufacturerName: SortEnumType @cost(weight: "10")
"Delivery status name"
deliveryStatus: SortEnumType @cost(weight: "10")
"Automatic delivery time calculation active"
isDeliveryTimeAutomatic: SortEnumType @cost(weight: "10")
"Manual delivery time in days"
manualDeliveryTimeDays: SortEnumType @cost(weight: "10")
"Item width"
width: SortEnumType @cost(weight: "10")
"Item height"
height: SortEnumType @cost(weight: "10")
"Item length"
length: SortEnumType @cost(weight: "10")
"Shipping weight"
shippingWeight: SortEnumType @cost(weight: "10")
"Item weight (without packaging)"
weight: SortEnumType @cost(weight: "10")
"Creation date of the item"
createdDate: SortEnumType @cost(weight: "10")
"Last modification date (date only)"
modifiedDate: SortEnumType @cost(weight: "10")
"Last modification timestamp (date and time)"
modifiedTimestamp: SortEnumType @cost(weight: "10")
"Release date of the item"
releaseDate: SortEnumType @cost(weight: "10")
"Date of last purchase"
lastPurchaseDate: SortEnumType @cost(weight: "10")
"Name of the last editor"
lastEditor: SortEnumType @cost(weight: "10")
"Item Net Price"
salesPriceNet: SortEnumType @cost(weight: "10")
"Sales price gross (including tax)"
salesPriceGross: SortEnumType @cost(weight: "10")
"UVP"
suggestedRetailPrice: SortEnumType @cost(weight: "10")
"Average purchase price net"
averagePurchasePriceNet: SortEnumType @cost(weight: "10")
"Last Purchase Net Price"
lastPurchasePrice: SortEnumType @cost(weight: "10")
"AmazonPrice Net Price"
amazonPrice: SortEnumType @cost(weight: "10")
"EbayPrice Net Price"
ebayPrice: SortEnumType @cost(weight: "10")
"Profit of this item"
profit: SortEnumType @cost(weight: "10")
"Profit in percent"
profitPercent: SortEnumType @cost(weight: "10")
"Special price status (0 = no special price, 1 = expired, 2 = active)"
specialPriceStatus: SortEnumType @cost(weight: "10")
"Base price value"
basePriceValue: SortEnumType @cost(weight: "10")
"Base price unit display code"
basePriceUnit: SortEnumType @cost(weight: "10")
"Measurement unit name"
measurementUnit: SortEnumType @cost(weight: "10")
"Total stock in all warehouses"
stockTotal: SortEnumType @cost(weight: "10")
"Own Stock (without children\/variations)"
stockOwn: SortEnumType @cost(weight: "10")
"Stock incoming"
stockIncoming: SortEnumType @cost(weight: "10")
"Stock on purchase list"
stockOnPurchaseList: SortEnumType @cost(weight: "10")
"Total stock in orders"
stockInOrders: SortEnumType @cost(weight: "10")
"Available stock"
stockAvailable: SortEnumType @cost(weight: "10")
"Total stock reserved"
stockReservedTotal: SortEnumType @cost(weight: "10")
"Stock in Amazon offers"
stockInAmazonOffers: SortEnumType @cost(weight: "10")
"Stock in eBay listings"
ebayStock: SortEnumType @cost(weight: "10")
"Minimum order quantity"
minimumOrderQuantity: SortEnumType @cost(weight: "10")
"Purchase interval"
purchaseInterval: SortEnumType @cost(weight: "10")
"The item buffer"
buffer: SortEnumType @cost(weight: "10")
"The Item minimum stock level"
minimumStock: SortEnumType @cost(weight: "10")
"Determines if negative stock is allowed for this item"
allowNegativeStock: SortEnumType @cost(weight: "10")
"Determines if the item is working with inventory management"
isInventoryManagementActive: SortEnumType @cost(weight: "10")
"Determines if the item is working with split quantities in stock"
isDivisible: SortEnumType @cost(weight: "10")
"The Item HasBatch"
hasBatch: SortEnumType @cost(weight: "10")
"Determines if the item is working with best before date (MHD)"
hasBestBeforeDate: SortEnumType @cost(weight: "10")
"If the item uses serial number management."
isSerialNumberManaged: SortEnumType @cost(weight: "10")
"Serial number tracking flag"
serialNumberTrackingMode: SortEnumType @cost(weight: "10")
"Indicates if the item is active"
isActive: SortEnumType @cost(weight: "10")
"Is on price list flag"
isOnPriceList: SortEnumType @cost(weight: "10")
"Is top item flag"
isTopItem: SortEnumType @cost(weight: "10")
"Is new item flag"
isNew: SortEnumType @cost(weight: "10")
"Is bill of materials"
isBillOfMaterials: SortEnumType @cost(weight: "10")
"Is bill of materials component"
isBillOfMaterialsComponent: SortEnumType @cost(weight: "10")
"Is variation parent"
isVariationParent: SortEnumType @cost(weight: "10")
"Is variation child"
isVariationChild: SortEnumType @cost(weight: "10")
"Has minimum stock level"
hasMinimumStock: SortEnumType @cost(weight: "10")
"Is blocked for order suggestions"
isBlockedForOrderSuggestions: SortEnumType @cost(weight: "10")
"Is active in at least one shop"
isShopActive: SortEnumType @cost(weight: "10")
"No order process flag"
isOrderProcessProhibited: SortEnumType @cost(weight: "10")
"Sales packaging unit (VPE)"
salesPackagingUnit: SortEnumType @cost(weight: "10")
"Condition ID"
conditionId: ZustandKeySortInput @cost(weight: "10")
"Condition name"
conditionName: SortEnumType @cost(weight: "10")
"Determines if the item is being shared in the JTL Fulfillment Network"
isFulfillmentActive: SortEnumType @cost(weight: "10")
"Determines if the item is managed by this client"
isFulfillmentOwn: SortEnumType @cost(weight: "10")
"Tax class ID"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Name of the tax class"
taxClassName: SortEnumType @cost(weight: "10")
"Manufacturer ID"
manufacturerId: HerstellerKeySortInput @cost(weight: "10")
"Product group ID"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Name of the ProductGroup"
productGroupName: SortEnumType @cost(weight: "10")
"Default supplier ID"
defaultSupplierId: LieferantKeySortInput @cost(weight: "10")
"Name of the Default Supplier"
defaultSupplier: SortEnumType @cost(weight: "10")
"Shipping class ID"
shippingClassId: VersandklasseKeySortInput @cost(weight: "10")
"Shipping class name"
shippingClassName: SortEnumType @cost(weight: "10")
"The id of the default image."
defaultImageId: BildKeySortInput @cost(weight: "10")
"Additional processing time in days"
additionalProcessingTime: SortEnumType @cost(weight: "10")
"Meta description for SEO (first 255 chars)"
metaDescription: SortEnumType @cost(weight: "10")
"Title tag for SEO (first 255 chars)"
titleTag: SortEnumType @cost(weight: "10")
"Meta keywords for SEO (first 255 chars)"
metaKeywords: SortEnumType @cost(weight: "10")
"Language ID for descriptions"
languageId: SpracheKeySortInput @cost(weight: "10")
"Company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
}
"Model Class: ItemSupplierListItem"
input ItemSupplierListItemFilterInput {
and: [ItemSupplierListItemFilterInput!]
or: [ItemSupplierListItemFilterInput!]
"Id of the item supplier"
id: ComparableLieferantenArtikelKeyOperationFilterInput
"Id of the item"
itemId: ComparableArtikelKeyOperationFilterInput
"Id of the supplier"
supplierId: ComparableLieferantKeyOperationFilterInput
"Name of the supplier"
supplierName: StringOperationFilterInput
"Currency used by the supplier"
supplierCurrency: StringOperationFilterInput
"Indicates if the supplier supports dropshipping."
isDropshippingSupported: ComparableBooleanOperationFilterInput
"The delivery time of the supplier."
supplierDeliveryTimeInDays: ComparableNullableOfInt32OperationFilterInput
"Name of the item at the supplier (max 255 characters)."
supplierItemName: StringOperationFilterInput
"Item number at the supplier (max 255 characters)."
supplierItemNumber: StringOperationFilterInput
"Delivery period as text (max 255 characters)."
deliveryPeriod: StringOperationFilterInput
"Stock level of the item at the supplier."
stockLevel: ComparableDecimalOperationFilterInput
"Average delivery time based on historical data."
averageDeliveryTime: ComparableDecimalOperationFilterInput
"Date when the stock level was last updated."
stockLevelLastModified: ComparableNullableOfDateTimeOperationFilterInput
"Net purchase price of the item at the supplier."
netPurchasePrice: ComparableDecimalOperationFilterInput
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: ComparableNullableOfInt32OperationFilterInput
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: ComparableNullableOfInt32OperationFilterInput
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: ComparableBooleanOperationFilterInput
"Indicates if this supplier is the default supplier for the item."
isDefaultSupplier: ComparableBooleanOperationFilterInput
"Indicates if this supplier is the default dropshipping supplier for the item."
isDefaultDropshippingSupplier: ComparableBooleanOperationFilterInput
"Description of the packaging unit."
packageUnitDescription: StringOperationFilterInput
"Quantity per packaging unit."
packageUnitQuantity: ComparableNullableOfDecimalOperationFilterInput
"Additional notes (max 512 characters)."
notes: StringOperationFilterInput
"VAT rate of the item at the supplier."
vatRate: ComparableDecimalOperationFilterInput
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: ComparableBooleanOperationFilterInput
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: ComparableBooleanOperationFilterInput
"Purchase interval for this item at the supplier."
purchaseInterval: ComparableDecimalOperationFilterInput
}
"Model Class: ItemSupplierListItem"
input ItemSupplierListItemSortInput {
"Id of the item supplier"
id: LieferantenArtikelKeySortInput @cost(weight: "10")
"Id of the item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Id of the supplier"
supplierId: LieferantKeySortInput @cost(weight: "10")
"Name of the supplier"
supplierName: SortEnumType @cost(weight: "10")
"Currency used by the supplier"
supplierCurrency: SortEnumType @cost(weight: "10")
"Indicates if the supplier supports dropshipping."
isDropshippingSupported: SortEnumType @cost(weight: "10")
"The delivery time of the supplier."
supplierDeliveryTimeInDays: SortEnumType @cost(weight: "10")
"Name of the item at the supplier (max 255 characters)."
supplierItemName: SortEnumType @cost(weight: "10")
"Item number at the supplier (max 255 characters)."
supplierItemNumber: SortEnumType @cost(weight: "10")
"Delivery period as text (max 255 characters)."
deliveryPeriod: SortEnumType @cost(weight: "10")
"Stock level of the item at the supplier."
stockLevel: SortEnumType @cost(weight: "10")
"Average delivery time based on historical data."
averageDeliveryTime: SortEnumType @cost(weight: "10")
"Date when the stock level was last updated."
stockLevelLastModified: SortEnumType @cost(weight: "10")
"Net purchase price of the item at the supplier."
netPurchasePrice: SortEnumType @cost(weight: "10")
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: SortEnumType @cost(weight: "10")
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: SortEnumType @cost(weight: "10")
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: SortEnumType @cost(weight: "10")
"Indicates if this supplier is the default supplier for the item."
isDefaultSupplier: SortEnumType @cost(weight: "10")
"Indicates if this supplier is the default dropshipping supplier for the item."
isDefaultDropshippingSupplier: SortEnumType @cost(weight: "10")
"Description of the packaging unit."
packageUnitDescription: SortEnumType @cost(weight: "10")
"Quantity per packaging unit."
packageUnitQuantity: SortEnumType @cost(weight: "10")
"Additional notes (max 512 characters)."
notes: SortEnumType @cost(weight: "10")
"VAT rate of the item at the supplier."
vatRate: SortEnumType @cost(weight: "10")
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: SortEnumType @cost(weight: "10")
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: SortEnumType @cost(weight: "10")
"Purchase interval for this item at the supplier."
purchaseInterval: SortEnumType @cost(weight: "10")
}
"Single row of the item type information"
input ItemTypeListItemFilterInput {
and: [ItemTypeListItemFilterInput!]
or: [ItemTypeListItemFilterInput!]
"Item id"
id: ComparableArtikelKeyOperationFilterInput
"Indicates whether the item is managed as a stock item."
isStockItem: ComparableBooleanOperationFilterInput
"Indicates whether the item currently has a positive stock quantity."
hasStock: ComparableBooleanOperationFilterInput
"Indicates whether the item requires serial number tracking."
isSerialNumberItem: ComparableBooleanOperationFilterInput
"Indicates whether the item can be divided into partial quantities."
isDivisibleStock: ComparableBooleanOperationFilterInput
"Indicates whether the item has an expiration or best-before date (MHD)."
stockHasExpirationDate: ComparableBooleanOperationFilterInput
"Indicates whether the item is managed as a batch or lot item."
stockIsBatch: ComparableBooleanOperationFilterInput
"Indicates whether the item is a bill of materials (BOM \/ Stückliste)."
isBillOfMaterials: ComparableBooleanOperationFilterInput
"Indicates whether the item is used as a component within a bill of materials."
isBillOfMaterialsComponent: ComparableBooleanOperationFilterInput
"Indicates whether the item is a parent of a variation combination."
isVariationCombinationParent: ComparableBooleanOperationFilterInput
"Indicates whether the item is a child (variant) of a variation combination."
isVariationCombinationChild: ComparableBooleanOperationFilterInput
"Indicates whether the item has variations defined."
hasVariations: ComparableBooleanOperationFilterInput
"Indicates whether the item represents a voucher."
isVoucher: ComparableBooleanOperationFilterInput
"Indicates whether the item is a packaging item."
isPackaging: ComparableBooleanOperationFilterInput
"Indicates whether the item has a configuration attached."
hasConfigurationGroup: ComparableBooleanOperationFilterInput
"Indicates whether the item is a configuration component."
isConfigurationComponent: ComparableBooleanOperationFilterInput
}
"Single row of the item type information"
input ItemTypeListItemSortInput {
"Item id"
id: ArtikelKeySortInput @cost(weight: "10")
"Indicates whether the item is managed as a stock item."
isStockItem: SortEnumType @cost(weight: "10")
"Indicates whether the item currently has a positive stock quantity."
hasStock: SortEnumType @cost(weight: "10")
"Indicates whether the item requires serial number tracking."
isSerialNumberItem: SortEnumType @cost(weight: "10")
"Indicates whether the item can be divided into partial quantities."
isDivisibleStock: SortEnumType @cost(weight: "10")
"Indicates whether the item has an expiration or best-before date (MHD)."
stockHasExpirationDate: SortEnumType @cost(weight: "10")
"Indicates whether the item is managed as a batch or lot item."
stockIsBatch: SortEnumType @cost(weight: "10")
"Indicates whether the item is a bill of materials (BOM \/ Stückliste)."
isBillOfMaterials: SortEnumType @cost(weight: "10")
"Indicates whether the item is used as a component within a bill of materials."
isBillOfMaterialsComponent: SortEnumType @cost(weight: "10")
"Indicates whether the item is a parent of a variation combination."
isVariationCombinationParent: SortEnumType @cost(weight: "10")
"Indicates whether the item is a child (variant) of a variation combination."
isVariationCombinationChild: SortEnumType @cost(weight: "10")
"Indicates whether the item has variations defined."
hasVariations: SortEnumType @cost(weight: "10")
"Indicates whether the item represents a voucher."
isVoucher: SortEnumType @cost(weight: "10")
"Indicates whether the item is a packaging item."
isPackaging: SortEnumType @cost(weight: "10")
"Indicates whether the item has a configuration attached."
hasConfigurationGroup: SortEnumType @cost(weight: "10")
"Indicates whether the item is a configuration component."
isConfigurationComponent: SortEnumType @cost(weight: "10")
}
input KategorieKeySortInput {
kKategorie: SortEnumType @cost(weight: "10")
}
"Represents a unique key for identifying a customer in the JTL system."
input KundeKeySortInput {
"Gets the unique identifier for the customer."
kKunde: SortEnumType @cost(weight: "10")
"Gets a value indicating whether the customer key represents an existing customer."
isExisting: SortEnumType @cost(weight: "10")
}
input KundenGruppeKeySortInput {
kKundenGruppe: SortEnumType @cost(weight: "10")
}
input KundenKategorieKeySortInput {
kKundenKategorie: SortEnumType @cost(weight: "10")
}
"Represents a language item in the system"
input LanguageItemFilterInput {
and: [LanguageItemFilterInput!]
or: [LanguageItemFilterInput!]
"The two-letter ISO code of the language"
languageIso2: StringOperationFilterInput
"The name of the language in the Accept-Language header"
name: StringOperationFilterInput
"The culture ISO code of the language"
cultureIso: StringOperationFilterInput
"The three-letter ISO code of the language"
languageIso3: StringOperationFilterInput
}
"Represents a language item in the system"
input LanguageItemSortInput {
"The two-letter ISO code of the language"
languageIso2: SortEnumType @cost(weight: "10")
"The name of the language in the Accept-Language header"
name: SortEnumType @cost(weight: "10")
"The culture ISO code of the language"
cultureIso: SortEnumType @cost(weight: "10")
"The three-letter ISO code of the language"
languageIso3: SortEnumType @cost(weight: "10")
}
input LhmKeySortInput {
kLhm: SortEnumType @cost(weight: "10")
}
"Represents a unique key for identifying a lhm type in the JTL system."
input LhmTypeKeySortInput {
"Gets the unique identifier for the lhm type."
kLHMTyp: SortEnumType @cost(weight: "10")
}
input LieferantKeySortInput {
kLieferant: SortEnumType @cost(weight: "10")
}
"LieferArtikel Schlüssel"
input LieferantenArtikelKeySortInput {
"Der Interne Named Key"
kLiefArtikel: SortEnumType @cost(weight: "10")
}
"Locks a bin location, preventing stock movements. - Request"
input LockBinLocationCommandRequestInput {
"Unique identifier of the bin location to lock."
binLocationId: ID!
}
"Locks a bin location for available stock, preventing it from being used for stock allocation. - Request"
input LockBinLocationForAvailableStockCommandRequestInput {
"Unique identifier of the bin location to lock for available stock."
binLocationId: ID!
}
"A lot size for a production item. It defines the quantity of a production item that is produced in one lot."
input LotSizeFilterInput {
and: [LotSizeFilterInput!]
or: [LotSizeFilterInput!]
"The ID of this lot size."
id: ComparableLotSizeKeyOperationFilterInput
"The ID of the production item of this lot size."
productionItemId: ComparableProdItemKeyOperationFilterInput
"The quantity of the production item that is produced in one lot."
quantity: ComparableInt32OperationFilterInput
}
input LotSizeKeySortInput {
kLotSize: SortEnumType @cost(weight: "10")
}
"A lot size for a production item. It defines the quantity of a production item that is produced in one lot."
input LotSizeSortInput {
"The ID of this lot size."
id: LotSizeKeySortInput @cost(weight: "10")
"The ID of the production item of this lot size."
productionItemId: ProdItemKeySortInput @cost(weight: "10")
"The quantity of the production item that is produced in one lot."
quantity: SortEnumType @cost(weight: "10")
}
"Single Row of the manufacturer overview"
input ManufacturerListItemFilterInput {
and: [ManufacturerListItemFilterInput!]
or: [ManufacturerListItemFilterInput!]
"Id of the manufacturer."
id: ComparableHerstellerKeyOperationFilterInput
"Default manufacturer Name"
name: StringOperationFilterInput
}
"Single Row of the manufacturer overview"
input ManufacturerListItemSortInput {
"Id of the manufacturer."
id: HerstellerKeySortInput @cost(weight: "10")
"Sortnumber of the manufacturer."
sortNumber: SortEnumType @cost(weight: "10")
"Default manufacturer Name"
name: SortEnumType @cost(weight: "10")
}
"Marks a given sales order as completely paid by creating a payment with the open amount of the sales order. - Request"
input MarkSalesOrderAsPaidCommandRequestInput {
"Unique ID of the sales order to be marked as paid."
id: ID!
"Date when the payment was made. If not provided, the current date and time will be used."
paymentDate: DateTime
"ID of the payment method to be used for the payment. If not provided, the default payment method will be used."
paymentMethodId: ID
"Whether to distribute the payment to associated invoices. If not provided, it will default to true."
distribute: Boolean
"Comment for the payment. If not provided, no comment will be added to the payment."
comment: String
"Whether to send a confirmation email after payment processing. If not provided, it will default to false."
sendMail: Boolean
}
"Single row of the external document overview list."
input MarketplaceExternalDocumentListItemFilterInput {
and: [MarketplaceExternalDocumentListItemFilterInput!]
or: [MarketplaceExternalDocumentListItemFilterInput!]
"Type of the external document."
documentType: ComparableMarketplaceExternalDocumentTypeOperationFilterInput
"Name of the shop."
shopName: StringOperationFilterInput
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Document number."
documentNumber: StringOperationFilterInput
"Invoice date."
invoiceDate: ComparableNullableOfDateTimeOperationFilterInput
}
"Single row of the external document overview list."
input MarketplaceExternalDocumentListItemSortInput {
"Type of the external document."
documentType: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Invoice date."
invoiceDate: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Gross total amount."
grossTotal: SortEnumType @cost(weight: "10")
"Document number."
documentNumber: SortEnumType @cost(weight: "10")
"Currency code."
currency: SortEnumType @cost(weight: "10")
}
"Single row of the invoice correction PDF upload overview list."
input MarketplaceInvoiceCorrectionPdfUploadListItemFilterInput {
and: [MarketplaceInvoiceCorrectionPdfUploadListItemFilterInput!]
or: [MarketplaceInvoiceCorrectionPdfUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Overall queue status."
status: ComparableMarketplaceUploadQueueStatusOperationFilterInput
"Print status of the invoice correction PDF."
printStatus: ComparableMarketplaceInvoicePdfPrintStatusOperationFilterInput
"Upload status of the invoice correction PDF."
uploadStatus: ComparableMarketplaceInvoicePdfUploadStatusOperationFilterInput
"UTC timestamp when the queue entry was created."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
"Invoice correction number."
invoiceCorrectionNumber: StringOperationFilterInput
}
"Single row of the invoice correction PDF upload overview list."
input MarketplaceInvoiceCorrectionPdfUploadListItemSortInput {
"Overall queue status."
status: SortEnumType @cost(weight: "10")
"Print status of the invoice correction PDF."
printStatus: SortEnumType @cost(weight: "10")
"Upload status of the invoice correction PDF."
uploadStatus: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"UTC timestamp when the queue entry was created."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Invoice correction number."
invoiceCorrectionNumber: SortEnumType @cost(weight: "10")
"Invoice correction creation timestamp."
invoiceCorrectionCreatedAt: SortEnumType @cost(weight: "10")
}
"Single row of the invoice correction upload line item overview list."
input MarketplaceInvoiceCorrectionUploadLineItemListItemSortInput {
"Quantity of the line item."
quantity: SortEnumType @cost(weight: "10")
"Article number."
articleNumber: SortEnumType @cost(weight: "10")
"Article name."
articleName: SortEnumType @cost(weight: "10")
"Amount."
amount: SortEnumType @cost(weight: "10")
"Currency."
currency: SortEnumType @cost(weight: "10")
}
"Single row of the invoice correction upload overview list."
input MarketplaceInvoiceCorrectionUploadListItemFilterInput {
and: [MarketplaceInvoiceCorrectionUploadListItemFilterInput!]
or: [MarketplaceInvoiceCorrectionUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the invoice correction upload."
status: ComparableMarketplaceInvoiceCorrectionUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableNullableOfDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single row of the invoice correction upload overview list."
input MarketplaceInvoiceCorrectionUploadListItemSortInput {
"Status of the invoice correction upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Number of refund upload attempts."
refundUploadCount: SortEnumType @cost(weight: "10")
"Invoice correction number."
invoiceCorrectionNumber: SortEnumType @cost(weight: "10")
}
"Single row of the invoice PDF upload overview list."
input MarketplaceInvoicePdfUploadListItemFilterInput {
and: [MarketplaceInvoicePdfUploadListItemFilterInput!]
or: [MarketplaceInvoicePdfUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Overall queue status."
status: ComparableMarketplaceUploadQueueStatusOperationFilterInput
"Print status of the invoice PDF."
printStatus: ComparableMarketplaceInvoicePdfPrintStatusOperationFilterInput
"Upload status of the invoice PDF."
uploadStatus: ComparableMarketplaceInvoicePdfUploadStatusOperationFilterInput
"UTC timestamp when the queue entry was created."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
"Invoice number."
invoiceNumber: StringOperationFilterInput
}
"Single row of the invoice PDF upload overview list."
input MarketplaceInvoicePdfUploadListItemSortInput {
"Overall queue status."
status: SortEnumType @cost(weight: "10")
"Print status of the invoice PDF."
printStatus: SortEnumType @cost(weight: "10")
"Upload status of the invoice PDF."
uploadStatus: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"UTC timestamp when the queue entry was created."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Invoice number."
invoiceNumber: SortEnumType @cost(weight: "10")
"Invoice creation timestamp."
invoiceCreatedAt: SortEnumType @cost(weight: "10")
}
"Single row of the notification detail overview list."
input MarketplaceNotificationDetailListItemSortInput {
"Detail code of the notification."
code: SortEnumType @cost(weight: "10")
"Detailed message of the notification."
message: SortEnumType @cost(weight: "10")
}
"Single Row of the notification overview list."
input MarketplaceNotificationListItemFilterInput {
and: [MarketplaceNotificationListItemFilterInput!]
or: [MarketplaceNotificationListItemFilterInput!]
"Severity level of the notification."
severity: ComparableMarketplaceNotificationSeverityOperationFilterInput
"Type of the notification."
notificationType: ComparableMarketplaceNotificationTypeOperationFilterInput
"Whether the notification has been read."
isRead: ComparableBooleanOperationFilterInput
"Optional display name of the shop."
shopName: StringOperationFilterInput
"Optional title of the associated offer."
offerTitle: StringOperationFilterInput
}
"Single Row of the notification overview list."
input MarketplaceNotificationListItemSortInput {
"Creation timestamp."
creationDate: SortEnumType @cost(weight: "10")
"Severity level of the notification."
severity: SortEnumType @cost(weight: "10")
"Type of the notification."
notificationType: SortEnumType @cost(weight: "10")
"Name of the marketplace channel."
channel: SortEnumType @cost(weight: "10")
"Optional display name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Whether the notification has been read."
isRead: SortEnumType @cost(weight: "10")
"Event identifier that triggered this notification."
eventId: SortEnumType @cost(weight: "10")
"Optional short message summarizing the notification."
shortMessage: SortEnumType @cost(weight: "10")
}
"Single row of the offer failure list."
input MarketplaceOfferFailureListItemSortInput {
"Creation timestamp (UTC)."
createdAt: SortEnumType @cost(weight: "10")
"Error code."
code: SortEnumType @cost(weight: "10")
"Short error message."
message: SortEnumType @cost(weight: "10")
}
"Single row of the marketplace offer overview list."
input MarketplaceOfferListItemFilterInput {
and: [MarketplaceOfferListItemFilterInput!]
or: [MarketplaceOfferListItemFilterInput!]
"Combined lifecycle and action status of the offer."
offerStatus: ComparableMarketplaceOfferViewStatusOperationFilterInput
"Type of the offer."
offerType: ComparableMarketplaceOfferTypeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
"ID of the seller."
shopScxId: ComparableScxShopKeyOperationFilterInput
"ID of the channel."
channelId: ComparableScxChannelKeyOperationFilterInput
"Whether the offer is currently listed."
isListed: ComparableBooleanOperationFilterInput
"Whether the offer is external."
isExtern: ComparableBooleanOperationFilterInput
"Stock keeping unit."
sku: StringOperationFilterInput
"Product number of the article."
productNumber: StringOperationFilterInput
"Title of the offer."
offerTitle: StringOperationFilterInput
"Display name of the sales channel."
channelName: StringOperationFilterInput
"Name of the shop."
shopName: StringOperationFilterInput
"Whether automatic stock updates are enabled for this seller."
stockUpdateEnabled: ComparableBooleanOperationFilterInput
}
"Single row of the marketplace offer overview list."
input MarketplaceOfferListItemSortInput {
"Title of the offer."
offerTitle: SortEnumType @cost(weight: "10")
"Combined lifecycle and action status of the offer."
offerStatus: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
channelName: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Stock keeping unit."
sku: SortEnumType @cost(weight: "10")
"Product number of the article."
productNumber: SortEnumType @cost(weight: "10")
"Current quantity."
quantity: SortEnumType @cost(weight: "10")
"Net price of the offer."
netPrice: SortEnumType @cost(weight: "10")
"Timestamp since the offer is active."
activeSince: SortEnumType @cost(weight: "10")
"Timestamp of the last upload."
lastUpload: SortEnumType @cost(weight: "10")
"Whether the offer is currently listed."
isListed: SortEnumType @cost(weight: "10")
}
"Single row of the order cancellation request upload overview list."
input MarketplaceOrderCancellationRequestUploadListItemFilterInput {
and: [MarketplaceOrderCancellationRequestUploadListItemFilterInput!]
or: [MarketplaceOrderCancellationRequestUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the cancellation request upload."
status: ComparableMarketplaceOrderCancellationRequestUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single row of the order cancellation request upload overview list."
input MarketplaceOrderCancellationRequestUploadListItemSortInput {
"Status of the cancellation request upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
}
"Single Row of the order cancellation upload overview list."
input MarketplaceOrderCancellationUploadListItemFilterInput {
and: [MarketplaceOrderCancellationUploadListItemFilterInput!]
or: [MarketplaceOrderCancellationUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the cancellation upload."
status: ComparableMarketplaceOrderCancellationUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single Row of the order cancellation upload overview list."
input MarketplaceOrderCancellationUploadListItemSortInput {
"Status of the cancellation upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
}
"Single Row of the payment upload overview list."
input MarketplacePaymentUploadListItemFilterInput {
and: [MarketplacePaymentUploadListItemFilterInput!]
or: [MarketplacePaymentUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the payment upload."
status: ComparableMarketplacePaymentUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single Row of the payment upload overview list."
input MarketplacePaymentUploadListItemSortInput {
"Status of the payment upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Number of payment upload attempts."
paymentUploadCount: SortEnumType @cost(weight: "10")
}
"Single row of the return upload line item overview list."
input MarketplaceReturnUploadLineItemListItemSortInput {
"Quantity of the return line item."
quantity: SortEnumType @cost(weight: "10")
"SKU of the item."
sku: SortEnumType @cost(weight: "10")
"Name of the return line item."
name: SortEnumType @cost(weight: "10")
}
"Single Row of the return upload overview list."
input MarketplaceReturnUploadListItemFilterInput {
and: [MarketplaceReturnUploadListItemFilterInput!]
or: [MarketplaceReturnUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Return number."
returnNumber: StringOperationFilterInput
"Status of the return upload."
status: ComparableMarketplaceReturnUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single Row of the return upload overview list."
input MarketplaceReturnUploadListItemSortInput {
"Status of the return upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Number of return upload attempts."
returnUploadCount: SortEnumType @cost(weight: "10")
}
"Flat read model of a marketplace seller from SCX.lvSeller."
input MarketplaceSellerListItemFilterInput {
and: [MarketplaceSellerListItemFilterInput!]
or: [MarketplaceSellerListItemFilterInput!]
"ID of the SCX shop assignment."
scxShopId: ComparableScxShopKeyOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
"ID of the channel."
channelId: ComparableScxChannelKeyOperationFilterInput
"Name of the shop."
name: StringOperationFilterInput
"Shop is active."
isActive: ComparableBooleanOperationFilterInput
"Seller identifier on the marketplace channel."
sellerId: StringOperationFilterInput
"Channel code."
channel: StringOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"Last update timestamp."
updatedAt: ComparableNullableOfDateTimeOperationFilterInput
"Display name of the channel."
channelDisplayName: StringOperationFilterInput
"SCX shop assignment is marked as deleted."
isDeleted: ComparableBooleanOperationFilterInput
}
"Flat read model of a marketplace seller from SCX.lvSeller."
input MarketplaceSellerListItemSortInput {
"ID of the SCX shop assignment."
scxShopId: ScxShopKeySortInput @cost(weight: "10")
"ID of the shop."
shopId: ShopKeySortInput @cost(weight: "10")
"ID of the channel."
channelId: ScxChannelKeySortInput @cost(weight: "10")
"Name of the shop."
name: SortEnumType @cost(weight: "10")
"Shop is active."
isActive: SortEnumType @cost(weight: "10")
"Seller identifier on the marketplace channel."
sellerId: SortEnumType @cost(weight: "10")
"Channel code."
channel: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Last update timestamp."
updatedAt: SortEnumType @cost(weight: "10")
"Display name of the channel."
channelDisplayName: SortEnumType @cost(weight: "10")
"SCX shop assignment is marked as deleted."
isDeleted: SortEnumType @cost(weight: "10")
}
"Single row of the shipping information upload overview list."
input MarketplaceShippingInformationUploadListItemFilterInput {
and: [MarketplaceShippingInformationUploadListItemFilterInput!]
or: [MarketplaceShippingInformationUploadListItemFilterInput!]
"External sales order number."
externalSalesOrderNumber: StringOperationFilterInput
"Sales order number."
salesOrderNumber: StringOperationFilterInput
"Status of the shipping information upload."
status: ComparableMarketplaceShippingInformationUploadStatusOperationFilterInput
"Creation timestamp."
createdAt: ComparableDateTimeOperationFilterInput
"ID of the shop."
shopId: ComparableShopKeyOperationFilterInput
}
"Single row of the shipping information upload overview list."
input MarketplaceShippingInformationUploadListItemSortInput {
"Status of the shipping information upload."
status: SortEnumType @cost(weight: "10")
"Display name of the sales channel."
salesChannelDisplayName: SortEnumType @cost(weight: "10")
"Creation timestamp."
createdAt: SortEnumType @cost(weight: "10")
"Name of the shop."
shopName: SortEnumType @cost(weight: "10")
"Sales order number."
salesOrderNumber: SortEnumType @cost(weight: "10")
"External sales order number."
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Upload attempt count."
uploadCount: SortEnumType @cost(weight: "10")
}
"Single row of the payment methods overview table"
input PaymentMethodFilterInput {
and: [PaymentMethodFilterInput!]
or: [PaymentMethodFilterInput!]
"Unique identifier of the payment method"
id: ComparableZahlungsartKeyOperationFilterInput
"Name of the payment method"
name: StringOperationFilterInput
"G\/L account associated with the payment method"
generalLedgerAccount: StringOperationFilterInput
"Indicates whether the payment method is active"
isActive: ComparableBooleanOperationFilterInput
"Indicates whether this is the default payment method"
isDefault: ComparableBooleanOperationFilterInput
"Indicates whether the payment method is a debit type"
isDebit: ComparableBooleanOperationFilterInput
"Indicates whether dunning is active for this payment method"
isDunningActive: ComparableBooleanOperationFilterInput
"Indicates whether shipping is allowed before payment is received"
canShipBeforePayment: ComparableBooleanOperationFilterInput
"Number of days for cash discount"
cashDiscountDays: ComparableNullableOfInt32OperationFilterInput
"Value of the cash discount"
cashDiscountValue: ComparableNullableOfDecimalOperationFilterInput
"Payment option associated with the payment method"
paymentOption: StringOperationFilterInput
}
"Single row of the payment methods overview table"
input PaymentMethodSortInput {
"Unique identifier of the payment method"
id: ZahlungsartKeySortInput @cost(weight: "10")
"Name of the payment method"
name: SortEnumType @cost(weight: "10")
"G\/L account associated with the payment method"
generalLedgerAccount: SortEnumType @cost(weight: "10")
"Indicates whether the payment method is active"
isActive: SortEnumType @cost(weight: "10")
"Indicates whether this is the default payment method"
isDefault: SortEnumType @cost(weight: "10")
"Indicates whether the payment method is a debit type"
isDebit: SortEnumType @cost(weight: "10")
"Indicates whether dunning is active for this payment method"
isDunningActive: SortEnumType @cost(weight: "10")
"Indicates whether shipping is allowed before payment is received"
canShipBeforePayment: SortEnumType @cost(weight: "10")
"Number of days for cash discount"
cashDiscountDays: SortEnumType @cost(weight: "10")
"Value of the cash discount"
cashDiscountValue: SortEnumType @cost(weight: "10")
"Payment option associated with the payment method"
paymentOption: SortEnumType @cost(weight: "10")
}
"A pick list with its positions"
input PickListFilterInput {
and: [PickListFilterInput!]
or: [PickListFilterInput!]
"Id of the Warehouse"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Pick list status value"
status: ComparableInt32OperationFilterInput
"Pick list number"
pickListNumber: StringOperationFilterInput
}
"A pick list with its positions"
input PickListSortInput {
"Pick list number"
pickListNumber: SortEnumType @cost(weight: "10")
"Pick list status value"
status: SortEnumType @cost(weight: "10")
}
input PlattformKeySortInput {
kPlattform: SortEnumType @cost(weight: "10")
}
"Physically print the stored PDF files of marketplace external documents using the configured PDF print template set. - Request"
input PrintMarketplaceExternalDocumentCommandRequestInput {
"Document file ids of the external documents whose PDF files should be printed."
documentFileIds: [ID]!
}
"Der Schlüssel eines Produktionsartikels."
input ProdItemKeySortInput {
"Der eindeutige Bezeichner eines Produktionsartikels."
kArtikel: SortEnumType @cost(weight: "10")
}
"Single row of product group information."
input ProductGroupsListItemFilterInput {
and: [ProductGroupsListItemFilterInput!]
or: [ProductGroupsListItemFilterInput!]
"Product group id"
id: ComparableWarengruppeKeyOperationFilterInput
"The name of the product group"
name: StringOperationFilterInput
}
"Single row of product group information."
input ProductGroupsListItemSortInput {
"Product group id"
id: WarengruppeKeySortInput @cost(weight: "10")
"The name of the product group"
name: SortEnumType @cost(weight: "10")
}
"A production item."
input ProductionItemFilterInput {
and: [ProductionItemFilterInput!]
or: [ProductionItemFilterInput!]
"The ID of this production item."
id: ComparableProdItemKeyOperationFilterInput
"The ID of the item underlying this production item."
itemId: ComparableArtikelKeyOperationFilterInput
"Defines the type of lot size configuration for this production item."
lotType: ComparableLotTypeOperationFilterInput
"Defines the type of manufacturing of this production item."
productionType: ComparableProductionTypeOperationFilterInput
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateKey: ComparableVorlagenSetKeyOperationFilterInput
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no item label for each produced unit should be printed on completion."
singleItemLabelTemplateKey: ComparableVorlagenSetKeyOperationFilterInput
"The timestamp when this production item was created."
createDate: ComparableDateTimeOffsetOperationFilterInput
"The timestamp when this production item was last modified."
updateDate: ComparableDateTimeOffsetOperationFilterInput
"The ID of the user who last modified this production item, or NULL if this production item has not been modified yet."
updateUserId: ComparableBenutzerKeyOperationFilterInput
}
"A production item."
input ProductionItemSortInput {
"The ID of this production item."
id: ProdItemKeySortInput @cost(weight: "10")
"The ID of the item underlying this production item."
itemId: ArtikelKeySortInput @cost(weight: "10")
"Defines the type of lot size configuration for this production item."
lotType: SortEnumType @cost(weight: "10")
"Defines the type of manufacturing of this production item."
productionType: SortEnumType @cost(weight: "10")
"The ID of a template to be used for printing an item label when a lot is completed, or NULL if no item label should be printed on completion."
lotLabelTemplateKey: VorlagenSetKeySortInput @cost(weight: "10")
"The ID of a template to be used for printing an item label for each produced unit when a lot is completed, or NULL if no item label for each produced unit should be printed on completion."
singleItemLabelTemplateKey: VorlagenSetKeySortInput @cost(weight: "10")
"The timestamp when this production item was created."
createDate: SortEnumType @cost(weight: "10")
"The timestamp when this production item was last modified."
updateDate: SortEnumType @cost(weight: "10")
"The ID of the user who last modified this production item, or NULL if this production item has not been modified yet."
updateUserId: BenutzerKeySortInput @cost(weight: "10")
}
"A production order."
input ProductionOrderFilterInput {
and: [ProductionOrderFilterInput!]
or: [ProductionOrderFilterInput!]
"The ID of the production order."
id: ComparableProductionOrderKeyOperationFilterInput
"The ID of the production item to be produced by this production order."
productionItemId: ComparableProdItemKeyOperationFilterInput
"The ID of the bill of material used to produce the production item."
billOfMaterialId: ComparableBillOfMaterialKeyOperationFilterInput
"The ID of the disposition from which the production order originates."
dispositionId: ComparableDispositionKeyOperationFilterInput
"Planned number of lots to be produced."
lotCount: ComparableInt32OperationFilterInput
"Planned size of the lots to be produced."
lotSize: ComparableDecimalOperationFilterInput
"Planned total quantity to be produced."
targetTotalQuantity: ComparableDecimalOperationFilterInput
"Actual total quantity produced."
actualQuantity: ComparableDecimalOperationFilterInput
"Indicates whether it is allowed for this order to have a total quantity below the lot size (true) or not (false)."
isTargetTotalQuantityBelowLotSizeAllowed: ComparableBooleanOperationFilterInput
"Progress of the production order."
progress: ComparableDecimalOperationFilterInput
"Planned start time of the production order."
targetStartTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Planned completion time of the production order."
targetCompletionTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Actual (reported) start time of the production order."
actualStartTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Actual (reported) completion time of the production order."
actualCompletionTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The project number associated with the production order."
projectNumber: StringOperationFilterInput
"The reference number associated with the underlying order for this production order."
referenceNumber: StringOperationFilterInput
"The issue number of the production order."
issueNumber: StringOperationFilterInput
"The date when the production order was issued."
issueDate: ComparableDateTimeOffsetOperationFilterInput
"Additional note on the order that will be displayed during production."
notice: StringOperationFilterInput
"The timestamp when the production order was released."
releaseTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Planned delivery date."
deliveryTimestamp: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The ID of the user who created the production order."
creationUserId: ComparableBenutzerKeyOperationFilterInput
"The ID of the user who released the production order."
releaseUserId: ComparableBenutzerKeyOperationFilterInput
"The ID of the user who last modified the production order."
lastModificationUserId: ComparableBenutzerKeyOperationFilterInput
"The timestamp of the last modification of the production order."
lastModificationTimestamp: ComparableDateTimeOffsetOperationFilterInput
"The ID type of the resource (workbench-types only) which is allowed to produce this production order."
resourceTypeId: ComparableResourceTypeKeyOperationFilterInput
"The ID of the workbench resource onto which the production order was assigned."
workbenchResourceId: ComparableWorkbenchResourceKeyOperationFilterInput
}
input ProductionOrderKeySortInput {
kProductionOrder: SortEnumType @cost(weight: "10")
}
"A production order."
input ProductionOrderSortInput {
"The ID of the production order."
id: ProductionOrderKeySortInput @cost(weight: "10")
"The ID of the production item to be produced by this production order."
productionItemId: ProdItemKeySortInput @cost(weight: "10")
"The ID of the bill of material used to produce the production item."
billOfMaterialId: BillOfMaterialKeySortInput @cost(weight: "10")
"The issue number of the production order."
issueNumber: SortEnumType @cost(weight: "10")
"The date when the production order was issued."
issueDate: SortEnumType @cost(weight: "10")
"Planned start time of the production order."
targetStartTimestamp: SortEnumType @cost(weight: "10")
"Planned completion time of the production order."
targetCompletionTimestamp: SortEnumType @cost(weight: "10")
"Actual (reported) start time of the production order."
actualStartTimestamp: SortEnumType @cost(weight: "10")
"Actual (reported) completion time of the production order."
actualCompletionTimestamp: SortEnumType @cost(weight: "10")
"Planned delivery date."
deliveryTimestamp: SortEnumType @cost(weight: "10")
"The timestamp when the production order was released."
releaseTimestamp: SortEnumType @cost(weight: "10")
"Progress of the production order."
progress: SortEnumType @cost(weight: "10")
"The project number associated with the production order."
projectNumber: SortEnumType @cost(weight: "10")
"The reference number associated with the underlying order for this production order."
referenceNumber: SortEnumType @cost(weight: "10")
"The ID type of the resource (workbench-types only) which is allowed to produce this production order."
resourceTypeId: ResourceTypeKeySortInput @cost(weight: "10")
"The ID of the workbench resource onto which the production order was assigned."
workbenchResourceId: WorkbenchResourceKeySortInput @cost(weight: "10")
"The ID of the user who created the production order."
creationUserId: BenutzerKeySortInput @cost(weight: "10")
"The timestamp of the last modification of the production order."
lastModificationTimestamp: SortEnumType @cost(weight: "10")
}
"Provides paged access to stock entries filtered by warehouse, bin location, or article."
input QueryStockFilterInput {
and: [QueryStockFilterInput!]
or: [QueryStockFilterInput!]
"Unique identifier of the stock entry."
stockEntryId: ComparableWarenLagerEingangKeyOperationFilterInput
"Warehouse that owns the stock entry."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Bin location containing the stock entry."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Article stored in the stock entry."
articleId: ComparableArtikelKeyOperationFilterInput
"Available quantity (fAnzahlAktuell)."
availableQuantity: ComparableDecimalOperationFilterInput
"Quantity reserved for pick positions (fAnzahlReserviertPickpos)."
reservedQuantity: ComparableDecimalOperationFilterInput
"Batch\/charge number, empty when not tracked."
batchNumber: StringOperationFilterInput
"Best-before date (MHD) if tracked."
bestBeforeDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Serial number associated with the stock entry."
serialNumber: StringOperationFilterInput
}
"Single Row of the serial number query"
input QueryStockItemFilterInput {
and: [QueryStockItemFilterInput!]
or: [QueryStockItemFilterInput!]
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Id of the item."
itemId: ComparableArtikelKeyOperationFilterInput
}
"Single Row of the serial number query"
input QueryStockItemSortInput {
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Id of the item."
itemId: ArtikelKeySortInput @cost(weight: "10")
"Total quantity of this item at this storage location."
quantityTotal: SortEnumType @cost(weight: "10")
"Comment1"
comment1: SortEnumType @cost(weight: "10")
"Comment2"
comment2: SortEnumType @cost(weight: "10")
}
"Provides paged access to stock entries filtered by warehouse, bin location, or article."
input QueryStockSortInput {
"Unique identifier of the stock entry."
stockEntryId: WarenLagerEingangKeySortInput @cost(weight: "10")
"Warehouse that owns the stock entry."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Bin location containing the stock entry."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Article stored in the stock entry."
articleId: ArtikelKeySortInput @cost(weight: "10")
"Available quantity (fAnzahlAktuell)."
availableQuantity: SortEnumType @cost(weight: "10")
"Quantity reserved for pick positions (fAnzahlReserviertPickpos)."
reservedQuantity: SortEnumType @cost(weight: "10")
"Batch\/charge number, empty when not tracked."
batchNumber: SortEnumType @cost(weight: "10")
"Best-before date (MHD) if tracked."
bestBeforeDate: SortEnumType @cost(weight: "10")
"Serial number associated with the stock entry."
serialNumber: SortEnumType @cost(weight: "10")
}
input RechnungKeySortInput {
kRechnung: SortEnumType @cost(weight: "10")
}
input RechnungPositionKeySortInput {
kRechnungPosition: SortEnumType @cost(weight: "10")
}
input RechnungStornogrundKeySortInput {
kRechnungStornogrund: SortEnumType @cost(weight: "10")
}
"Releases an existing production order. - Request"
input ReleaseProductionOrderCommandRequestInput {
"The ID of the production order to be released."
productionOrderId: ID!
}
"Removes bin locations from a warehouse zone. - Request"
input RemoveBinLocationsFromZoneCommandRequestInput {
"The zone to remove bin locations from."
zoneId: ID!
"Bin locations to remove from the zone."
binLocationIds: [ID]!
}
"Removes the item assignment from the specified marketplace offers. - Request"
input RemoveItemFromMarketplaceOfferCommandRequestInput {
"Marketplace offer keys identifying the offers from which the item assignment should be removed."
offerKeys: [ID]!
"If true, related marketplace assignment data is removed from items as well."
removeDataFromItem: Boolean!
}
"Reset the upload counter for marketplace invoice correction PDFs. - Request"
input ResetMarketplaceInvoiceCorrectionPdfUploadCounterCommandRequestInput {
"The invoice correction PDF upload queue entries for which the upload counter should be reset."
documentUploadQueueKeys: [ID]!
}
"Reset the upload counter for marketplace invoice corrections. - Request"
input ResetMarketplaceInvoiceCorrectionUploadCounterCommandRequestInput {
"The invoice corrections for which the upload counter should be reset."
orderKeys: [ID]!
}
"Resets PDF generation for marketplace invoices\/invoice corrections so they can be reprinted and uploaded again. - Request"
input ResetMarketplaceInvoicePdfPrintingCommandRequestInput {
"Upload document IDs of the invoices\/invoice corrections to reset PDF generation."
documentUploadQueueKeys: [ID]!
}
"Reset the upload counter for marketplace order cancellation request uploads. - Request"
input ResetMarketplaceOrderCancellationRequestUploadCounterCommandRequestInput {
"Marketplace order cancellation event keys whose upload counter should be reset."
orderCancellationEventKeys: [ID]!
}
"Reset the upload counter for marketplace order cancellation uploads. - Request"
input ResetMarketplaceOrderCancellationUploadCounterCommandRequestInput {
"Marketplace order keys of cancellation uploads whose counter should be reset."
orderKeys: [ID]!
}
"Reset the upload counter for marketplace payment uploads. - Request"
input ResetMarketplacePaymentUploadCounterCommandRequestInput {
"Marketplace order keys of payment uploads whose counter should be reset."
orderKeys: [ID]!
}
"Reset the upload counter for marketplace return uploads. - Request"
input ResetMarketplaceReturnUploadCounterCommandRequestInput {
"Marketplace order keys of return uploads whose counter should be reset."
orderKeys: [ID]!
}
"Reset the upload counter for marketplace shipping information uploads. - Request"
input ResetMarketplaceShippingInformationUploadCounterCommandRequestInput {
"Marketplace order shipping keys of shipping information uploads whose counter should be reset."
orderShippingKeys: [ID]!
}
"Represents a resource category"
input ResourceCategoryFilterInput {
and: [ResourceCategoryFilterInput!]
or: [ResourceCategoryFilterInput!]
"This resource category's unqiue ID."
id: ComparableResourceCategoryKeyOperationFilterInput
"The resource category's name."
name: StringOperationFilterInput
"Specifies whether this resource category is visible to users."
isVisible: ComparableBooleanOperationFilterInput
"Specifies whether this resource category is enabled for use."
isEnabled: ComparableBooleanOperationFilterInput
}
"Ein Schlüssel für eine Ressourcenkategorie."
input ResourceCategoryKeySortInput {
"Der durch diesen Schlüssel beschriebene global eindeutige Bezeichner."
value: SortEnumType @cost(weight: "10")
}
"Represents a resource category"
input ResourceCategorySortInput {
"This resource category's unqiue ID."
id: ResourceCategoryKeySortInput @cost(weight: "10")
"The resource category's name."
name: SortEnumType @cost(weight: "10")
"Specifies whether this resource category is visible to users."
isVisible: SortEnumType @cost(weight: "10")
"Specifies whether this resource category is enabled for use."
isEnabled: SortEnumType @cost(weight: "10")
}
input ResourceTypeKeySortInput {
kResourceType: SortEnumType @cost(weight: "10")
}
input RueckhaltegrundKeySortInput {
kRueckhalteGrund: SortEnumType @cost(weight: "10")
}
"Single row of the sales channels overview table"
input SalesChannelFilterInput {
and: [SalesChannelFilterInput!]
or: [SalesChannelFilterInput!]
"Unique identifier of the sales channel"
id: ComparableShopKeyOperationFilterInput
"Name of the sales channel"
name: StringOperationFilterInput
}
"Single row of the sales channels overview table"
input SalesChannelSortInput {
"Unique identifier of the sales channel"
id: ShopKeySortInput @cost(weight: "10")
"Name of the sales channel"
name: SortEnumType @cost(weight: "10")
}
input SalesInvoiceCancellationInternalFilterInput {
and: [SalesInvoiceCancellationInternalFilterInput!]
or: [SalesInvoiceCancellationInternalFilterInput!]
"Sales order identifier"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales invoice identifier"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Company identifier"
companyId: ComparableFirmaKeyOperationFilterInput
"Customer identifier"
customerId: ComparableKundeKeyOperationFilterInput
"Platform identifier"
platformId: ComparablePlattformKeyOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Sales invoice cancellation date"
salesInvoiceCancellationDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"External order number"
externalOrderNumber: StringOperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Date when the order was created in the ERP system"
createdInErpDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Tax setting"
taxSetting: ComparableInt32OperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Currency conversion factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Departure country currency ISO code"
departureCountryCurrencyIso: StringOperationFilterInput
"Departure country currency conversion factor"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"Service date"
serviceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Last shipping date"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Platform identifier"
platformName: StringOperationFilterInput
"Shipment method identifier"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"Value date"
valueDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Customer VAT identifier"
customerVatIdNumber: StringOperationFilterInput
"Sales invoice VAT identifier"
salesInvoiceVatIdNumber: StringOperationFilterInput
"Departure country ISO code"
departureCountryIso: StringOperationFilterInput
"Total gross amount"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Customer number"
salesInvoiceCustomerNumber: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableInt32OperationFilterInput
"Payment status"
paymentStatus: ComparableNullableOfInt32OperationFilterInput
"Invoice payment method identifier"
invoicePaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Payment method identifier"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Payment method"
paymentMethodName: StringOperationFilterInput
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: StringOperationFilterInput
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: ComparableNullableOfDecimalOperationFilterInput
"Shipment company name"
shipmentAddressCompany: StringOperationFilterInput
"Shipment salutation"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment street address"
shipmentAddressStreet: StringOperationFilterInput
"Shipment postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment city"
shipmentAddressCity: StringOperationFilterInput
"Shipment country"
shipmentAddressCountry: StringOperationFilterInput
"Shipment phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment fax number"
shipmentAddressFaxNumber: StringOperationFilterInput
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment country ISO code"
shipmentAddressCountryIso: StringOperationFilterInput
"Shipment VAT identifier"
shipmentAddressVatIdNumber: StringOperationFilterInput
"Sales invoice company name"
billingAddressCompany: StringOperationFilterInput
"Sales invoice salutation"
billingAddressSalutation: StringOperationFilterInput
"Sales invoice title"
billingAddressTitle: StringOperationFilterInput
"Sales invoice first name"
billingAddressFirstName: StringOperationFilterInput
"Sales invoice last name"
billingAddressLastName: StringOperationFilterInput
"Sales invoice street address"
billingAddressStreet: StringOperationFilterInput
"Sales invoice postal code"
billingAddressPostalCode: StringOperationFilterInput
"Sales invoice city"
billingAddressCity: StringOperationFilterInput
"Sales invoice country"
billingAddressCountry: StringOperationFilterInput
"Sales invoice phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Sales invoice fax number"
billingAddressFaxNumber: StringOperationFilterInput
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Sales invoice country ISO code"
billingAddressCountryIso: StringOperationFilterInput
"Customer company name"
customerDefaultBillingAddressCompany: StringOperationFilterInput
"Customer salutation"
customerDefaultBillingAddressSalutation: StringOperationFilterInput
"Customer title"
customerDefaultBillingAddressTitle: StringOperationFilterInput
"Customer first name"
customerDefaultBillingAddressFirstName: StringOperationFilterInput
"Customer last name"
customerDefaultBillingAddressLastName: StringOperationFilterInput
"Customer street address"
customerDefaultBillingAddressStreet: StringOperationFilterInput
"Customer postal code"
customerDefaultBillingAddressPostalCode: StringOperationFilterInput
"Customer city"
customerDefaultBillingAddressCity: StringOperationFilterInput
"Customer country"
customerDefaultBillingAddressCountry: StringOperationFilterInput
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerDefaultBillingAddressFaxNumber: StringOperationFilterInput
"Customer address country ISO code"
customerDefaultBillingAddressCountryIso: StringOperationFilterInput
"Customer email address"
customerDefaultBillingAddressEmailAddress: StringOperationFilterInput
"Customer address VAT identifier"
customerDefaultBillingAddressVatIdNumber: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer group identifier"
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Customer payment due date in days"
customerPaymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Deposit information"
deposit: StringOperationFilterInput
"Delivery note count for drop shipping"
dropShippingDeliveryNoteCount: ComparableInt32OperationFilterInput
}
input SalesInvoiceCancellationInternalSortInput {
"Sales order identifier"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales invoice identifier"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Company identifier"
companyId: FirmaKeySortInput @cost(weight: "10")
"Customer identifier"
customerId: KundeKeySortInput @cost(weight: "10")
"Platform identifier"
platformId: PlattformKeySortInput @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Sales invoice cancellation date"
salesInvoiceCancellationDate: SortEnumType @cost(weight: "10")
"External order number"
externalOrderNumber: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Date when the order was created in the ERP system"
createdInErpDate: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Currency conversion factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Departure country currency ISO code"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Departure country currency conversion factor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Last shipping date"
lastShippingDate: SortEnumType @cost(weight: "10")
"Platform identifier"
platformName: SortEnumType @cost(weight: "10")
"Shipment method identifier"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Value date"
valueDate: SortEnumType @cost(weight: "10")
"Customer VAT identifier"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice VAT identifier"
salesInvoiceVatIdNumber: SortEnumType @cost(weight: "10")
"Departure country ISO code"
departureCountryIso: SortEnumType @cost(weight: "10")
"Total gross amount"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount"
totalNetAmount: SortEnumType @cost(weight: "10")
"Customer number"
salesInvoiceCustomerNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Payment status"
paymentStatus: SortEnumType @cost(weight: "10")
"Invoice payment method identifier"
invoicePaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Payment method identifier"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Payment method"
paymentMethodName: SortEnumType @cost(weight: "10")
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Shipment company name"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment salutation"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment street address"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment country"
shipmentAddressCountry: SortEnumType @cost(weight: "10")
"Shipment phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment fax number"
shipmentAddressFaxNumber: SortEnumType @cost(weight: "10")
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment country ISO code"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipment VAT identifier"
shipmentAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice company name"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Sales invoice salutation"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Sales invoice title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Sales invoice first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Sales invoice last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Sales invoice street address"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Sales invoice postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Sales invoice city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Sales invoice country"
billingAddressCountry: SortEnumType @cost(weight: "10")
"Sales invoice phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Sales invoice fax number"
billingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Sales invoice country ISO code"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer company name"
customerDefaultBillingAddressCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerDefaultBillingAddressSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerDefaultBillingAddressTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerDefaultBillingAddressFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerDefaultBillingAddressLastName: SortEnumType @cost(weight: "10")
"Customer street address"
customerDefaultBillingAddressStreet: SortEnumType @cost(weight: "10")
"Customer postal code"
customerDefaultBillingAddressPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerDefaultBillingAddressCity: SortEnumType @cost(weight: "10")
"Customer country"
customerDefaultBillingAddressCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerDefaultBillingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Customer address country ISO code"
customerDefaultBillingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer email address"
customerDefaultBillingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer address VAT identifier"
customerDefaultBillingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer group identifier"
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Customer payment due date in days"
customerPaymentDueDateInDays: SortEnumType @cost(weight: "10")
"Deposit information"
deposit: SortEnumType @cost(weight: "10")
"Delivery note count for drop shipping"
dropShippingDeliveryNoteCount: SortEnumType @cost(weight: "10")
}
"Single sales invoice cancellation reason"
input SalesInvoiceCancellationReasonFilterInput {
and: [SalesInvoiceCancellationReasonFilterInput!]
or: [SalesInvoiceCancellationReasonFilterInput!]
"Unique identifier of the sales invoice cancellation reason"
id: ComparableRechnungStornogrundKeyOperationFilterInput
"Name of the cancellation reason"
name: StringOperationFilterInput
"Indicates whether a comment is required when using this cancellation reason"
isCommentRequired: ComparableBooleanOperationFilterInput
}
"Single sales invoice cancellation reason"
input SalesInvoiceCancellationReasonSortInput {
"Unique identifier of the sales invoice cancellation reason"
id: RechnungStornogrundKeySortInput @cost(weight: "10")
"Name of the cancellation reason"
name: SortEnumType @cost(weight: "10")
"Indicates whether a comment is required when using this cancellation reason"
isCommentRequired: SortEnumType @cost(weight: "10")
}
input SalesInvoiceCorrectionInternalFilterInput {
and: [SalesInvoiceCorrectionInternalFilterInput!]
or: [SalesInvoiceCorrectionInternalFilterInput!]
"Sales order identifier"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales invoice correction identifier"
salesInvoiceCorrectionId: ComparableGutschriftKeyOperationFilterInput
"Customer identifier"
customerId: ComparableKundeKeyOperationFilterInput
"Company identifier"
companyId: ComparableFirmaKeyOperationFilterInput
"Sales invoice identifier"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Platform identifier"
platformId: ComparablePlattformKeyOperationFilterInput
"Cancelled sales invoice identifier"
cancelledSalesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Sales invoice payment method identifier"
salesInvoicePaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Sales invoice correction payment method identifier"
salesInvoiceCorrectionPaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Sales invoice correction number"
salesInvoiceCorrectionNumber: StringOperationFilterInput
"Sales invoice correction date"
salesInvoiceCorrectionDate: ComparableDateTimeOffsetOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Sales invoice date"
salesInvoiceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"External order number"
externalOrderNumber: StringOperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Date when the order was created in the ERP system"
createdInErpDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Currency conversion factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Departure country currency ISO code"
departureCountryCurrencyIso: StringOperationFilterInput
"Departure country currency conversion factor"
departureCountryCurrencyFactor: ComparableNullableOfDecimalOperationFilterInput
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: StringOperationFilterInput
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: ComparableNullableOfDecimalOperationFilterInput
"Shipment type"
salesOrderShippingMethodId: ComparableVersandartKeyOperationFilterInput
"Shipment type"
salesInvoiceShippingMethodId: ComparableVersandartKeyOperationFilterInput
"Service date"
serviceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Delivery date"
deliveryDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Total gross amount"
totalGrossAmount: ComparableDecimalOperationFilterInput
"Sales order total gross amount"
salesOrderTotalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Sales order total net amount"
salesOrderTotalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Platform identifier"
platformIdentifier: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Shipment company name"
shipmentCompany: StringOperationFilterInput
"Shipment salutation"
shipmentSalutation: StringOperationFilterInput
"Shipment title"
shipmentTitle: StringOperationFilterInput
"Shipment first name"
shipmentFirstName: StringOperationFilterInput
"Shipment last name"
shipmentLastName: StringOperationFilterInput
"Shipment street address"
shipmentStreet: StringOperationFilterInput
"Shipment postal code"
shipmentPostalCode: StringOperationFilterInput
"Shipment city"
shipmentCity: StringOperationFilterInput
"Shipment country"
shipmentCountry: StringOperationFilterInput
"Shipment phone number"
shipmentPhoneNumber: StringOperationFilterInput
"Shipment fax number"
shipmentFaxNumber: StringOperationFilterInput
"Shipment additional address line"
shipmentAdditionalAddressLine: StringOperationFilterInput
"Shipment country ISO code"
shipmentCountryIso: StringOperationFilterInput
"Shipment VAT identifier"
shipmentVatIdNumber: StringOperationFilterInput
"Sales order customer VAT identifier"
salesOrderCustomerVatIdNumber: StringOperationFilterInput
"Sales invoice company name"
salesInvoiceCompany: StringOperationFilterInput
"Sales invoice salutation"
salesInvoiceSalutation: StringOperationFilterInput
"Sales invoice title"
salesInvoiceTitle: StringOperationFilterInput
"Sales invoice first name"
salesInvoiceFirstName: StringOperationFilterInput
"Sales invoice last name"
salesInvoiceLastName: StringOperationFilterInput
"Sales invoice street address"
salesInvoiceStreet: StringOperationFilterInput
"Sales invoice postal code"
salesInvoicePostalCode: StringOperationFilterInput
"Sales invoice city"
salesInvoiceCity: StringOperationFilterInput
"Sales invoice country"
salesInvoiceCountry: StringOperationFilterInput
"Sales invoice phone number"
salesInvoicePhoneNumber: StringOperationFilterInput
"Sales invoice fax number"
salesInvoiceFaxNumber: StringOperationFilterInput
"Sales invoice additional address line"
salesInvoiceAdditionalAddressLine: StringOperationFilterInput
"Sales invoice country ISO code"
salesInvoiceIso: StringOperationFilterInput
"Customer company name"
customerCompany: StringOperationFilterInput
"Customer salutation"
customerSalutation: StringOperationFilterInput
"Customer title"
customerTitle: StringOperationFilterInput
"Customer first name"
customerFirstName: StringOperationFilterInput
"Customer last name"
customerLastName: StringOperationFilterInput
"Customer street address"
customerStreet: StringOperationFilterInput
"Customer postal code"
customerPostalCode: StringOperationFilterInput
"Customer city"
customerCity: StringOperationFilterInput
"Customer country"
customerCountry: StringOperationFilterInput
"Customer phone number"
customerPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerFaxNumber: StringOperationFilterInput
"Customer address country ISO code"
customerAddressIso: StringOperationFilterInput
"Customer email address"
customerAddressEmailAddress: StringOperationFilterInput
"Customer address VAT identifier"
customerAddressVatIdNumber: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer group identifier"
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Customer payment due date in days"
customerPaymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Last shipping date"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Tax setting"
taxSetting: ComparableNullableOfInt32OperationFilterInput
"VAT identifier"
salesOrderVatIdNumber: StringOperationFilterInput
"Departure country ISO code"
departureCountryIso: StringOperationFilterInput
"Payment method"
paymentMethod: StringOperationFilterInput
"Customer VAT identifier"
customerVatIdNumber: StringOperationFilterInput
"VAT identifier"
salesInvoiceVatIdNumber: StringOperationFilterInput
"Customer number"
salesInvoiceCustomerNumber: StringOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Payment method"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Indicates if this is a storno (cancellation)"
isCancelled: StringOperationFilterInput
"Deposit information"
deposit: StringOperationFilterInput
"Sales invoice identifier"
salesInvoiceId2: ComparableRechnungKeyOperationFilterInput
"Delivery note count"
dropShippingDeliveryNoteCount: ComparableInt32OperationFilterInput
}
input SalesInvoiceCorrectionInternalSortInput {
"Sales order identifier"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales invoice correction identifier"
salesInvoiceCorrectionId: GutschriftKeySortInput @cost(weight: "10")
"Customer identifier"
customerId: KundeKeySortInput @cost(weight: "10")
"Company identifier"
companyId: FirmaKeySortInput @cost(weight: "10")
"Sales invoice identifier"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Platform identifier"
platformId: PlattformKeySortInput @cost(weight: "10")
"Cancelled sales invoice identifier"
cancelledSalesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Sales invoice payment method identifier"
salesInvoicePaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Sales invoice correction payment method identifier"
salesInvoiceCorrectionPaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Sales invoice correction number"
salesInvoiceCorrectionNumber: SortEnumType @cost(weight: "10")
"Sales invoice correction date"
salesInvoiceCorrectionDate: SortEnumType @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Sales invoice date"
salesInvoiceDate: SortEnumType @cost(weight: "10")
"External order number"
externalOrderNumber: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Date when the order was created in the ERP system"
createdInErpDate: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Currency conversion factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Departure country currency ISO code"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Departure country currency conversion factor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Sales order departure country currency ISO code"
salesOrderDepartureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Sales order departure country currency conversion factor"
salesOrderDepartureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Shipment type"
salesOrderShippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Shipment type"
salesInvoiceShippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Delivery date"
deliveryDate: SortEnumType @cost(weight: "10")
"Total gross amount"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Sales order total gross amount"
salesOrderTotalGrossAmount: SortEnumType @cost(weight: "10")
"Sales order total net amount"
salesOrderTotalNetAmount: SortEnumType @cost(weight: "10")
"Platform identifier"
platformIdentifier: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Shipment company name"
shipmentCompany: SortEnumType @cost(weight: "10")
"Shipment salutation"
shipmentSalutation: SortEnumType @cost(weight: "10")
"Shipment title"
shipmentTitle: SortEnumType @cost(weight: "10")
"Shipment first name"
shipmentFirstName: SortEnumType @cost(weight: "10")
"Shipment last name"
shipmentLastName: SortEnumType @cost(weight: "10")
"Shipment street address"
shipmentStreet: SortEnumType @cost(weight: "10")
"Shipment postal code"
shipmentPostalCode: SortEnumType @cost(weight: "10")
"Shipment city"
shipmentCity: SortEnumType @cost(weight: "10")
"Shipment country"
shipmentCountry: SortEnumType @cost(weight: "10")
"Shipment phone number"
shipmentPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment fax number"
shipmentFaxNumber: SortEnumType @cost(weight: "10")
"Shipment additional address line"
shipmentAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment country ISO code"
shipmentCountryIso: SortEnumType @cost(weight: "10")
"Shipment VAT identifier"
shipmentVatIdNumber: SortEnumType @cost(weight: "10")
"Sales order customer VAT identifier"
salesOrderCustomerVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice company name"
salesInvoiceCompany: SortEnumType @cost(weight: "10")
"Sales invoice salutation"
salesInvoiceSalutation: SortEnumType @cost(weight: "10")
"Sales invoice title"
salesInvoiceTitle: SortEnumType @cost(weight: "10")
"Sales invoice first name"
salesInvoiceFirstName: SortEnumType @cost(weight: "10")
"Sales invoice last name"
salesInvoiceLastName: SortEnumType @cost(weight: "10")
"Sales invoice street address"
salesInvoiceStreet: SortEnumType @cost(weight: "10")
"Sales invoice postal code"
salesInvoicePostalCode: SortEnumType @cost(weight: "10")
"Sales invoice city"
salesInvoiceCity: SortEnumType @cost(weight: "10")
"Sales invoice country"
salesInvoiceCountry: SortEnumType @cost(weight: "10")
"Sales invoice phone number"
salesInvoicePhoneNumber: SortEnumType @cost(weight: "10")
"Sales invoice fax number"
salesInvoiceFaxNumber: SortEnumType @cost(weight: "10")
"Sales invoice additional address line"
salesInvoiceAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Sales invoice country ISO code"
salesInvoiceIso: SortEnumType @cost(weight: "10")
"Customer company name"
customerCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerLastName: SortEnumType @cost(weight: "10")
"Customer street address"
customerStreet: SortEnumType @cost(weight: "10")
"Customer postal code"
customerPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerCity: SortEnumType @cost(weight: "10")
"Customer country"
customerCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerFaxNumber: SortEnumType @cost(weight: "10")
"Customer address country ISO code"
customerAddressIso: SortEnumType @cost(weight: "10")
"Customer email address"
customerAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer address VAT identifier"
customerAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer group identifier"
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Customer payment due date in days"
customerPaymentDueDateInDays: SortEnumType @cost(weight: "10")
"Last shipping date"
lastShippingDate: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"VAT identifier"
salesOrderVatIdNumber: SortEnumType @cost(weight: "10")
"Departure country ISO code"
departureCountryIso: SortEnumType @cost(weight: "10")
"Payment method"
paymentMethod: SortEnumType @cost(weight: "10")
"Customer VAT identifier"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"VAT identifier"
salesInvoiceVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
salesInvoiceCustomerNumber: SortEnumType @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Payment method"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Indicates if this is a storno (cancellation)"
isCancelled: SortEnumType @cost(weight: "10")
"Deposit information"
deposit: SortEnumType @cost(weight: "10")
"Sales invoice identifier"
salesInvoiceId2: RechnungKeySortInput @cost(weight: "10")
"Delivery note count"
dropShippingDeliveryNoteCount: SortEnumType @cost(weight: "10")
}
input SalesInvoiceCorrectionLineItemInternalFilterInput {
and: [SalesInvoiceCorrectionLineItemInternalFilterInput!]
or: [SalesInvoiceCorrectionLineItemInternalFilterInput!]
"Sales invoice correction line item identifier"
salesInvoiceCorrectionLineItemId: ComparableGutschriftPosKeyOperationFilterInput
"Sales order line item identifier"
salesOrderLineItemId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales price gross"
salesPriceGross: ComparableDecimalOperationFilterInput
"Discount amount"
discount: ComparableDecimalOperationFilterInput
"Sales price net"
salesPriceNet: ComparableDecimalOperationFilterInput
"Quantity"
quantity: ComparableDecimalOperationFilterInput
"Sales invoice correction line item name"
lineItemName: StringOperationFilterInput
"Stock keeping unit"
sku: StringOperationFilterInput
"Value added tax rate"
taxRate: ComparableDecimalOperationFilterInput
"Sales order item purchase price net"
salesOrderLineItemPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Item purchase price net"
itemPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Tax class identifier"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Line item type"
lineItemType: ComparableNullableOfByteOperationFilterInput
"Item identifier"
itemId: ComparableArtikelKeyOperationFilterInput
"Sales order parts list identifier"
billOfMaterialsSalesOrderLineItemId: ComparableVerkaufAuftragPositionKeyOperationFilterInput
"Parent item identifier"
parentItemId: ComparableArtikelKeyOperationFilterInput
"Taric code"
taric: StringOperationFilterInput
"Item weight"
itemWeight: ComparableNullableOfDecimalOperationFilterInput
"Item volume"
itemVolume: ComparableNullableOfDecimalOperationFilterInput
"Product group identifier"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Product group name"
productGroupName: StringOperationFilterInput
"Warehouse identifier"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Sales invoice line item identifier"
salesInvoiceLineItemId: ComparableRechnungPositionKeyOperationFilterInput
}
input SalesInvoiceCorrectionLineItemInternalSortInput {
"Sales invoice correction line item identifier"
salesInvoiceCorrectionLineItemId: GutschriftPosKeySortInput @cost(weight: "10")
"Sales order line item identifier"
salesOrderLineItemId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales price gross"
salesPriceGross: SortEnumType @cost(weight: "10")
"Discount amount"
discount: SortEnumType @cost(weight: "10")
"Sales price net"
salesPriceNet: SortEnumType @cost(weight: "10")
"Quantity"
quantity: SortEnumType @cost(weight: "10")
"Sales invoice correction line item name"
lineItemName: SortEnumType @cost(weight: "10")
"Stock keeping unit"
sku: SortEnumType @cost(weight: "10")
"Value added tax rate"
taxRate: SortEnumType @cost(weight: "10")
"Sales order item purchase price net"
salesOrderLineItemPurchasePriceNet: SortEnumType @cost(weight: "10")
"Item purchase price net"
itemPurchasePriceNet: SortEnumType @cost(weight: "10")
"Tax class identifier"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Line item type"
lineItemType: SortEnumType @cost(weight: "10")
"Item identifier"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Sales order parts list identifier"
billOfMaterialsSalesOrderLineItemId: VerkaufAuftragPositionKeySortInput @cost(weight: "10")
"Parent item identifier"
parentItemId: ArtikelKeySortInput @cost(weight: "10")
"Taric code"
taric: SortEnumType @cost(weight: "10")
"Item weight"
itemWeight: SortEnumType @cost(weight: "10")
"Item volume"
itemVolume: SortEnumType @cost(weight: "10")
"Product group identifier"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Product group name"
productGroupName: SortEnumType @cost(weight: "10")
"Warehouse identifier"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Sales invoice line item identifier"
salesInvoiceLineItemId: RechnungPositionKeySortInput @cost(weight: "10")
}
"Single row of the invoice corrections overview table"
input SalesInvoiceCorrectionListItemFilterInput {
and: [SalesInvoiceCorrectionListItemFilterInput!]
or: [SalesInvoiceCorrectionListItemFilterInput!]
"Unique identifier of the invoice correction"
id: ComparableGutschriftKeyOperationFilterInput
"Entry number of the invoice correction"
salesInvoiceCorrectionNumber: StringOperationFilterInput
"Entry number of the related invoice"
salesInvoiceNumber: StringOperationFilterInput
"Number of the related customer"
customerNumber: StringOperationFilterInput
"Total gross amount of the invoice correction"
totalGrossAmount: ComparableDecimalOperationFilterInput
"Total net amount of the invoice correction"
totalNetAmount: ComparableDecimalOperationFilterInput
"The revenue account of the invoice correction"
revenueAccount: StringOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Name of the customer group"
customerGroupName: StringOperationFilterInput
"Date when the invoice correction was created"
salesInvoiceCorrectionDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice correction was first printed"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice correction was first sent via e-mail"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Comment of the related invoice"
salesInvoiceComment: StringOperationFilterInput
"Date when the invoice correction was cancelled"
cancelledDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Name of the user who cancelled the invoice correction"
cancellationUserName: StringOperationFilterInput
"Cancellation reason"
cancellationReason: StringOperationFilterInput
"Cancellation comment"
cancellationComment: StringOperationFilterInput
"Short text of the invoice collection"
shortText: StringOperationFilterInput
"Billing address company"
billingAddressCompany: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street"
billingAddressStreet: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address fax number"
billingAddressFax: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"Billing address additional company line"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address state"
billingAddressState: StringOperationFilterInput
"Shipment address company"
shipmentAddressCompany: StringOperationFilterInput
"Shipment address first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street"
shipmentAddressStreet: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address fax number"
shipmentAddressFax: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address state"
shipmentAddressState: StringOperationFilterInput
"Created by user ID"
createdByUserId: ComparableBenutzerKeyOperationFilterInput
"Status text of the invoice correction"
status: StringOperationFilterInput
"CompanyId"
companyId: ComparableFirmaKeyOperationFilterInput
"Comment of the sales invoice correction"
comment: StringOperationFilterInput
"eBay user name"
ebayUsername: StringOperationFilterInput
}
"Single row of the invoice corrections overview table"
input SalesInvoiceCorrectionListItemSortInput {
"Unique identifier of the invoice correction"
id: GutschriftKeySortInput @cost(weight: "10")
"Entry number of the invoice correction"
salesInvoiceCorrectionNumber: SortEnumType @cost(weight: "10")
"Entry number of the related invoice"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Number of the related customer"
customerNumber: SortEnumType @cost(weight: "10")
"Total gross amount of the invoice correction"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount of the invoice correction"
totalNetAmount: SortEnumType @cost(weight: "10")
"The revenue account of the invoice correction"
revenueAccount: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Name of the customer group"
customerGroupName: SortEnumType @cost(weight: "10")
"Date when the invoice correction was created"
salesInvoiceCorrectionDate: SortEnumType @cost(weight: "10")
"Date when the invoice correction was first printed"
printDate: SortEnumType @cost(weight: "10")
"Date when the invoice correction was first sent via e-mail"
mailDate: SortEnumType @cost(weight: "10")
"Comment of the related invoice"
salesInvoiceComment: SortEnumType @cost(weight: "10")
"Date when the invoice correction was cancelled"
cancelledDate: SortEnumType @cost(weight: "10")
"Name of the user who cancelled the invoice correction"
cancellationUserName: SortEnumType @cost(weight: "10")
"Cancellation reason"
cancellationReason: SortEnumType @cost(weight: "10")
"Cancellation comment"
cancellationComment: SortEnumType @cost(weight: "10")
"Short text of the invoice collection"
shortText: SortEnumType @cost(weight: "10")
"Billing address company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax number"
billingAddressFax: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Billing address additional company line"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address state"
billingAddressState: SortEnumType @cost(weight: "10")
"Shipment address company"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment address first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax number"
shipmentAddressFax: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address state"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Created by user ID"
createdByUserId: BenutzerKeySortInput @cost(weight: "10")
"Status text of the invoice correction"
status: SortEnumType @cost(weight: "10")
"CompanyId"
companyId: FirmaKeySortInput @cost(weight: "10")
"Comment of the sales invoice correction"
comment: SortEnumType @cost(weight: "10")
"eBay user name"
ebayUsername: SortEnumType @cost(weight: "10")
}
input SalesInvoiceInternalFilterInput {
and: [SalesInvoiceInternalFilterInput!]
or: [SalesInvoiceInternalFilterInput!]
"Sales order ID"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Sales invoice ID"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"Platform ID"
platformId: ComparablePlattformKeyOperationFilterInput
"Payment method ID"
salesInvoicePaymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Company ID"
companyId: ComparableFirmaKeyOperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableInt32OperationFilterInput
"Payment status"
paymentStatus: ComparableNullableOfByteOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Sales invoice date"
salesInvoiceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"External order number"
externalOrderNumber: StringOperationFilterInput
"Shipment type"
shipmentType: ComparableNullableOfInt32OperationFilterInput
"Value date"
valueDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Tax setting"
taxSetting: ComparableInt32OperationFilterInput
"Customer VAT ID"
customerVatIdNumber: StringOperationFilterInput
"Sales invoice VAT ID"
salesInvoiceVatIdNumber: StringOperationFilterInput
"Departure country ISO"
departureCountryIso: StringOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Service date"
serviceDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Customer number"
salesInvoiceCustomerNumber: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Currency ISO"
currencyIso: StringOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Departure country currency ISO"
departureCountryCurrencyIso: StringOperationFilterInput
"Departure country currency factor"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"Total gross amount"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Last shipping"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Created in ERP date"
createdInErpDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Platform identifier"
platformIdentifier: StringOperationFilterInput
"Payment method"
paymentMethod: StringOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Shipment company"
shipmentAddressCompany: StringOperationFilterInput
"Shipment salutation"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment street"
shipmentAddressStreet: StringOperationFilterInput
"Shipment postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment city"
shipmentAddressCity: StringOperationFilterInput
"Shipment country"
shipmentAddressCountry: StringOperationFilterInput
"Shipment phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment fax number"
shipmentAddressFaxNumber: StringOperationFilterInput
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment country ISO"
shipmentAddressCountryIso: StringOperationFilterInput
"Shipment VAT ID"
shipmentAddressVatIdNumber: StringOperationFilterInput
"Sales order shipment country ISO"
salesOrderShipmentCountryIso: StringOperationFilterInput
"Sales invoice company"
billingAddressCompany: StringOperationFilterInput
"Sales invoice salutation"
billingAddressSalutation: StringOperationFilterInput
"Sales invoice title"
billingAddressTitle: StringOperationFilterInput
"Sales invoice first name"
billingAddressFirstName: StringOperationFilterInput
"Sales invoice last name"
billingAddressLastName: StringOperationFilterInput
"Sales invoice street"
billingAddressStreet: StringOperationFilterInput
"Sales invoice postal code"
billingAddressPostalCode: StringOperationFilterInput
"Sales invoice city"
billingAddressCity: StringOperationFilterInput
"Sales invoice country"
billingAddressCountry: StringOperationFilterInput
"Sales invoice phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Sales invoice fax number"
billingAddressFaxNumber: StringOperationFilterInput
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Sales invoice ISO"
billingAddressCountryIso: StringOperationFilterInput
"Customer company"
customerDefaultBillingAddressCompany: StringOperationFilterInput
"Customer salutation"
customerDefaultBillingAddressSalutation: StringOperationFilterInput
"Customer title"
customerDefaultBillingAddressTitle: StringOperationFilterInput
"Customer first name"
customerDefaultBillingAddressFirstName: StringOperationFilterInput
"Customer last name"
customerDefaultBillingAddressLastName: StringOperationFilterInput
"Customer street"
customerDefaultBillingAddressStreet: StringOperationFilterInput
"Customer postal code"
customerDefaultBillingAddressPostalCode: StringOperationFilterInput
"Customer city"
customerDefaultBillingAddressCity: StringOperationFilterInput
"Customer country"
customerDefaultBillingAddressCountry: StringOperationFilterInput
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: StringOperationFilterInput
"Customer fax number"
customerDefaultBillingAddressFaxNumber: StringOperationFilterInput
"Customer address ISO"
customerDefaultBillingAddressCountryIso: StringOperationFilterInput
"Customer address email address"
customerDefaultBillingAddressEmailAddress: StringOperationFilterInput
"Customer address VAT ID"
customerDefaultBillingAddressVatIdNumber: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Customer group ID"
customerGroupId: ComparableKundenGruppeKeyOperationFilterInput
"Customer payment due date in days"
customerPaymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Deposit"
deposit: StringOperationFilterInput
"Cancelled sales invoice ID"
cancelledSalesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Delivery note count"
dropShippingDeliveryNoteCount: ComparableInt32OperationFilterInput
}
input SalesInvoiceInternalSortInput {
"Sales order ID"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Sales invoice ID"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"Platform ID"
platformId: PlattformKeySortInput @cost(weight: "10")
"Payment method ID"
salesInvoicePaymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Payment status"
paymentStatus: SortEnumType @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Sales invoice date"
salesInvoiceDate: SortEnumType @cost(weight: "10")
"External order number"
externalOrderNumber: SortEnumType @cost(weight: "10")
"Shipment type"
shipmentType: SortEnumType @cost(weight: "10")
"Value date"
valueDate: SortEnumType @cost(weight: "10")
"Tax setting"
taxSetting: SortEnumType @cost(weight: "10")
"Customer VAT ID"
customerVatIdNumber: SortEnumType @cost(weight: "10")
"Sales invoice VAT ID"
salesInvoiceVatIdNumber: SortEnumType @cost(weight: "10")
"Departure country ISO"
departureCountryIso: SortEnumType @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Service date"
serviceDate: SortEnumType @cost(weight: "10")
"Customer number"
salesInvoiceCustomerNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Currency ISO"
currencyIso: SortEnumType @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Departure country currency ISO"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Departure country currency factor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Total gross amount"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount"
totalNetAmount: SortEnumType @cost(weight: "10")
"Last shipping"
lastShippingDate: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Created in ERP date"
createdInErpDate: SortEnumType @cost(weight: "10")
"Platform identifier"
platformIdentifier: SortEnumType @cost(weight: "10")
"Payment method"
paymentMethod: SortEnumType @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Shipment company"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment salutation"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment country"
shipmentAddressCountry: SortEnumType @cost(weight: "10")
"Shipment phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment fax number"
shipmentAddressFaxNumber: SortEnumType @cost(weight: "10")
"Shipment additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment country ISO"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipment VAT ID"
shipmentAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Sales order shipment country ISO"
salesOrderShipmentCountryIso: SortEnumType @cost(weight: "10")
"Sales invoice company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Sales invoice salutation"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Sales invoice title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Sales invoice first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Sales invoice last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Sales invoice street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Sales invoice postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Sales invoice city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Sales invoice country"
billingAddressCountry: SortEnumType @cost(weight: "10")
"Sales invoice phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Sales invoice fax number"
billingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Sales invoice additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Sales invoice ISO"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer company"
customerDefaultBillingAddressCompany: SortEnumType @cost(weight: "10")
"Customer salutation"
customerDefaultBillingAddressSalutation: SortEnumType @cost(weight: "10")
"Customer title"
customerDefaultBillingAddressTitle: SortEnumType @cost(weight: "10")
"Customer first name"
customerDefaultBillingAddressFirstName: SortEnumType @cost(weight: "10")
"Customer last name"
customerDefaultBillingAddressLastName: SortEnumType @cost(weight: "10")
"Customer street"
customerDefaultBillingAddressStreet: SortEnumType @cost(weight: "10")
"Customer postal code"
customerDefaultBillingAddressPostalCode: SortEnumType @cost(weight: "10")
"Customer city"
customerDefaultBillingAddressCity: SortEnumType @cost(weight: "10")
"Customer country"
customerDefaultBillingAddressCountry: SortEnumType @cost(weight: "10")
"Customer phone number"
customerDefaultBillingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Customer fax number"
customerDefaultBillingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Customer address ISO"
customerDefaultBillingAddressCountryIso: SortEnumType @cost(weight: "10")
"Customer address email address"
customerDefaultBillingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Customer address VAT ID"
customerDefaultBillingAddressVatIdNumber: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Customer group ID"
customerGroupId: KundenGruppeKeySortInput @cost(weight: "10")
"Customer payment due date in days"
customerPaymentDueDateInDays: SortEnumType @cost(weight: "10")
"Deposit"
deposit: SortEnumType @cost(weight: "10")
"Cancelled sales invoice ID"
cancelledSalesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Delivery note count"
dropShippingDeliveryNoteCount: SortEnumType @cost(weight: "10")
}
input SalesInvoiceLineItemInternalFilterInput {
and: [SalesInvoiceLineItemInternalFilterInput!]
or: [SalesInvoiceLineItemInternalFilterInput!]
"Sales invoice identifier"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Sales invoice position identifier"
salesInvoicePositionId: ComparableRechnungPositionKeyOperationFilterInput
"Sales order identifier"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Item identifier"
itemId: ComparableArtikelKeyOperationFilterInput
"Parts list line item identifier"
billOfMaterialsSalesInvoiceLineItemId: ComparableRechnungPositionKeyOperationFilterInput
"Sales invoice line item identifier"
salesInvoiceLineItemId: ComparableRechnungPositionKeyOperationFilterInput
"Sales price gross"
salesPriceGross: ComparableDecimalOperationFilterInput
"Sales price net"
salesPriceNet: ComparableDecimalOperationFilterInput
"Invoice line item purchase price net"
purchasePriceNet: ComparableDecimalOperationFilterInput
"Item purchase price net"
itemPurchasePriceNet: ComparableNullableOfDecimalOperationFilterInput
"Invoice line item quantity"
quantity: ComparableDecimalOperationFilterInput
"Invoice line item name"
name: StringOperationFilterInput
"Stock keeping unit"
sku: StringOperationFilterInput
"Invoice line item Tax rate"
taxRate: ComparableDecimalOperationFilterInput
"Tax class identifier"
taxClassId: ComparableSteuerklasseKeyOperationFilterInput
"Invoice line item type"
invoiceLineItemType: ComparableByteOperationFilterInput
"Parent item identifier"
parentItemId: ComparableArtikelKeyOperationFilterInput
"Taric code"
taric: StringOperationFilterInput
"Item weight"
itemWeight: ComparableNullableOfDecimalOperationFilterInput
"Item volume"
itemVolume: ComparableNullableOfDecimalOperationFilterInput
"Product group identifier"
productGroupId: ComparableWarengruppeKeyOperationFilterInput
"Product group name"
productGroupName: StringOperationFilterInput
"Warehouse identifier"
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
input SalesInvoiceLineItemInternalSortInput {
"Sales invoice identifier"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Sales invoice position identifier"
salesInvoicePositionId: RechnungPositionKeySortInput @cost(weight: "10")
"Sales order identifier"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Item identifier"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Parts list line item identifier"
billOfMaterialsSalesInvoiceLineItemId: RechnungPositionKeySortInput @cost(weight: "10")
"Sales invoice line item identifier"
salesInvoiceLineItemId: RechnungPositionKeySortInput @cost(weight: "10")
"Sales price gross"
salesPriceGross: SortEnumType @cost(weight: "10")
"Sales price net"
salesPriceNet: SortEnumType @cost(weight: "10")
"Invoice line item purchase price net"
purchasePriceNet: SortEnumType @cost(weight: "10")
"Item purchase price net"
itemPurchasePriceNet: SortEnumType @cost(weight: "10")
"Invoice line item quantity"
quantity: SortEnumType @cost(weight: "10")
"Invoice line item name"
name: SortEnumType @cost(weight: "10")
"Stock keeping unit"
sku: SortEnumType @cost(weight: "10")
"Invoice line item Tax rate"
taxRate: SortEnumType @cost(weight: "10")
"Tax class identifier"
taxClassId: SteuerklasseKeySortInput @cost(weight: "10")
"Invoice line item type"
invoiceLineItemType: SortEnumType @cost(weight: "10")
"Parent item identifier"
parentItemId: ArtikelKeySortInput @cost(weight: "10")
"Taric code"
taric: SortEnumType @cost(weight: "10")
"Item weight"
itemWeight: SortEnumType @cost(weight: "10")
"Item volume"
itemVolume: SortEnumType @cost(weight: "10")
"Product group identifier"
productGroupId: WarengruppeKeySortInput @cost(weight: "10")
"Product group name"
productGroupName: SortEnumType @cost(weight: "10")
"Warehouse identifier"
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
"Single row of the sales invoices overview table"
input SalesInvoiceListItemFilterInput {
and: [SalesInvoiceListItemFilterInput!]
or: [SalesInvoiceListItemFilterInput!]
"Unique identifier of the sales invoice"
salesInvoiceId: ComparableRechnungKeyOperationFilterInput
"Created by user ID"
createdByUserId: ComparableBenutzerKeyOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Company ID"
companyId: ComparableFirmaKeyOperationFilterInput
"Company name"
companyName: StringOperationFilterInput
"The VAT ID of the merchant’s company that is shown on the invoice"
vatIdNumber: StringOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Indicates if dunning is blocked"
isDunningBlocked: ComparableBooleanOperationFilterInput
"Date when the invoice was created"
salesInvoiceDate: ComparableDateTimeOffsetOperationFilterInput
"Value date of the invoice"
valueDate: ComparableDateTimeOffsetOperationFilterInput
"Sales invoice number"
salesInvoiceNumber: StringOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Shipping method ID"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"Shipping method name"
shippingMethodName: StringOperationFilterInput
"Indicates if the invoice is a draft"
isDraft: ComparableBooleanOperationFilterInput
"Language ID"
languageId: ComparableSpracheKeyOperationFilterInput
"Tax setting value"
taxSetting: ComparableSalesInvoiceTaxSettingOperationFilterInput
"Indicates intra-community delivery"
isIntraCommunityDelivery: ComparableBooleanOperationFilterInput
"Indicates VAT exemption"
isExemptFromVat: ComparableBooleanOperationFilterInput
"Ebay username"
ebayUsername: StringOperationFilterInput
"Sales channel name"
salesChannelName: StringOperationFilterInput
"Indicates if invoice is external"
isExternalSalesInvoice: ComparableBooleanOperationFilterInput
"Indicates whether to print an existing invoice again"
printExistingSalesInvoice: ComparableBooleanOperationFilterInput
"Date when the invoice was paid"
paymentDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice was printed"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the invoice was sent via e-mail"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Indicates if the invoice has been dunned"
isDunned: ComparableBooleanOperationFilterInput
"Open amount still to pay"
stillToPay: ComparableDecimalOperationFilterInput
"Amount already paid"
alreadyPaidAmount: ComparableDecimalOperationFilterInput
"Indicates if the invoice is completely paid"
isCompletelyPaid: ComparableBooleanOperationFilterInput
"Internal comment"
comment: StringOperationFilterInput
"Additional comment"
customerComment: StringOperationFilterInput
"Total gross amount of credits related to this invoice"
salesInvoiceCorrectionTotalGrossAmount: ComparableDecimalOperationFilterInput
"Indicates if a sales invoice correction exists"
hasSalesInvoiceCorrection: ComparableBooleanOperationFilterInput
"Payment status of the invoice"
paymentStatus: ComparableInvoicePaymentStatusOperationFilterInput
"Shipment address company"
shipmentAddressCompanyName: StringOperationFilterInput
"Shipment address form of address"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment address title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment address first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street"
shipmentAddressStreet: StringOperationFilterInput
"The additional address line of the shipment address"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: StringOperationFilterInput
"Shipment address fax"
shipmentAddressFaxNumber: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"The additional company line of the shipment address"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address post ID"
shipmentAddressPostId: StringOperationFilterInput
"Shipment address state"
shipmentAddressState: StringOperationFilterInput
"Shipment address country ISO code"
shipmentAddressCountryIso: StringOperationFilterInput
"Billing address company name"
billingAddressCompanyName: StringOperationFilterInput
"The salutation of the billing address"
billingAddressSalutation: StringOperationFilterInput
"Billing address title"
billingAddressTitle: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street"
billingAddressStreet: StringOperationFilterInput
"The additional address line of the billing address"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: StringOperationFilterInput
"Billing address fax number"
billingAddressFaxNumber: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"The additional company line of the billing address"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address post ID"
billingAddressPostId: StringOperationFilterInput
"Billing address state"
billingAddressState: StringOperationFilterInput
"Billing address country ISO code"
billingAddressCountryIso: StringOperationFilterInput
"Total gross amount of the invoice"
totalGrossAmount: ComparableDecimalOperationFilterInput
"Total gross amount in shipping country currency"
shippingCountryTotalGrossAmount: ComparableDecimalOperationFilterInput
"Total net amount of the invoice"
totalNetAmount: ComparableDecimalOperationFilterInput
"Total net amount in shipping country currency"
shippingCountryTotalNetAmount: ComparableDecimalOperationFilterInput
"Name of the user who created the invoice"
createdByUserName: StringOperationFilterInput
"Customer number"
customerNumber: StringOperationFilterInput
"Accounts receivable number"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Customer group name"
customerGroupName: StringOperationFilterInput
"Payment due date in days"
paymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Payment due date"
paymentDueDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Dunning level"
dunningLevel: ComparableNullableOfInt32OperationFilterInput
"Date of last dunning"
dunningDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Indicates if the invoice is archived"
isArchived: ComparableBooleanOperationFilterInput
"Process colour code"
processColourCode: ComparableInt32OperationFilterInput
"Process colour name"
processColourName: StringOperationFilterInput
"Platform type"
platformType: ComparableInt32OperationFilterInput
"Sales order number"
salesOrderNumber: StringOperationFilterInput
"Indicates if the invoice has been corrected"
isCorrected: ComparableBooleanOperationFilterInput
"Indicates if the invoice is cancelled"
isCancelled: ComparableBooleanOperationFilterInput
"Date when the invoice was cancelled"
cancelledDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Cancellation comment"
cancellationComment: StringOperationFilterInput
"Name of the user who cancelled the invoice"
cancellationUserName: StringOperationFilterInput
"Cancellation reason"
cancellationReason: StringOperationFilterInput
"Related sales order ID"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"External sales order number"
externalSalesOrderNumber: StringOperationFilterInput
"Service date from (Leistungsdatum von) of the invoice"
serviceDateFrom: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Service date to (Leistungsdatum bis) of the invoice"
serviceDateTo: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date of last shipping related to the invoice"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
}
"Single row of the sales invoices overview table"
input SalesInvoiceListItemSortInput {
"Unique identifier of the sales invoice"
salesInvoiceId: RechnungKeySortInput @cost(weight: "10")
"Created by user ID"
createdByUserId: BenutzerKeySortInput @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"Company name"
companyName: SortEnumType @cost(weight: "10")
"The VAT ID of the merchant’s company that is shown on the invoice"
vatIdNumber: SortEnumType @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Indicates if dunning is blocked"
isDunningBlocked: SortEnumType @cost(weight: "10")
"Date when the invoice was created"
salesInvoiceDate: SortEnumType @cost(weight: "10")
"Value date of the invoice"
valueDate: SortEnumType @cost(weight: "10")
"Sales invoice number"
salesInvoiceNumber: SortEnumType @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Shipping method ID"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Shipping method name"
shippingMethodName: SortEnumType @cost(weight: "10")
"Indicates if the invoice is a draft"
isDraft: SortEnumType @cost(weight: "10")
"Language ID"
languageId: SpracheKeySortInput @cost(weight: "10")
"Tax setting value"
taxSetting: SortEnumType @cost(weight: "10")
"Indicates intra-community delivery"
isIntraCommunityDelivery: SortEnumType @cost(weight: "10")
"Indicates VAT exemption"
isExemptFromVat: SortEnumType @cost(weight: "10")
"Ebay username"
ebayUsername: SortEnumType @cost(weight: "10")
"Sales channel name"
salesChannelName: SortEnumType @cost(weight: "10")
"Indicates if invoice is external"
isExternalSalesInvoice: SortEnumType @cost(weight: "10")
"Indicates whether to print an existing invoice again"
printExistingSalesInvoice: SortEnumType @cost(weight: "10")
"Date when the invoice was paid"
paymentDate: SortEnumType @cost(weight: "10")
"Date when the invoice was printed"
printDate: SortEnumType @cost(weight: "10")
"Date when the invoice was sent via e-mail"
mailDate: SortEnumType @cost(weight: "10")
"Indicates if the invoice has been dunned"
isDunned: SortEnumType @cost(weight: "10")
"Open amount still to pay"
stillToPay: SortEnumType @cost(weight: "10")
"Amount already paid"
alreadyPaidAmount: SortEnumType @cost(weight: "10")
"Indicates if the invoice is completely paid"
isCompletelyPaid: SortEnumType @cost(weight: "10")
"Internal comment"
comment: SortEnumType @cost(weight: "10")
"Additional comment"
customerComment: SortEnumType @cost(weight: "10")
"Total gross amount of credits related to this invoice"
salesInvoiceCorrectionTotalGrossAmount: SortEnumType @cost(weight: "10")
"Indicates if a sales invoice correction exists"
hasSalesInvoiceCorrection: SortEnumType @cost(weight: "10")
"Payment status of the invoice"
paymentStatus: SortEnumType @cost(weight: "10")
"Shipment address company"
shipmentAddressCompanyName: SortEnumType @cost(weight: "10")
"Shipment address form of address"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment address title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment address first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"The additional address line of the shipment address"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax"
shipmentAddressFaxNumber: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"The additional company line of the shipment address"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address post ID"
shipmentAddressPostId: SortEnumType @cost(weight: "10")
"Shipment address state"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Shipment address country ISO code"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Billing address company name"
billingAddressCompanyName: SortEnumType @cost(weight: "10")
"The salutation of the billing address"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Billing address title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"The additional address line of the billing address"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax number"
billingAddressFaxNumber: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"The additional company line of the billing address"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address post ID"
billingAddressPostId: SortEnumType @cost(weight: "10")
"Billing address state"
billingAddressState: SortEnumType @cost(weight: "10")
"Billing address country ISO code"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Total gross amount of the invoice"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total gross amount in shipping country currency"
shippingCountryTotalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount of the invoice"
totalNetAmount: SortEnumType @cost(weight: "10")
"Total net amount in shipping country currency"
shippingCountryTotalNetAmount: SortEnumType @cost(weight: "10")
"Name of the user who created the invoice"
createdByUserName: SortEnumType @cost(weight: "10")
"Customer number"
customerNumber: SortEnumType @cost(weight: "10")
"Accounts receivable number"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Customer group name"
customerGroupName: SortEnumType @cost(weight: "10")
"Payment due date in days"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Payment due date"
paymentDueDate: SortEnumType @cost(weight: "10")
"Dunning level"
dunningLevel: SortEnumType @cost(weight: "10")
"Date of last dunning"
dunningDate: SortEnumType @cost(weight: "10")
"Indicates if the invoice is archived"
isArchived: SortEnumType @cost(weight: "10")
"Process colour code"
processColourCode: SortEnumType @cost(weight: "10")
"Process colour name"
processColourName: SortEnumType @cost(weight: "10")
"Platform type"
platformType: SortEnumType @cost(weight: "10")
"Sales order number"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Indicates if the invoice has been corrected"
isCorrected: SortEnumType @cost(weight: "10")
"Indicates if the invoice is cancelled"
isCancelled: SortEnumType @cost(weight: "10")
"Date when the invoice was cancelled"
cancelledDate: SortEnumType @cost(weight: "10")
"Cancellation comment"
cancellationComment: SortEnumType @cost(weight: "10")
"Name of the user who cancelled the invoice"
cancellationUserName: SortEnumType @cost(weight: "10")
"Cancellation reason"
cancellationReason: SortEnumType @cost(weight: "10")
"Related sales order ID"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"External sales order number"
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"Service date from (Leistungsdatum von) of the invoice"
serviceDateFrom: SortEnumType @cost(weight: "10")
"Service date to (Leistungsdatum bis) of the invoice"
serviceDateTo: SortEnumType @cost(weight: "10")
"Date of last shipping related to the invoice"
lastShippingDate: SortEnumType @cost(weight: "10")
}
"Single row of the salesorder overview table"
input SalesOrderListItemFilterInput {
and: [SalesOrderListItemFilterInput!]
or: [SalesOrderListItemFilterInput!]
"Sales order id"
id: ComparableVerkaufAuftragKeyOperationFilterInput
"The SalesOrder AccountsReceivableNumber"
accountsReceivableNumber: ComparableNullableOfInt32OperationFilterInput
"Assigned user ID"
assignedUserId: ComparableBenutzerKeyOperationFilterInput
"Company name"
companyName: StringOperationFilterInput
"Created by user ID"
createdByUserId: ComparableBenutzerKeyOperationFilterInput
"Currency factor"
currencyFactor: ComparableDecimalOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"The SalesOrder CustomerNumber"
customerNumber: StringOperationFilterInput
"The SalesOrder DeliveryCompleteStatus"
deliveryCompleteStatus: ComparableDeliveryCompleteStatusOperationFilterInput
"The SalesOrder CountryISO"
departureCountryIso: StringOperationFilterInput
"The SalesOrder CurrencyFactor"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"The SalesOrder CurrencyISO"
departureCountryCurrencyIso: StringOperationFilterInput
"The SalesOrder EbayUsername"
ebayUsername: StringOperationFilterInput
"The SalesOrder"
estimatedDeliveryDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The SalesOrder ExternalInvoiceType"
externalSalesInvoiceType: ComparableExternalSalesInvoiceTypeOperationFilterInput
"The SalesOrder"
externalSalesOrderNumber: StringOperationFilterInput
"The SalesOrder ExtraWeight"
extraWeight: ComparableDecimalOperationFilterInput
"SpacialTaxTreatment IntraCommunityDelivery"
isIntraCommunityDelivery: ComparableBooleanOperationFilterInput
"Indicates if the order is cancelled"
isCancelled: ComparableBooleanOperationFilterInput
"Indicates if the order is pending"
isPending: ComparableBooleanOperationFilterInput
"Item description type"
itemDescriptionType: ComparableItemDescriptionTypeOperationFilterInput
"Language ISO code"
languageIso: StringOperationFilterInput
"The latest SalesOrder ShippingDate"
lastShippingDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"The SalesOrder NeedsOnlineSynchronization"
needsOnlineSynchronisation: ComparableBooleanOperationFilterInput
"On hold reason ID"
onHoldReasonId: ComparableRueckhaltegrundKeyOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: ComparableNullableOfInt32OperationFilterInput
"Process colour code"
processColourCode: ComparableNullableOfInt32OperationFilterInput
"Process colour name"
processColourName: StringOperationFilterInput
"Process status name"
processStatusName: StringOperationFilterInput
"Read only type indicator"
readOnlyType: ComparableReadOnlyTypeOperationFilterInput
"The date when the order was created"
salesOrderDate: ComparableDateTimeOffsetOperationFilterInput
"The SalesOrder SalesOrderNumber"
salesOrderNumber: StringOperationFilterInput
"Sales order status"
salesOrderStatus: ComparableByteOperationFilterInput
"Shipping method ID"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"The SalesOrder ShippingPriority"
shippingPriority: ComparableInt32OperationFilterInput
"The SalesOrder ShopPaymentModule"
shopPaymentModule: StringOperationFilterInput
"The SalesOrder TaxSetting"
taxSetting: ComparableNullableOfTaxSettingOperationFilterInput
"The total gross amount of the order"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"SpacialTaxTreatment VATFree"
isExemptFromVat: ComparableBooleanOperationFilterInput
"The company ID"
companyId: ComparableFirmaKeyOperationFilterInput
"The internet order ID"
onlineSalesOrderId: ComparableNullableOfInt32OperationFilterInput
"Comment\/Annotation"
comment: StringOperationFilterInput
"Print date"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Mail date"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Payment mail date"
paymentMailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date of payment"
dateOfPayment: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Payment date"
paymentDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"On hold reason name"
onHoldReasonName: StringOperationFilterInput
"Sales invoice status"
salesInvoiceStatus: ComparableInvoiceStatusOperationFilterInput
"Billing address company"
billingAddressCompany: StringOperationFilterInput
"Billing address additional company line"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address salutation"
billingAddressSalutation: StringOperationFilterInput
"Billing address title"
billingAddressTitle: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street"
billingAddressStreet: StringOperationFilterInput
"Billing address additional address line"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: StringOperationFilterInput
"Billing address fax"
billingAddressFax: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"Billing address post ID"
billingAddressPostId: StringOperationFilterInput
"Billing address state"
billingAddressState: StringOperationFilterInput
"Billing address country ISO"
billingAddressCountryIso: StringOperationFilterInput
"Shipment address company"
shipmentAddressCompany: StringOperationFilterInput
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address salutation"
shipmentAddressSalutation: StringOperationFilterInput
"Shipment address title"
shipmentAddressTitle: StringOperationFilterInput
"Shipment address first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street"
shipmentAddressStreet: StringOperationFilterInput
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: StringOperationFilterInput
"Shipment address fax"
shipmentAddressFax: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"Shipment address post ID"
shipmentAddressPostId: StringOperationFilterInput
"Shipment address state"
shipmentAddressState: StringOperationFilterInput
"Shipment address country ISO"
shipmentAddressCountryIso: StringOperationFilterInput
"Assigned user name"
assignedUserName: StringOperationFilterInput
"Sales channel name"
salesChannelName: StringOperationFilterInput
"Customer group name"
customerGroupName: StringOperationFilterInput
"Payment method name"
paymentMethodName: StringOperationFilterInput
"Shipping method name"
shippingMethodName: StringOperationFilterInput
"Shipping country total gross amount"
shippingCountryTotalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Customer comment"
customerComment: StringOperationFilterInput
"Payment reference"
paymentReference: StringOperationFilterInput
"Credits total gross amount"
salesInvoiceCorrectionTotalGrossAmount: ComparableDecimalOperationFilterInput
"Already paid amount"
alreadyPaidAmount: ComparableDecimalOperationFilterInput
"Still to pay amount"
stillToPay: ComparableNullableOfDecimalOperationFilterInput
"Total net amount"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"WMS locked"
wmsLocked: ComparableNullableOfByteOperationFilterInput
"WMS partial shipment"
wmsPartialShipment: ComparableNullableOfInt32OperationFilterInput
"WMS pre picking"
wmsPrePicking: ComparableNullableOfInt32OperationFilterInput
"Payment status"
paymentStatus: ComparableInvoicePaymentStatusOperationFilterInput
"Delivery status"
deliveryStatus: ComparableDeliveryStatusOperationFilterInput
"Platform type"
platformType: ComparableInt32OperationFilterInput
"Sales invoice numbers"
salesInvoiceNumbers: StringOperationFilterInput
"Cancelled date"
cancelledDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Cancellation comment"
cancellationComment: StringOperationFilterInput
"Cancellation user name"
cancellationUserName: StringOperationFilterInput
"Cancellation reason"
cancellationReason: StringOperationFilterInput
"Amazon user ID"
amazonUserId: ComparableNullableOfInt32OperationFilterInput
"Created by user name"
createdByUserName: StringOperationFilterInput
}
"Single row of the salesorder overview table"
input SalesOrderListItemSortInput {
"Sales order id"
id: VerkaufAuftragKeySortInput @cost(weight: "10")
"The SalesOrder AccountsReceivableNumber"
accountsReceivableNumber: SortEnumType @cost(weight: "10")
"Assigned user ID"
assignedUserId: BenutzerKeySortInput @cost(weight: "10")
"Company name"
companyName: SortEnumType @cost(weight: "10")
"Created by user ID"
createdByUserId: BenutzerKeySortInput @cost(weight: "10")
"Currency factor"
currencyFactor: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"The SalesOrder CustomerNumber"
customerNumber: SortEnumType @cost(weight: "10")
"The SalesOrder DeliveryCompleteStatus"
deliveryCompleteStatus: SortEnumType @cost(weight: "10")
"The SalesOrder CountryISO"
departureCountryIso: SortEnumType @cost(weight: "10")
"The SalesOrder CurrencyFactor"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"The SalesOrder CurrencyISO"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"The SalesOrder EbayUsername"
ebayUsername: SortEnumType @cost(weight: "10")
"The SalesOrder"
estimatedDeliveryDate: SortEnumType @cost(weight: "10")
"The SalesOrder ExternalInvoiceType"
externalSalesInvoiceType: SortEnumType @cost(weight: "10")
"The SalesOrder"
externalSalesOrderNumber: SortEnumType @cost(weight: "10")
"The SalesOrder ExtraWeight"
extraWeight: SortEnumType @cost(weight: "10")
"SpacialTaxTreatment IntraCommunityDelivery"
isIntraCommunityDelivery: SortEnumType @cost(weight: "10")
"Indicates if the order is cancelled"
isCancelled: SortEnumType @cost(weight: "10")
"Indicates if the order is pending"
isPending: SortEnumType @cost(weight: "10")
"Item description type"
itemDescriptionType: SortEnumType @cost(weight: "10")
"Language ISO code"
languageIso: SortEnumType @cost(weight: "10")
"The latest SalesOrder ShippingDate"
lastShippingDate: SortEnumType @cost(weight: "10")
"The SalesOrder NeedsOnlineSynchronization"
needsOnlineSynchronisation: SortEnumType @cost(weight: "10")
"On hold reason ID"
onHoldReasonId: RueckhaltegrundKeySortInput @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: SortEnumType @cost(weight: "10")
"Process colour code"
processColourCode: SortEnumType @cost(weight: "10")
"Process colour name"
processColourName: SortEnumType @cost(weight: "10")
"Process status name"
processStatusName: SortEnumType @cost(weight: "10")
"Read only type indicator"
readOnlyType: SortEnumType @cost(weight: "10")
"The date when the order was created"
salesOrderDate: SortEnumType @cost(weight: "10")
"The SalesOrder SalesOrderNumber"
salesOrderNumber: SortEnumType @cost(weight: "10")
"Sales order status"
salesOrderStatus: SortEnumType @cost(weight: "10")
"Shipping method ID"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"The SalesOrder ShippingPriority"
shippingPriority: SortEnumType @cost(weight: "10")
"The SalesOrder ShopPaymentModule"
shopPaymentModule: SortEnumType @cost(weight: "10")
"The SalesOrder TaxSetting"
taxSetting: SortEnumType @cost(weight: "10")
"The total gross amount of the order"
totalGrossAmount: SortEnumType @cost(weight: "10")
"SpacialTaxTreatment VATFree"
isExemptFromVat: SortEnumType @cost(weight: "10")
"The company ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"The internet order ID"
onlineSalesOrderId: SortEnumType @cost(weight: "10")
"Comment\/Annotation"
comment: SortEnumType @cost(weight: "10")
"Print date"
printDate: SortEnumType @cost(weight: "10")
"Mail date"
mailDate: SortEnumType @cost(weight: "10")
"Payment mail date"
paymentMailDate: SortEnumType @cost(weight: "10")
"Date of payment"
dateOfPayment: SortEnumType @cost(weight: "10")
"Payment date"
paymentDate: SortEnumType @cost(weight: "10")
"On hold reason name"
onHoldReasonName: SortEnumType @cost(weight: "10")
"Sales invoice status"
salesInvoiceStatus: SortEnumType @cost(weight: "10")
"Billing address company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Billing address additional company line"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address salutation"
billingAddressSalutation: SortEnumType @cost(weight: "10")
"Billing address title"
billingAddressTitle: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Billing address additional address line"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address mobile phone number"
billingAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax"
billingAddressFax: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Billing address post ID"
billingAddressPostId: SortEnumType @cost(weight: "10")
"Billing address state"
billingAddressState: SortEnumType @cost(weight: "10")
"Billing address country ISO"
billingAddressCountryIso: SortEnumType @cost(weight: "10")
"Shipment address company"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment address additional company line"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address salutation"
shipmentAddressSalutation: SortEnumType @cost(weight: "10")
"Shipment address title"
shipmentAddressTitle: SortEnumType @cost(weight: "10")
"Shipment address first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment address additional address line"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address mobile phone number"
shipmentAddressMobilePhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax"
shipmentAddressFax: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"Shipment address post ID"
shipmentAddressPostId: SortEnumType @cost(weight: "10")
"Shipment address state"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Shipment address country ISO"
shipmentAddressCountryIso: SortEnumType @cost(weight: "10")
"Assigned user name"
assignedUserName: SortEnumType @cost(weight: "10")
"Sales channel name"
salesChannelName: SortEnumType @cost(weight: "10")
"Customer group name"
customerGroupName: SortEnumType @cost(weight: "10")
"Payment method name"
paymentMethodName: SortEnumType @cost(weight: "10")
"Shipping method name"
shippingMethodName: SortEnumType @cost(weight: "10")
"Shipping country total gross amount"
shippingCountryTotalGrossAmount: SortEnumType @cost(weight: "10")
"Customer comment"
customerComment: SortEnumType @cost(weight: "10")
"Payment reference"
paymentReference: SortEnumType @cost(weight: "10")
"Credits total gross amount"
salesInvoiceCorrectionTotalGrossAmount: SortEnumType @cost(weight: "10")
"Already paid amount"
alreadyPaidAmount: SortEnumType @cost(weight: "10")
"Still to pay amount"
stillToPay: SortEnumType @cost(weight: "10")
"Total net amount"
totalNetAmount: SortEnumType @cost(weight: "10")
"WMS locked"
wmsLocked: SortEnumType @cost(weight: "10")
"WMS partial shipment"
wmsPartialShipment: SortEnumType @cost(weight: "10")
"WMS pre picking"
wmsPrePicking: SortEnumType @cost(weight: "10")
"Payment status"
paymentStatus: SortEnumType @cost(weight: "10")
"Delivery status"
deliveryStatus: SortEnumType @cost(weight: "10")
"Platform type"
platformType: SortEnumType @cost(weight: "10")
"Sales invoice numbers"
salesInvoiceNumbers: SortEnumType @cost(weight: "10")
"Cancelled date"
cancelledDate: SortEnumType @cost(weight: "10")
"Cancellation comment"
cancellationComment: SortEnumType @cost(weight: "10")
"Cancellation user name"
cancellationUserName: SortEnumType @cost(weight: "10")
"Cancellation reason"
cancellationReason: SortEnumType @cost(weight: "10")
"Amazon user ID"
amazonUserId: SortEnumType @cost(weight: "10")
"Created by user name"
createdByUserName: SortEnumType @cost(weight: "10")
}
"Single row of the sales quotation overview table"
input SalesQuotationListItemFilterInput {
and: [SalesQuotationListItemFilterInput!]
or: [SalesQuotationListItemFilterInput!]
"Sales quotation unique identifier"
id: ComparableVerkaufAuftragKeyOperationFilterInput
"Assigned user ID"
assignedUserId: ComparableBenutzerKeyOperationFilterInput
"Customer ID"
customerId: ComparableKundeKeyOperationFilterInput
"Shipping method ID"
shippingMethodId: ComparableVersandartKeyOperationFilterInput
"Company (firm) ID"
companyId: ComparableFirmaKeyOperationFilterInput
"Payment method ID"
paymentMethodId: ComparableZahlungsartKeyOperationFilterInput
"Official sales quotation number"
salesQuotationNumber: StringOperationFilterInput
"External reference number for the quotation"
externalSalesQuotationNumber: StringOperationFilterInput
"Name of the platform where the quotation originated"
platformName: StringOperationFilterInput
"Internal comments or remarks"
comment: StringOperationFilterInput
"ISO currency code used for the quotation"
currencyIso: StringOperationFilterInput
"Exchange rate factor for the currency"
currencyFactor: ComparableDecimalOperationFilterInput
"Date when the quotation was printed"
printDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Date when the quotation was sent via email"
mailDate: ComparableNullableOfDateTimeOffsetOperationFilterInput
"Display text for the current process status"
processStatusName: StringOperationFilterInput
"Additional weight calculated for the quotation"
extraWeight: ComparableDecimalOperationFilterInput
"Total shipping weight"
shippingWeight: ComparableDecimalOperationFilterInput
"Date and time when the quotation was created"
salesQuotationDate: ComparableDateTimeOffsetOperationFilterInput
"ISO code of the departure\/shipping country"
departureCountryIso: StringOperationFilterInput
"Name of the departure\/shipping country"
departureCountryName: StringOperationFilterInput
"Currency ISO code of the departure country"
departureCountryCurrencyIso: StringOperationFilterInput
"Currency exchange factor of the departure country"
departureCountryCurrencyFactor: ComparableDecimalOperationFilterInput
"Billing address company"
billingAddressCompany: StringOperationFilterInput
"Billing address first name"
billingAddressFirstName: StringOperationFilterInput
"Billing address last name"
billingAddressLastName: StringOperationFilterInput
"Billing address street and house number"
billingAddressStreet: StringOperationFilterInput
"Billing address additional address line (e.g., apartment, suite)"
billingAddressAdditionalAddressLine: StringOperationFilterInput
"Billing address postal code"
billingAddressPostalCode: StringOperationFilterInput
"Billing address city"
billingAddressCity: StringOperationFilterInput
"Billing address country name"
billingAddressCountryName: StringOperationFilterInput
"Billing address phone number"
billingAddressPhoneNumber: StringOperationFilterInput
"Billing address fax number"
billingAddressFax: StringOperationFilterInput
"Billing address email address"
billingAddressEmailAddress: StringOperationFilterInput
"Billing address additional company information line"
billingAddressAdditionalCompanyLine: StringOperationFilterInput
"Billing address state or province"
billingAddressState: StringOperationFilterInput
"Shipment address company name"
shipmentAddressCompany: StringOperationFilterInput
"Shipment address contact first name"
shipmentAddressFirstName: StringOperationFilterInput
"Shipment address contact last name"
shipmentAddressLastName: StringOperationFilterInput
"Shipment address street and house number"
shipmentAddressStreet: StringOperationFilterInput
"Shipment address additional address line (e.g., apartment, suite)"
shipmentAddressAdditionalAddressLine: StringOperationFilterInput
"Shipment address postal code"
shipmentAddressPostalCode: StringOperationFilterInput
"Shipment address city"
shipmentAddressCity: StringOperationFilterInput
"Shipment address country name"
shipmentAddressCountryName: StringOperationFilterInput
"Shipment address phone number"
shipmentAddressPhoneNumber: StringOperationFilterInput
"Shipment address fax number"
shipmentAddressFax: StringOperationFilterInput
"Shipment address email address"
shipmentAddressEmailAddress: StringOperationFilterInput
"Shipment address additional company information line"
shipmentAddressAdditionalCompanyLine: StringOperationFilterInput
"Shipment address state or province"
shipmentAddressState: StringOperationFilterInput
"Name of the user currently assigned to this quotation"
assignedUserName: StringOperationFilterInput
"Name of the user who originally created the quotation"
createdByUserName: StringOperationFilterInput
"Display name of the company"
companyName: StringOperationFilterInput
"Name of the sales channel or shop"
salesChannelName: StringOperationFilterInput
"Name of the assigned customer group"
customerGroupName: StringOperationFilterInput
"Display name of the selected payment method"
paymentMethodName: StringOperationFilterInput
"Display name of the selected shipping method"
shippingMethodName: StringOperationFilterInput
"Unique customer business number"
customerNumber: StringOperationFilterInput
"Total gross amount in the system's base currency"
totalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount in the system's base currency"
totalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Total gross amount converted to the shipping country's currency"
shippingCountryTotalGrossAmount: ComparableNullableOfDecimalOperationFilterInput
"Total net amount converted to the shipping country's currency"
shippingCountryTotalNetAmount: ComparableNullableOfDecimalOperationFilterInput
"Additional customer-related notes or miscellaneous instructions"
customerComment: StringOperationFilterInput
"ARGB or numeric color code for process highlighting"
processColourCode: ComparableNullableOfInt32OperationFilterInput
"Descriptive name of the assigned process color"
processColourName: StringOperationFilterInput
}
"Single row of the sales quotation overview table"
input SalesQuotationListItemSortInput {
"Sales quotation unique identifier"
id: VerkaufAuftragKeySortInput @cost(weight: "10")
"Assigned user ID"
assignedUserId: BenutzerKeySortInput @cost(weight: "10")
"Customer ID"
customerId: KundeKeySortInput @cost(weight: "10")
"Shipping method ID"
shippingMethodId: VersandartKeySortInput @cost(weight: "10")
"Company (firm) ID"
companyId: FirmaKeySortInput @cost(weight: "10")
"Payment method ID"
paymentMethodId: ZahlungsartKeySortInput @cost(weight: "10")
"Official sales quotation number"
salesQuotationNumber: SortEnumType @cost(weight: "10")
"External reference number for the quotation"
externalSalesQuotationNumber: SortEnumType @cost(weight: "10")
"Name of the platform where the quotation originated"
platformName: SortEnumType @cost(weight: "10")
"Internal comments or remarks"
comment: SortEnumType @cost(weight: "10")
"ISO currency code used for the quotation"
currencyIso: SortEnumType @cost(weight: "10")
"Exchange rate factor for the currency"
currencyFactor: SortEnumType @cost(weight: "10")
"Date when the quotation was printed"
printDate: SortEnumType @cost(weight: "10")
"Date when the quotation was sent via email"
mailDate: SortEnumType @cost(weight: "10")
"Display text for the current process status"
processStatusName: SortEnumType @cost(weight: "10")
"Additional weight calculated for the quotation"
extraWeight: SortEnumType @cost(weight: "10")
"Total shipping weight"
shippingWeight: SortEnumType @cost(weight: "10")
"Date and time when the quotation was created"
salesQuotationDate: SortEnumType @cost(weight: "10")
"ISO code of the departure\/shipping country"
departureCountryIso: SortEnumType @cost(weight: "10")
"Name of the departure\/shipping country"
departureCountryName: SortEnumType @cost(weight: "10")
"Currency ISO code of the departure country"
departureCountryCurrencyIso: SortEnumType @cost(weight: "10")
"Currency exchange factor of the departure country"
departureCountryCurrencyFactor: SortEnumType @cost(weight: "10")
"Billing address company"
billingAddressCompany: SortEnumType @cost(weight: "10")
"Billing address first name"
billingAddressFirstName: SortEnumType @cost(weight: "10")
"Billing address last name"
billingAddressLastName: SortEnumType @cost(weight: "10")
"Billing address street and house number"
billingAddressStreet: SortEnumType @cost(weight: "10")
"Billing address additional address line (e.g., apartment, suite)"
billingAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Billing address postal code"
billingAddressPostalCode: SortEnumType @cost(weight: "10")
"Billing address city"
billingAddressCity: SortEnumType @cost(weight: "10")
"Billing address country name"
billingAddressCountryName: SortEnumType @cost(weight: "10")
"Billing address phone number"
billingAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Billing address fax number"
billingAddressFax: SortEnumType @cost(weight: "10")
"Billing address email address"
billingAddressEmailAddress: SortEnumType @cost(weight: "10")
"Billing address additional company information line"
billingAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Billing address state or province"
billingAddressState: SortEnumType @cost(weight: "10")
"Shipment address company name"
shipmentAddressCompany: SortEnumType @cost(weight: "10")
"Shipment address contact first name"
shipmentAddressFirstName: SortEnumType @cost(weight: "10")
"Shipment address contact last name"
shipmentAddressLastName: SortEnumType @cost(weight: "10")
"Shipment address street and house number"
shipmentAddressStreet: SortEnumType @cost(weight: "10")
"Shipment address additional address line (e.g., apartment, suite)"
shipmentAddressAdditionalAddressLine: SortEnumType @cost(weight: "10")
"Shipment address postal code"
shipmentAddressPostalCode: SortEnumType @cost(weight: "10")
"Shipment address city"
shipmentAddressCity: SortEnumType @cost(weight: "10")
"Shipment address country name"
shipmentAddressCountryName: SortEnumType @cost(weight: "10")
"Shipment address phone number"
shipmentAddressPhoneNumber: SortEnumType @cost(weight: "10")
"Shipment address fax number"
shipmentAddressFax: SortEnumType @cost(weight: "10")
"Shipment address email address"
shipmentAddressEmailAddress: SortEnumType @cost(weight: "10")
"Shipment address additional company information line"
shipmentAddressAdditionalCompanyLine: SortEnumType @cost(weight: "10")
"Shipment address state or province"
shipmentAddressState: SortEnumType @cost(weight: "10")
"Name of the user currently assigned to this quotation"
assignedUserName: SortEnumType @cost(weight: "10")
"Name of the user who originally created the quotation"
createdByUserName: SortEnumType @cost(weight: "10")
"Display name of the company"
companyName: SortEnumType @cost(weight: "10")
"Name of the sales channel or shop"
salesChannelName: SortEnumType @cost(weight: "10")
"Name of the assigned customer group"
customerGroupName: SortEnumType @cost(weight: "10")
"Display name of the selected payment method"
paymentMethodName: SortEnumType @cost(weight: "10")
"Display name of the selected shipping method"
shippingMethodName: SortEnumType @cost(weight: "10")
"Unique customer business number"
customerNumber: SortEnumType @cost(weight: "10")
"Total gross amount in the system's base currency"
totalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount in the system's base currency"
totalNetAmount: SortEnumType @cost(weight: "10")
"Total gross amount converted to the shipping country's currency"
shippingCountryTotalGrossAmount: SortEnumType @cost(weight: "10")
"Total net amount converted to the shipping country's currency"
shippingCountryTotalNetAmount: SortEnumType @cost(weight: "10")
"Additional customer-related notes or miscellaneous instructions"
customerComment: SortEnumType @cost(weight: "10")
"ARGB or numeric color code for process highlighting"
processColourCode: SortEnumType @cost(weight: "10")
"Descriptive name of the assigned process color"
processColourName: SortEnumType @cost(weight: "10")
}
"Batch saves the entire tax configuration in a single transaction. Zones with an Id are updated, zones without an Id are created, and zones in the database but not in the list are deleted. - Request"
input SaveTaxConfigurationCommandRequestInput {
"The complete list of tax zones representing the desired state. The system will diff this against the current database state and derive create, update, and delete operations."
taxZones: [SaveTaxConfigurationTaxZoneInput!]!
}
"Represents a tax rate key assignment in the batch save. Identified by composite key (ProductGroupId, ShippingMethodId, LineItemType)."
input SaveTaxConfigurationTaxRateAssignmentInput {
"The product group ID."
productGroupId: ID
"The shipping method ID."
shippingMethodId: ID
"The line item type."
lineItemType: TaxLineItemType!
"The main tax code (Steuerschlüssel)."
taxCodeId: ID
"The intra-community delivery tax code."
intraCommunityDeliveryTaxCodeId: ID
"The tax code for shipments from EU to non-EU countries (exempt from VAT, not EU)."
exemptFromVatNotEuTaxCodeId: ID
"The reverse charge tax code."
reverseChargeTaxCodeId: ID
}
"Represents a tax rate in the batch save. If Id is set the rate is updated; if null a new rate is created. Rates in the database but not in the list are deleted."
input SaveTaxConfigurationTaxRateInput {
"The ID of an existing tax rate to update. Null to create a new rate."
id: ID
"The tax class this rate applies to."
taxClassId: ID
"The VAT rate as a decimal value (e.g. 19.0 for 19%). Required on create."
vatRate: Decimal
"The main tax code (Steuerschlüssel)."
taxCodeId: ID
"The intra-community delivery tax code."
intraCommunityDeliveryTaxCodeId: ID
"The tax code for shipments from EU to non-EU countries (exempt from VAT, not EU)."
exemptFromVatNotEuTaxCodeId: ID
"The reverse charge tax code."
reverseChargeTaxCodeId: ID
"The complete list of tax rate key assignments for this rate. Keys in the database but not in this list are deleted."
taxRateAssignments: [SaveTaxConfigurationTaxRateAssignmentInput!]!
}
"Represents a country assignment for a tax zone in the batch save."
input SaveTaxConfigurationTaxZoneCountryInput {
"The ISO country code."
countryIso: String!
"The state or province code within the country."
stateCode: String
}
"Represents a tax zone in the batch save. If Id is set the zone is updated; if null a new zone is created. Zones in the database but not in the list are deleted."
input SaveTaxConfigurationTaxZoneInput {
"The ID of an existing tax zone to update. Null to create a new zone."
id: ID
"The company this tax zone belongs to. Required on create."
companyId: ID
"The name of the tax zone."
name: String
"The ISO code of the departure country this zone is associated with. Required."
departureCountryIso: String
"The source for VAT ID resolution in B2B transactions."
vatIdB2B: VatIdSource
"The source for VAT ID resolution in B2C transactions."
vatIdB2C: VatIdSource
"The complete list of country assignments for this zone. Countries in the database but not in this list are removed."
countries: [SaveTaxConfigurationTaxZoneCountryInput!]!
"The complete list of tax rates for this zone. Rates with an Id are updated, rates without an Id are created, and rates in the database but not in this list are deleted."
taxRates: [SaveTaxConfigurationTaxRateInput!]!
}
"Represents a key for a SCX channel."
input ScxChannelKeySortInput {
"Gets the database identifier for the SCX channel."
channelId: SortEnumType @cost(weight: "10")
}
"Represents a key for a ScxShop entity."
input ScxShopKeySortInput {
"Gets the database identifier for the ScxShop."
scxShopId: SortEnumType @cost(weight: "10")
}
"Single Row of the serial number query"
input SerialNumberListItemFilterInput {
and: [SerialNumberListItemFilterInput!]
or: [SerialNumberListItemFilterInput!]
"Id of the Warehouse."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Id of the item."
itemId: ComparableArtikelKeyOperationFilterInput
"Serial numbers of the item."
serialNumber: StringOperationFilterInput
"Indicates if the serial number is active."
isActive: ComparableBooleanOperationFilterInput
}
"Single Row of the serial number query"
input SerialNumberListItemSortInput {
"Id of the Warehouse."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
"Id of the storage location if the warehouse type is JTL-WMS."
storageLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Id of the item."
itemId: ArtikelKeySortInput @cost(weight: "10")
"Serial numbers of the item."
serialNumber: SortEnumType @cost(weight: "10")
"Indicates if the serial number is active."
isActive: SortEnumType @cost(weight: "10")
}
"Sets the maximum stock quantity for the specified marketplace offers. - Request"
input SetMarketplaceOfferMaxQuantityCommandRequestInput {
"Marketplace offer keys to update."
offerKeys: [ID]!
"Maximum stock quantity to set for each specified marketplace offer."
maxQuantity: Decimal!
}
"Sets the minimum stock quantity for the specified marketplace offers. - Request"
input SetMarketplaceOfferMinQuantityCommandRequestInput {
"Marketplace offer keys to update."
offerKeys: [ID]!
"Minimum stock quantity to set for each specified marketplace offer."
minQuantity: Decimal!
}
"Single row of the shipping boxes overview list."
input ShippingBoxListItemFilterInput {
and: [ShippingBoxListItemFilterInput!]
or: [ShippingBoxListItemFilterInput!]
"Shipping box identifier."
id: ComparableLhmKeyOperationFilterInput
"Display name of the shipping box."
displayId: StringOperationFilterInput
"Box type identifier (nullable in DB)."
typeId: ComparableLhmTypeKeyOperationFilterInput
"Assigned bin location (can be 0 or null in DB)."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
"Parent warehouse."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Lock status (false=unlocked, true=locked). Nullable in database."
locked: ComparableBooleanOperationFilterInput
}
"Single row of the shipping boxes overview list."
input ShippingBoxListItemSortInput {
"Shipping box identifier."
id: LhmKeySortInput @cost(weight: "10")
"Display name of the shipping box."
displayId: SortEnumType @cost(weight: "10")
"Box type identifier (nullable in DB)."
typeId: LhmTypeKeySortInput @cost(weight: "10")
"Lock status (false=unlocked, true=locked). Nullable in database."
locked: SortEnumType @cost(weight: "10")
}
"Reference data describing an available shipping box type."
input ShippingBoxTypeFilterInput {
and: [ShippingBoxTypeFilterInput!]
or: [ShippingBoxTypeFilterInput!]
"Box type identifier."
value: ComparableLhmTypeKeyOperationFilterInput
"Display name for the box type."
name: StringOperationFilterInput
}
"Reference data describing an available shipping box type."
input ShippingBoxTypeSortInput {
"Box type identifier."
value: LhmTypeKeySortInput @cost(weight: "10")
"Display name for the box type."
name: SortEnumType @cost(weight: "10")
}
"Single row of the shipping class overview"
input ShippingClassListItemFilterInput {
and: [ShippingClassListItemFilterInput!]
or: [ShippingClassListItemFilterInput!]
"ShippingClass id"
id: ComparableVersandklasseKeyOperationFilterInput
}
"Single row of the shipping class overview"
input ShippingClassListItemSortInput {
"ShippingClass id"
id: VersandklasseKeySortInput @cost(weight: "10")
}
"Single Row of the shipping method lookup"
input ShippingMethodLookupItemFilterInput {
and: [ShippingMethodLookupItemFilterInput!]
or: [ShippingMethodLookupItemFilterInput!]
"Id of the shipping method."
id: ComparableVersandartKeyOperationFilterInput
"Default Category Name"
name: StringOperationFilterInput
"Is the shipping method active"
isActive: ComparableBooleanOperationFilterInput
}
"Single Row of the shipping method lookup"
input ShippingMethodLookupItemSortInput {
"Id of the shipping method."
id: VersandartKeySortInput @cost(weight: "10")
"Default Category Name"
name: SortEnumType @cost(weight: "10")
"Is the shipping method active"
isActive: SortEnumType @cost(weight: "10")
}
input ShopKeySortInput {
kShop: SortEnumType @cost(weight: "10")
}
input SpracheKeySortInput {
kSprache: SortEnumType @cost(weight: "10")
}
input SteuerklasseKeySortInput {
kSteuerklasse: SortEnumType @cost(weight: "10")
}
input SteuerschluesselKeySortInput {
kSteuerschluessel: SortEnumType @cost(weight: "10")
}
input SteuerzoneKeySortInput {
kSteuerzone: SortEnumType @cost(weight: "10")
}
"Provides paged access to stock movement history entries filtered by warehouse and optional criteria."
input StockMovementHistoryItemFilterInput {
and: [StockMovementHistoryItemFilterInput!]
or: [StockMovementHistoryItemFilterInput!]
"Article number (cArtNr)."
articleNumber: StringOperationFilterInput
"Article display name."
articleName: StringOperationFilterInput
"Movement quantity."
quantity: ComparableDecimalOperationFilterInput
"Best-before date (MHD), if tracked."
bestBeforeDate: ComparableNullableOfDateTimeOperationFilterInput
"Batch\/charge number."
batchNumber: StringOperationFilterInput
"First serial number linked to the movement."
serialNumber: StringOperationFilterInput
"Count of serial numbers linked to the movement."
serialNumberCount: ComparableInt32OperationFilterInput
"Source bin location name."
sourceBinLocation: StringOperationFilterInput
"Target bin location name."
targetBinLocation: StringOperationFilterInput
"Source shipping box display ID."
sourceBoxDisplayId: StringOperationFilterInput
"Target shipping box display ID."
targetBoxDisplayId: StringOperationFilterInput
"Transfer type key (kBuchungsArt)."
transferTypeId: ComparableNullableOfInt32OperationFilterInput
"Transfer type name."
transferTypeName: StringOperationFilterInput
"User name."
userName: StringOperationFilterInput
"Movement timestamp."
timestamp: ComparableDateTimeOperationFilterInput
"Movement comment."
comment: StringOperationFilterInput
}
"Provides paged access to stock movement history entries filtered by warehouse and optional criteria."
input StockMovementHistoryItemSortInput {
"Article number (cArtNr)."
articleNumber: SortEnumType @cost(weight: "10")
"Article display name."
articleName: SortEnumType @cost(weight: "10")
"Movement quantity."
quantity: SortEnumType @cost(weight: "10")
"Best-before date (MHD), if tracked."
bestBeforeDate: SortEnumType @cost(weight: "10")
"Batch\/charge number."
batchNumber: SortEnumType @cost(weight: "10")
"First serial number linked to the movement."
serialNumber: SortEnumType @cost(weight: "10")
"Count of serial numbers linked to the movement."
serialNumberCount: SortEnumType @cost(weight: "10")
"Source bin location name."
sourceBinLocation: SortEnumType @cost(weight: "10")
"Target bin location name."
targetBinLocation: SortEnumType @cost(weight: "10")
"Source shipping box display ID."
sourceBoxDisplayId: SortEnumType @cost(weight: "10")
"Target shipping box display ID."
targetBoxDisplayId: SortEnumType @cost(weight: "10")
"Transfer type key (kBuchungsArt)."
transferTypeId: SortEnumType @cost(weight: "10")
"Transfer type name."
transferTypeName: SortEnumType @cost(weight: "10")
"User name."
userName: SortEnumType @cost(weight: "10")
"Movement timestamp."
timestamp: SortEnumType @cost(weight: "10")
"Movement comment."
comment: SortEnumType @cost(weight: "10")
}
"Single Row of the stock reservations query"
input StockReservationListItemFilterInput {
and: [StockReservationListItemFilterInput!]
or: [StockReservationListItemFilterInput!]
"Id of the item"
itemId: ComparableArtikelKeyOperationFilterInput
"Id of the sales order"
salesOrderId: ComparableVerkaufAuftragKeyOperationFilterInput
"Id of the customer"
customerId: ComparableKundeKeyOperationFilterInput
"Creation date of the reservation"
createdAt: ComparableDateTimeOffsetOperationFilterInput
"Reserved amount"
amount: ComparableDecimalOperationFilterInput
}
"Single Row of the stock reservations query"
input StockReservationListItemSortInput {
"Id of the item"
itemId: ArtikelKeySortInput @cost(weight: "10")
"Id of the sales order"
salesOrderId: VerkaufAuftragKeySortInput @cost(weight: "10")
"Id of the customer"
customerId: KundeKeySortInput @cost(weight: "10")
"Reserved amount"
amount: SortEnumType @cost(weight: "10")
"Creation date of the reservation"
createdAt: SortEnumType @cost(weight: "10")
"eBay item identifier"
ebayItemId: SortEnumType @cost(weight: "10")
"Sales platform"
platform: SortEnumType @cost(weight: "10")
}
"Single Row of the storage location query"
input StorageLocationListItemFilterInput {
and: [StorageLocationListItemFilterInput!]
or: [StorageLocationListItemFilterInput!]
"Id of the storage location."
id: ComparableWarenLagerPlatzKeyOperationFilterInput
"Default storage location name"
name: StringOperationFilterInput
}
"Single Row of the storage location query"
input StorageLocationListItemSortInput {
"Id of the storage location."
id: WarenLagerPlatzKeySortInput @cost(weight: "10")
"Default storage location name"
name: SortEnumType @cost(weight: "10")
}
input StringOperationFilterInput {
and: [StringOperationFilterInput!]
or: [StringOperationFilterInput!]
eq: String @cost(weight: "10")
neq: String @cost(weight: "10")
contains: String @cost(weight: "20")
ncontains: String @cost(weight: "20")
in: [String] @cost(weight: "10")
nin: [String] @cost(weight: "10")
startsWith: String @cost(weight: "20")
nstartsWith: String @cost(weight: "20")
endsWith: String @cost(weight: "20")
nendsWith: String @cost(weight: "20")
}
"Single row of the supplier overview table"
input SupplierFilterInput {
and: [SupplierFilterInput!]
or: [SupplierFilterInput!]
"Unique identifier of the supplier"
id: ComparableLieferantKeyOperationFilterInput
"Name of the supplier"
name: StringOperationFilterInput
"Is drop shipping supplier"
canDropship: ComparableBooleanOperationFilterInput
"Currency ISO code"
currencyIso: StringOperationFilterInput
}
"Single row of the supplier overview table"
input SupplierSortInput {
"Unique identifier of the supplier"
id: LieferantKeySortInput @cost(weight: "10")
"Name of the supplier"
name: SortEnumType @cost(weight: "10")
"Is drop shipping supplier"
canDropship: SortEnumType @cost(weight: "10")
"Currency ISO code"
currencyIso: SortEnumType @cost(weight: "10")
}
"Represents a tax class in the system"
input TaxClassFilterInput {
and: [TaxClassFilterInput!]
or: [TaxClassFilterInput!]
"The unique identifier of the tax class"
id: ComparableSteuerklasseKeyOperationFilterInput
"Indicates if this tax class is the standard tax class"
isStandard: ComparableBooleanOperationFilterInput
"The name of the tax class"
name: StringOperationFilterInput
"The type of the tax class"
taxType: ComparableTaxTypeOperationFilterInput
}
"Represents a tax class in the system"
input TaxClassSortInput {
"The unique identifier of the tax class"
id: SteuerklasseKeySortInput @cost(weight: "10")
"Indicates if this tax class is the standard tax class"
isStandard: SortEnumType @cost(weight: "10")
"The name of the tax class"
name: SortEnumType @cost(weight: "10")
"The type of the tax class"
taxType: SortEnumType @cost(weight: "10")
}
"Represents a tax code in the system"
input TaxCodeFilterInput {
and: [TaxCodeFilterInput!]
or: [TaxCodeFilterInput!]
"The unique identifier of the tax code"
id: ComparableSteuerschluesselKeyOperationFilterInput
"The cash discount account of the tax code"
cashDiscountAccount: StringOperationFilterInput
"The general ledger account of the tax code"
generalLedgerAccount: StringOperationFilterInput
"Indicates if this tax code is automatic"
isAutomatic: ComparableBooleanOperationFilterInput
"The name of the tax code"
name: StringOperationFilterInput
"The number of the tax code"
number: ComparableNullableOfInt32OperationFilterInput
}
"Represents a tax code in the system"
input TaxCodeSortInput {
"The unique identifier of the tax code"
id: SteuerschluesselKeySortInput @cost(weight: "10")
"The cash discount account of the tax code"
cashDiscountAccount: SortEnumType @cost(weight: "10")
"The general ledger account of the tax code"
generalLedgerAccount: SortEnumType @cost(weight: "10")
"Indicates if this tax code is automatic"
isAutomatic: SortEnumType @cost(weight: "10")
"The name of the tax code"
name: SortEnumType @cost(weight: "10")
"The number of the tax code"
number: SortEnumType @cost(weight: "10")
}
"Represents a tax zone with its country assignments, tax rates, and rate key assignments."
input TaxZoneFilterInput {
and: [TaxZoneFilterInput!]
or: [TaxZoneFilterInput!]
"The unique identifier of the tax zone."
id: ComparableSteuerzoneKeyOperationFilterInput
"The company this tax zone belongs to."
companyId: ComparableFirmaKeyOperationFilterInput
"The name of the tax zone."
name: StringOperationFilterInput
"The ISO code of the departure country this zone is associated with."
departureCountryIso: StringOperationFilterInput
"The source for VAT ID resolution in B2B transactions."
vatIdB2B: ComparableVatIdSourceOperationFilterInput
"The source for VAT ID resolution in B2C transactions."
vatIdB2C: ComparableVatIdSourceOperationFilterInput
}
"Represents a tax zone with its country assignments, tax rates, and rate key assignments."
input TaxZoneSortInput {
"The unique identifier of the tax zone."
id: SteuerzoneKeySortInput @cost(weight: "10")
"The company this tax zone belongs to."
companyId: FirmaKeySortInput @cost(weight: "10")
"The name of the tax zone."
name: SortEnumType @cost(weight: "10")
"The ISO code of the departure country this zone is associated with."
departureCountryIso: SortEnumType @cost(weight: "10")
"The source for VAT ID resolution in B2B transactions."
vatIdB2B: SortEnumType @cost(weight: "10")
"The source for VAT ID resolution in B2C transactions."
vatIdB2C: SortEnumType @cost(weight: "10")
}
"Triggers offer synchronisation for the specified marketplace offers. - Request"
input TriggerMarketplaceOfferSynchronisationCommandRequestInput {
"Marketplace offer keys to include in the next offer synchronisation."
offerKeys: [ID]!
}
"Triggers stock synchronisation for the specified marketplace offers. - Request"
input TriggerMarketplaceStockSynchronisationCommandRequestInput {
"Marketplace offer keys to include in the next stock synchronisation."
offerKeys: [ID]!
}
"Unlocks a bin location for available stock, allowing it to be used for stock allocation. - Request"
input UnlockBinLocationForAvailableStockCommandRequestInput {
"Unique identifier of the bin location to unlock for available stock."
binLocationId: ID!
}
input UpdateAttributeSalesChannelValuesInput {
"Identifies the saleschannel for this attributevalue"
salesChannelId: ID!
"Contains the values for a saleschannel"
values: [UpdateAttributeValueInput]
}
input UpdateAttributeValueInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Value of this attribute as string. Please consider the Attribute Type for correct formatting."
value: String!
}
input UpdateAttributeValuesInput {
"Identifies the attribute"
attributeId: ID!
"Defines the default values for the attribute and item in different languages."
defaultValues: [UpdateAttributeValueInput]
"Contains all values for saleschannels for this attribute and item"
salesChannelValues: [UpdateAttributeSalesChannelValuesInput]
}
"Updates metadata of an existing bin location (name, type, sort order). - Request"
input UpdateBinLocationMetadataCommandRequestInput {
"Unique identifier of the bin location to update."
binLocationId: ID!
"New name for the bin location (must be unique within the warehouse, max 50 chars, no apostrophes)."
name: String
"New type for the bin location (0=Standard, 1=Shelf, 2=Floor, 3=Rack, 4=Picking, 5=Transfer, 6=Clarification)."
type: Int
"New sort order."
sort: Int
}
"Updates a new Category - Request"
input UpdateCategoryCommandRequestInput {
"The category to update"
id: ID!
"The parent category of the category."
parentId: ID
"The sort number of the category."
sortNumber: Int
"The category name."
name: String
}
"Single row of the company VAT id table"
input UpdateCompanyVatIdDetailsItemInput {
"Unique VAT ID."
id: ID!
"The company id."
companyId: ID!
"The country ISO code."
countryIsoCode: String!
"The VAT id."
vatIdentifier: String!
"If this country is a shipping country"
isShippingCountry: Boolean!
}
"Represents a single cross-selling item."
input UpdateCrossSellItemInput {
"Id of the item"
id: ID!
"Sku of the item"
sku: String
}
"Updates a customer - Request"
input UpdateCustomerCommandRequestInput {
"Id of the customer."
customerId: ID!
"Id of the company the customer belongs to. Optional — if omitted, the existing company assignment is left unchanged."
companyId: ID
"Customer group for the customer to be in."
customerGroupId: ID
"The customers category ID."
customerCategoryId: ID
"The customers preferred payment method ID."
paymentMethodId: ID
"The accounts receivable number of the customer."
accountsReceivableNumber: Int
"The customer's date of birth."
birthday: DateTime
"The customer's commercial register number."
commercialRegisterNumber: String
"Number of the customer. If no number is given when posting a customer, the number will be generated automatically."
customerNumber: String
"The customers ebay name."
ebayName: String
"The customers homepage URL."
homepage: String
"The source of initial contact. This could be for example a specific sales channel, a convention or a marketing campaign."
initialContact: String
"States if a customer is from a cash-register or point of sale and if their data should be synchronized with JTL-POS, for example."
isCashRegisterBased: Boolean
"The customer's locked status."
isLocked: Boolean
"The customer's preferred language in ISO format (e.g. \"de\", \"en\")."
languageIso: String
"The customer's tax identification number."
taxIdentificationNumber: String
"Addresses of the customer."
addresses: [UpdateUpdateCustomerAddressInput]
"Settings relevant to payment for the customer."
paymentSettings: UpdateUpdateCustomerPaymentSettingsInput
"The date and time of the customer's creation."
createdDate: DateTime
}
input UpdateCustomerGroupSurchargeInput {
"Id of the customergroup"
customerGroupId: ID!
"Surcharge for that customergroup"
surcharge: Decimal
"Defines if the surcharges will be synchronized to online saleschannels. Does not apply for the default customer group surcharges, which are always synchronized when not overriden."
isActive: Boolean
}
"Defines a default description of an item in a specific language. This description is used as a fallback when no more specific platform or sales channel descriptions are available."
input UpdateDefaultDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the actual description data such as name, short and long description as well as SEO-relevant information."
descriptionData: UpdateDescriptionDataInput!
}
"Defines the actual description data of an item. This structure contains all textual information of an item including SEO-relevant metadata for online shops."
input UpdateDescriptionDataInput {
"The name of the item as displayed in the user interface or shop."
itemName: String
"Short description of the item for overview displays and search results."
shortDescription: String
"Detailed description of the item with comprehensive product information and properties."
description: String
"Meta description for search engine optimization (SEO) that is displayed in search results."
metaDescription: String
"Meta keywords for search engine optimization to improve discoverability of the item."
metaKeywords: String
"HTML title tag for the item that is displayed in the browser tab and search results."
titleTag: String
"URL path for the item to create SEO-friendly and speaking URLs."
urlPath: String
}
input UpdateDescriptionInput {
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Name of the Variation in the specific language"
name: String!
}
input UpdateEbayImagesInput {
"Unique ID to identify an ebay account."
ebayAccountId: ID!
"List of images assigned to the eBay account."
images: [UpdateItemImageInput]
}
input UpdateItemAttributesInput {
"Contains all attribute values assigned to the item"
values: [UpdateAttributeValuesInput]
}
"Defines the category assignments of an item for creation. This structure manages all categories to which an item can be assigned and enables hierarchical classification for better organization and navigation."
input UpdateItemCategoriesInput {
"Contains all categories to which the item is assigned. An item can be assigned to multiple categories simultaneously to enable flexible categorization and better discoverability."
categories: [UpdateItemCategoryInput]
}
"Defines a single category assignment for an item. This structure represents the link between an item and a specific category in the hierarchical category system of the ERP system."
input UpdateItemCategoryInput {
"Unique key of the category that identifies the specific category to which the item should be assigned. This key establishes the connection to the category data."
categoryId: ID!
}
"Represents a single cross-selling group with its assigned items."
input UpdateItemCrosssellingGroupInput {
"Unique identifier of the cross-selling group."
crosssellingGroupId: ID!
"List of item keys that belong to this cross-selling group."
items: [UpdateCrossSellItemInput]
}
"Manages cross-selling groups assigned to an item. Cross-selling groups define related products that should be promoted together."
input UpdateItemCrosssellingGroupsInput {
"Collection of cross-selling groups associated with the item."
groups: [UpdateItemCrosssellingGroupInput]
}
"Defines a single custom field value for an item. This structure connects a custom field definition with its actual value for a specific item."
input UpdateItemCustomFieldValueInput {
"Unique identifier of the custom field definition. References the custom field that was previously created in the system."
fieldId: ID!
"The actual value stored in this custom field. The format and content depend on the custom field type definition (text, number, date, etc.)."
value: String!
"The culture name (e.g., \"en-US\", \"de-DE\") associated with the custom field value. This is important for localized fields where the value may vary based on the user's language or region. When returning those values from the server side this Format is always InvariantCulture. When sending values to the server side the culture name is optional and if not provided, it will be treated as InvariantCulture. Otherwise this value initializes a CultureInfo Object."
valueCultureName: String!
}
"Defines custom fields for an item to store additional, user-defined information. Custom fields allow flexible extension of item data beyond standard properties and can be used for special business requirements, integrations, or custom workflows."
input UpdateItemCustomFieldsInput {
"List of custom field values assigned to the item. Each entry represents a custom field with its corresponding value."
fieldValues: [UpdateItemCustomFieldValueInput!]!
}
"Defines customer group-specific prices for an item. This structure enables differentiated pricing by customer groups, allowing different price levels for different customer segments."
input UpdateItemCustomerGroupPricesInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers)."
customerGroupId: ID!
"List of prices for this customer group - can contain different tier prices or volume discounts."
prices: [UpdateItemPriceInput!]!
}
"Defines a customer group-specific special price for an item. This structure represents a single promotional price for a specific customer group in a sales channel."
input UpdateItemCustomerGroupSpecialPriceInput {
"Key of the customer group that identifies the specific customer group (e.g., end customers, resellers, wholesalers) for which this special price applies."
customerGroupId: ID!
"Net special price for this customer group without taxes. Setting this to null will deactivate the special price for this customer group."
netPrice: Decimal
"Indicates whether this special price is active for this customer group. Automatically set to false when NetPrice is set to null."
isActive: Boolean
}
"Defines customer-specific prices for an item. This structure enables individual price agreements for specific customers that can deviate from standard or customer group prices."
input UpdateItemCustomerPricesInput {
"Key of the customer that identifies the specific customer for whom these individual prices apply."
customerId: ID!
"List of individual prices for this customer - can contain different tier prices or special conditions."
prices: [UpdateItemPriceInput!]!
}
"Defines the collection of all descriptions of an item for creation. This structure manages default, platform, and sales channel-specific item descriptions for different languages and distribution channels."
input UpdateItemDescriptionsInput {
"Default descriptions of the item. This is used when no more specific platform or sales channel descriptions are available and serves as a fallback description."
defaultDescriptions: [UpdateDefaultDescriptionInput]
"List of sales channel-specific descriptions for sales platforms like JTL-Shop. Enables individual customization of item descriptions for specific sales channels."
salesChannelDescriptions: [UpdateSalesChannelDescriptionInput]
"List of platform-specific descriptions for non-sales platforms like print. Allows different descriptions for various output platforms."
platformDescriptions: [UpdatePlatformDescriptionInput]
}
"Defines a single feature assignment for an item. This structure represents the link between an item and a specific feature value from the feature system, allowing detailed product characterization."
input UpdateItemFeatureInput {
"Unique key of the feature value that identifies the specific feature characteristic to be assigned to the item. This key establishes the connection to a predefined feature value in the feature system."
featureId: ID!
}
"Defines the feature assignments of an item. This structure manages all features (characteristics\/attributes) that describe specific properties or attributes of an item, such as color, size, material, or other custom characteristics used for product differentiation and filtering."
input UpdateItemFeaturesInput {
"Contains all features assigned to the item. Each feature represents a specific characteristic or attribute that describes the item in more detail, enabling better product differentiation and advanced filtering capabilities."
features: [UpdateItemFeatureInput]
}
"Defines various identifiers of an item for creation. This structure includes all relevant markings and numbers used for unique identification of an item."
input UpdateItemIdentifiersInput {
"Unique item number (Stock Keeping Unit) - the user-assigned main identification of the item."
sku: String
"Amazon FNSKU (Fulfillment Network Stock Keeping Unit) - used by Amazon for inventory management."
amazonFnsku: String
"GTIN (Global Trade Item Number, formerly EAN) - internationally standardized product identification for global trade."
gtin: String
"Manufacturer's item number - the official product number assigned by the manufacturer."
manufacturerNumber: String
"ISBN (International Standard Book Number) - mainly used for books and other publications."
isbn: String
"Taric code - customs tariff number for international trade and customs processing."
tariccode: String
"UPC (Universal Product Code) - barcode standard mainly used in North America."
upc: String
"UN number - used for marking dangerous goods in transport."
unNumber: String
"Hazard number - identifies the type of danger for hazardous goods in transport."
hazardNumber: String
"Own identifier - user-defined internal identification for company-specific purposes."
ownIdentifier: String
"Default ASIN (Amazon Standard Identification Number) - primary Amazon product identification."
defaultAsin: String
"JTL-Fulfillment-SKU (JFSKU) - unique identifier in the JTL Fulfillment Network (FFN) for item identification."
jfsku: String
}
input UpdateItemImageInput {
"Unique ID to identify an image."
blobIdentifier: UUID!
"Sort order of the image."
sortNumber: Int!
"Declares the main image of the item. Typically the image with sort order 1."
isMainImage: Boolean!
}
input UpdateItemImagesInput {
"List of default images assigned to the item."
defaultImages: [UpdateItemImageInput]
"List of images assigned to different platforms."
platformImages: [UpdatePlatformImagesInput]
"List of images assigned to different saleschannels."
saleschannelImages: [UpdateSaleschannelImagesInput]
"List of images assigned to different eBay accounts."
ebayImages: [UpdateEbayImagesInput]
}
"Defines the physical dimensions and weight specifications of an item for creation. This structure includes all relevant measurements for storage, shipping and product presentation and is used for shipping cost calculations and storage space optimizations."
input UpdateItemMeasurementsInput {
"Height of the item in the configured unit of measurement (usually centimeters or millimeters)."
height: Decimal
"Length of the item in the configured unit of measurement (usually centimeters or millimeters)."
length: Decimal
"Shipping weight of the item for shipping cost calculation in the configured weight unit (usually kilograms or grams). May differ from the actual item weight."
shippingWeight: Decimal
"Actual weight of the item without packaging in the configured weight unit (usually kilograms or grams)."
weight: Decimal
"Width of the item in the configured unit of measurement (usually centimeters or millimeters)."
width: Decimal
}
"Defines a single price with tiering options and discount possibilities. This structure forms the basis for complex price structures with volume discounts and percentage price reductions from the standard price."
input UpdateItemPriceInput {
"Minimum quantity from which this price applies - enables tier prices based on order quantity (e.g., from 10 pieces)."
fromQuantity: Int!
"Net price for this price tier without taxes - the actual selling price for the specified quantity tier."
netPrice: Decimal
"Percentage discount on the standard price - indicates by what percentage the standard price is reduced for this price tier. Used as an alternative to NetPrice."
reduceStandardPriceByPercent: Decimal
}
"Defines the complete price structure of an item for creation. This structure includes all price information for different sales channels, customer groups and individual customer prices as well as basic price information."
input UpdateItemPricesInput {
"Indicates whether discounts should be ignored for this item. When set to true, no automatic discounts will be applied to the item prices."
ignoreDiscounts: Boolean
"Net sales price of the item without taxes and discounts - the basic selling price of the item."
salesPriceNet: Decimal
"Manufacturer's suggested retail price (MSRP) - the selling price recommended by the manufacturer."
suggestedRetailPrice: Decimal
"Net purchase price without taxes - the price at which the item was purchased."
purchasePriceNet: Decimal
"eBay-specific selling price - special price for eBay sales."
ebayPrice: Decimal
"Amazon-specific selling price - special price for Amazon sales."
amazonPrice: Decimal
"List of sales channel-specific prices - enables different pricing for various sales channels or shops."
salesChannelPrices: [UpdateItemSaleschannelPricesInput]
"List of customer-specific prices - allows individual price agreements for specific customers."
customerPrices: [UpdateItemCustomerPricesInput]
"List of default prices for different customer groups - these prices serve as fallback when no more specific prices are defined."
defaultPrices: [UpdateItemCustomerGroupPricesInput]
}
"Defines sales channel-specific special prices for an item. This structure enables different promotional pricing for a specific sales channel or shop with customer group-related special price structures."
input UpdateItemSalesChannelSpecialPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this special price structure applies."
salesChannelId: ID!
"List of special prices for different customer groups within this sales channel - enables differentiated promotional pricing by customer groups."
specialPrices: [UpdateItemCustomerGroupSpecialPriceInput!]!
}
"Updates the active sales channels for a set of items - Request"
input UpdateItemSalesChannelsCommandRequestInput {
"The items to update."
itemKeys: [ID]!
"The sales channels to activate for the item set."
activateSalesChannels: [ID]
"The sales channels to deactivate for the item set."
deactivateSalesChannels: [ID]
"Should sales channel update be applied to child items."
applyToChildItems: Boolean
}
"Defines sales channel-specific prices for an item. This structure enables different pricing for various sales channels or shops with customer group-related price structures."
input UpdateItemSaleschannelPricesInput {
"Key of the sales channel that identifies the specific sales channel or shop for which this price structure applies."
saleschannelId: ID!
"List of prices for different customer groups within this sales channel - enables differentiated pricing by customer groups."
customerGroupPrices: [UpdateItemCustomerGroupPricesInput!]!
"Indicates whether this sales channel is active for the item - determines whether the item can be sold in this sales channel."
isActive: Boolean
}
"Defines the special prices (promotional prices) structure of an item. This structure includes time-based and stock-based special pricing for different sales channels and customer groups, as well as Amazon-specific special prices."
input UpdateItemSpecialPricesInput {
"Indicates whether special prices are active for this item. When set to true, the special price rules defined below will be applied according to their conditions."
isActive: Boolean
"Date from which the special price becomes active. The special price will only be valid from this date onwards."
startDate: DateTime
"Date until which the special price remains active. The special price will expire after this date. Only evaluated if IsEndDateActive is true."
endDate: DateTime
"Indicates whether the end date should be considered. If false, the special price has no expiration date."
isEndDateActive: Boolean
"Minimum stock quantity that must be available for the special price to remain active. Only evaluated if IsStockRestrictionActive is true."
minimumStockQuantity: Int
"Indicates whether the stock restriction should be applied. When true, the special price is only active if the stock level is greater than or equal to MinimumStockQuantity. Can only be activated for items that use stock management."
isStockRestrictionActive: Boolean
"List of sales channel-specific special prices - enables different promotional pricing for various sales channels or shops with customer group differentiation."
salesChannelSpecialPrices: [UpdateItemSalesChannelSpecialPricesInput]
}
"Defines the storage and inventory management constraints of an item. This structure includes settings for negative stock handling, inventory management, serial numbers, batch tracking, and best-before date management."
input UpdateItemStorageConstraintsInput {
"Allows selling a higher quantity of the item than is actually in stock. This global setting must be activated first before platform-specific or sales channel-specific negative stock settings can be enabled."
allowNegativeStock: Boolean
"List of platform-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific platforms (e.g., eBay, Amazon). AllowNegativeStock must be activated as well for these settings to take effect."
itemPlatformNegativeStocks: [UpdateNegativeStockPlatformInput]
"List of sales channel-specific negative stock settings. Activates the ability to sell a higher quantity of the item for specific sales channels or shops. AllowNegativeStock must be activated as well for these settings to take effect."
itemSalesChannelNegativeStocks: [UpdateNegativeStockSalesChannelInput]
"Item buffer quantity - defines a safety stock buffer that is reserved and not available for sale. This helps prevent overselling and ensures availability for important orders."
buffer: Int
"Global minimum stock level across all warehouses. When the total stock falls below this value, the item is flagged for reordering. Used for automatic order suggestions and low-stock warnings."
globalMinimumStockLevel: Decimal
"Indicates whether the item uses batch management. When enabled, the item requires batch numbers to be assigned for each stock movement to enable tracking and traceability."
hasBatch: Boolean
"Determines if the item is working with inventory management. When active, stock levels are tracked and managed; when inactive, the item is treated as always available regardless of stock levels."
isInventoryManagementActive: Boolean
"Determines if the item is working with best-before date (MHD - Mindesthaltbarkeitsdatum) management. When enabled, stock items must have an assigned best-before date for tracking perishable goods."
isBestBeforeManaged: Boolean
"Determines if the item can be sold in split quantities (fractional units). When enabled, stock can be managed in decimal quantities (e.g., 2.5 pieces) instead of only whole numbers."
isStockDivisible: Boolean
"Determines the type of serial number processing. Defines whether serial numbers are inactive, active, or tracked for this item."
serialNumberType: SerialNumberType
}
input UpdateItemSupplierInput {
"Id of the supplier"
supplierId: ID!
"Name of the item at the supplier (max 255 characters)."
supplierItemName: String
"Item number at the supplier (max 255 characters)."
supplierItemNumber: String
"Stock level of the item at the supplier."
stockLevel: Decimal
"Net purchase price of the item at the supplier."
netPurchasePrice: Decimal
"Minimum purchase quantity of the item at the supplier."
minimumPurchaseQuantity: Int
"Delivery time for this item at the supplier (in days)."
deliveryTimeInDays: Int
"Indicates if this item uses dropshipping from the supplier."
isDropshippingActive: Boolean
"Description of the packaging unit."
packageUnitDescription: String
"Quantity per packaging unit."
packageUnitQuantity: Decimal
"Additional notes (max 512 characters)."
notes: String
"VAT rate of the item at the supplier."
vatRate: Decimal
"Whether to use the supplier's delivery time directly."
useSupplierDeliveryTime: Boolean
"Whether to include the supplier's stock in own inventory."
includeSupplierStock: Boolean
"Purchase interval for this item at the supplier."
purchaseInterval: Decimal
"Scale prices defined by the supplier for this item."
scalePrices: [UpdateSupplierPriceInput]
}
input UpdateItemSuppliersInput {
"Sets the default supplier for the item."
defaultSupplier: ID
"Sets the default supplier for dropshipping for the item."
defaultDropshippingSupplier: ID
"Assigned suppliers for the item"
suppliers: [UpdateItemSupplierInput]
}
"Defines the item unit pricing settings for creation and modification. This structure includes all relevant information about the sales unit, packaging unit, inner quantity and base price details for an item."
input UpdateItemUnitPricingInput {
"Id of the sales unit in which the item is sold (e.g. piece or box)."
salesUnitId: ID
"Id of the packaging unit of the item."
packagingUnitId: ID
"The amount of content for one piece of the sales unit, relative to the inner quantity unit."
innerQuantity: Decimal
"The measurement unit for the inner quantity (e.g. kg or liter)."
innerQuantityUnitId: ID
"Indicates whether the base price should be automatically calculated and displayed."
isBasePriceDeclared: Boolean
"The measurement unit to which the base price refers (e.g. per liter or per 100 grams)."
basePriceReferenceUnitId: ID
"The reference amount used when calculating the base price (e.g. 1 for per liter, 100 for per 100 grams)."
basePriceReferenceAmount: Decimal
}
input UpdateItemVariationsInput {
"Contains all Variations"
variations: [UpdateVariationInput]
}
"Defines negative stock settings for a specific platform. This structure enables individual configuration of negative stock handling per platform (e.g., eBay, Amazon), allowing overselling for specific marketplaces when the global AllowNegativeStock is enabled."
input UpdateNegativeStockPlatformInput {
"Key of the platform that identifies the specific marketplace or platform (e.g., eBay, Amazon) for which this negative stock setting applies."
platformId: ID!
"Determines if negative stock is allowed for this platform. When true, orders can be accepted even when the item is out of stock on this specific marketplace."
isNegativeStockAllowed: Boolean!
}
"Defines negative stock settings for a specific sales channel. This structure enables individual configuration of negative stock handling per sales channel, allowing overselling for specific online shops when the global AllowNegativeStock is enabled."
input UpdateNegativeStockSalesChannelInput {
"Key of the sales channel that identifies the specific shop or sales channel for which this negative stock setting applies."
salesChannelId: ID!
"Determines if negative stock is allowed for this sales channel. When true, orders can be accepted even when the item is out of stock in this specific channel."
isNegativeStockAllowed: Boolean!
}
"Defines a platform-specific description of an item. This enables different descriptions for various output platforms like print or other non-sales platforms."
input UpdatePlatformDescriptionInput {
"Unique key of the platform for which this description is intended (e.g., print, labels)."
platformId: ID!
"ISO2 language code that determines the language for this item description (e.g., \"DE\" for German, \"EN\" for English)."
languageIso: String!
"Contains the platform-specific description data with all relevant texts and SEO information."
descriptionData: UpdateDescriptionDataInput!
}
input UpdatePlatformImagesInput {
"Unique ID to identify a platform."
platformId: ID!
"List of images assigned to the platform."
images: [UpdateItemImageInput]
}
"Defines a product group"
input UpdateProductGroupInput {
"The id of the product group"
id: ID!
"The new name of the product group"
name: String!
}
"Update the properties of product groups. - Request"
input UpdateProductGroupsCommandRequestInput {
"Product groups to update."
productGroups: [UpdateProductGroupInput!]!
}
"Updates a production order. - Request"
input UpdateProductionOrderCommandRequestInput {
"The ID of the production order to be updated."
productionOrderId: ID!
"The ID of the item to be produced by the production order."
productionItemId: ID
"The ID of the bill of materials for the production item used in the production order."
billOfMaterialId: ID
"The number of lots for the production order."
lotCount: Int
"The size of each lot for the production order."
lotSize: Decimal
"The target start timestamp of the production order."
targetStartTimestamp: DateTime
"The target completion timestamp of the production order."
targetCompletionTimestamp: DateTime
"The delivery timestamp of the production order."
deliveryTimestamp: DateTime
"The reference number of the production order."
referenceNumber: String
"The project number of the production order."
projectNumber: String
"The notice of the production order."
notice: String
}
"Defines a sales channel-specific description of an item. This enables individual customization of item descriptions for specific sales channels or shops."
input UpdateSalesChannelDescriptionInput {
"Unique key of the sales channel or shop for which this description is intended."
salesChannelId: ID!
"ISO2 language code that determines the language for this sales channel-specific description."
languageIso: String!
"Contains the sales channel-specific description data with all relevant texts and SEO information."
descriptionData: UpdateDescriptionDataInput!
}
input UpdateSalesChannelSurchargeInput {
"Id of the saleschannel"
salesChannelId: ID!
"Contains the surcharges for that saleschannel and customergroup"
surcharges: [UpdateCustomerGroupSurchargeInput!]!
}
"Modifies an existing sales order. - Request"
input UpdateSalesOrderCommandRequestInput {
"Unique ID of the sales order to be modified."
salesOrderId: ID!
"Indicates whether automatic workflows should be disabled for this sales order."
disableAutomaticWorkflows: Boolean
"Indicates whether the billing address should be used as the shipment address."
useBillingAddressAsShipmentAddress: Boolean
"The SalesOrder CartonItemId"
cartonItemId: ID
"Unique ID of the company."
companyId: ID
"The ID of the customer associated with the sales order."
customerId: ID
"The SalesOrder OnHoldReasonId"
onHoldReasonId: ID
"The ID of the payment method for the sales order."
paymentMethodId: ID
"The SalesOrder ProcessColourId"
processColourId: ID
"The SalesOrder ProcessStatusId"
processStatusId: ID
"The ID of the shipping method for the sales order."
shippingMethodId: ID
"SalesOrderBillingAddress"
billingAddress: UpdateUpdateSalesOrderAddressInput
"SalesOrderShipmentAddress"
shipmentAddress: UpdateUpdateSalesOrderAddressInput
"DepartureCountry"
departureCountry: UpdateUpdateSalesOrderDepartureCountryInput
"ExternalDetails"
externalDetails: UpdateUpdateSalesOrderExternalDetailsInput
"The line items included in the sales order."
lineItems: [UpdateUpdateSalesOrderLineItemInput]
"PaymentDetails"
paymentDetails: UpdateUpdateSalesOrderPaymentDetailsInput
"SalesOrderPaymentInfo"
paymentInfo: UpdateUpdateSalesOrderPaymentInfoInput
"ShippingDetails"
shippingDetails: UpdateUpdateSalesOrderShippingDetailsInput
"TaxDetails"
taxDetails: UpdateUpdateSalesOrderTaxDetailsInput
"SalesOrderText"
text: UpdateUpdateSalesOrderTextInput
"The SalesOrder CustomerSalesOrderNumber"
customerSalesOrderNumber: String
"The SalesOrder ItemDescriptionType"
itemDescriptionType: ItemDescriptionType
"The SalesOrder LanguageISO"
languageIso: String
"The SalesOrder ReadOnlyType"
readOnlyType: ReadOnlyType
"The SalesOrder Date"
salesOrderDate: DateTime
"The SalesOrder VATId"
vatId: String
}
"Modifies an existing sales quotation. - Request"
input UpdateSalesQuotationCommandRequestInput {
"Unique ID of the sales quotation to be modified."
salesQuotationId: ID!
"Indicates whether automatic workflows should be disabled for this sales quotation."
disableAutomaticWorkflows: Boolean
"Indicates whether the billing address should be used as the shipment address."
useBillingAddressAsShipmentAddress: Boolean
"The SalesQuotation CartonItemId"
cartonItemId: ID
"Unique ID of the company."
companyId: ID
"The ID of the customer associated with the sales quotation."
customerId: ID
"The SalesQuotation OnHoldReasonId"
onHoldReasonId: ID
"The ID of the payment method for the sales quotation."
paymentMethodId: ID
"The SalesQuotation ProcessColourId"
processColourId: ID
"The SalesQuotation ProcessStatusId"
processStatusId: ID
"The ID of the shipping method for the sales quotation."
shippingMethodId: ID
"SalesQuotationBillingAddress"
billingAddress: UpdateUpdateSalesQuotationAddressInput
"SalesQuotationShipmentAddress"
shipmentAddress: UpdateUpdateSalesQuotationAddressInput
"DepartureCountry"
departureCountry: UpdateUpdateSalesQuotationDepartureCountryInput
"ExternalDetails"
externalDetails: UpdateUpdateSalesQuotationExternalDetailsInput
"The line items included in the sales quotation."
lineItems: [UpdateUpdateSalesQuotationLineItemInput]
"PaymentDetails"
paymentDetails: UpdateUpdateSalesQuotationPaymentDetailsInput
"SalesQuotationPaymentInfo"
paymentInfo: UpdateUpdateSalesQuotationPaymentInfoInput
"ShippingDetails"
shippingDetails: UpdateUpdateSalesQuotationShippingDetailsInput
"TaxDetails"
taxDetails: UpdateUpdateSalesQuotationTaxDetailsInput
"SalesQuotationText"
text: UpdateUpdateSalesQuotationTextInput
"The SalesQuotation CustomerSalesQuotationNumber"
customerSalesQuotationNumber: String
"The SalesQuotation ItemDescriptionType"
itemDescriptionType: ItemDescriptionType
"The SalesQuotation LanguageISO"
languageIso: String
"The SalesQuotation ReadOnlyType"
readOnlyType: ReadOnlyType
"The SalesQuotation Date"
salesQuotationDate: DateTime
"The SalesQuotation VATId"
vatId: String
}
input UpdateSaleschannelImagesInput {
"Unique ID to identify a saleschannel."
saleschannelId: ID!
"List of images assigned to the saleschannel."
images: [UpdateItemImageInput]
}
"Updates mutable metadata of an existing shipping box. TypeId is immutable (Rule SB-3). - Request"
input UpdateShippingBoxMetadataCommandRequestInput {
"The shipping box to update."
shippingBoxId: ID!
"New display name (omit to keep existing)."
displayId: String!
"Replacement attribute list (omit to keep existing)."
attributes: [String!]!
}
input UpdateSupplierPriceInput {
"Quantity from which the price applies. This value is not editable. To change it, a new scale must be created."
fromQuantity: Decimal!
"Net price for this scale."
netPrice: Decimal
"Indicates whether the scale uses a percentage discount of the NetPurchasePrice."
usePercentageDiscount: Boolean!
"The percentage discount applied in this scale."
percentageDiscount: Decimal
}
"Updates an existing tax class - Request"
input UpdateTaxClassCommandRequestInput {
"The ID of the tax class to update"
id: ID!
"Whether this tax class is the standard tax class. Setting this to true will set all other tax classes to non-standard."
isStandard: Boolean
"The name of the tax class"
name: String
"The type of the tax class"
taxType: TaxType
}
"Updates an existing tax code - Request"
input UpdateTaxCodeCommandRequestInput {
"The ID of the tax code to update"
id: ID!
"The cash discount account of the tax code"
cashDiscountAccount: String
"The general ledger account of the tax code"
generalLedgerAccount: String
"Whether this tax code is automatic"
isAutomatic: Boolean
"The name of the tax code"
name: String
"The number of the tax code. Can only be changed when the tax code is not referenced."
number: Int
}
input UpdateUpdateCustomerAddressInput {
"Unique identifier for the address."
customerAddressId: ID
"Type of the address (shipment, billing, etc.)."
addressType: CustomerAddressType
"Name of the street (including number)."
street: String
"Additional address information."
additionalAddressLine: String
"City name of the customer."
city: String
"Postal code of the customer."
postalCode: String
"Name of the state."
state: String
"ISO code of the country (2 letter code, e.g. DE, AT, CH)."
countryIso: String
"The customers email address."
emailAddress: String
"The customers phone number."
phoneNumber: String
"The customers mobile phone number."
mobilePhoneNumber: String
"The customers fax number."
faxNumber: String
"The customers VAT ID."
vatId: String
"The customers salutation (e.g. Mr., Mrs., etc.)"
salutation: String
"The customers title (e.g. Dr., Prof., etc.)"
title: String
"The customers first name"
firstName: String
"The customers last name"
lastName: String
"The customers company name"
companyName: String
"The customers company extension"
additionalCompanyLine: String
"Indicates whether this is the default address."
isDefaultAddress: Boolean
}
input UpdateUpdateCustomerPaymentSettingsInput {
"The customers credit limit."
creditLimit: Int
"Payment target (in days)."
paymentDueDateInDays: Int
"The customers discount percentage."
discount: Decimal
"Whether the customer is blocked for dunning notices."
isDunningBlocked: Boolean
}
"address details for the sales order."
input UpdateUpdateSalesOrderAddressInput {
"The SalesOrderAddress Salutation"
salutation: String
"The SalesOrderAddress Title"
title: String
"The SalesOrderAddress FirstName"
firstName: String
"The SalesOrderAddress LastName"
lastName: String
"The SalesOrderAddress Company"
company: String
"The SalesOrderAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesOrderAddress Street"
street: String
"The SalesOrderAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesOrderAddress City"
city: String
"The SalesOrderAddress PostalCode"
postalCode: String
"The SalesOrderAddress State"
state: String
"The SalesOrderAddress CountryISO"
countryIso: String
"The SalesOrderAddress PostId"
postId: String
"The SalesOrderAddress EmailAddress"
emailAddress: String
"The SalesOrderAddress PhoneNumber"
phoneNumber: String
"The SalesOrderAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesOrderAddress Fax"
fax: String
"The SalesOrderAddress VAT ID"
vatId: String
}
"Departure country information for the sales order to be modified."
input UpdateUpdateSalesOrderDepartureCountryInput {
"The ISO code of the departure country."
countryIso: String
"The sales order departure country currency iso"
currencyIso: String
"The sales order departure country currency factor"
currencyFactor: Decimal
"The SalesOrder StateCode"
stateCode: String
}
"External details for the sales order to be modified."
input UpdateUpdateSalesOrderExternalDetailsInput {
"The SalesOrder ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesOrder ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType
"The SalesOrder ExternalSalesOrderNumber"
externalSalesOrderNumber: String
}
"Line item details for the sales order line item to be modified."
input UpdateUpdateSalesOrderLineItemInput {
"Unique ID of the sales order line item to be modified."
salesOrderLineItemId: ID
"Unique ID to identify an item."
itemId: ID
"The SalesOrderLineItem ParentSalesOrderLineItemId"
parentSalesOrderLineItemId: ID
"The SalesOrderLineItem TaxClassId"
taxClassId: ID
"The SalesOrderLineItem TaxCodeId"
taxCodeId: ID
"The SalesOrderLineItem BillOfMaterialsType"
billOfMaterialsType: BillOfMaterialsType
"The SalesOrderLineItem ConfigurationItemType"
configurationItemType: ConfigurationItemType
"The discount of the line item."
discountPercent: Decimal
"The SalesOrderLineItem FNSKU"
fnSku: String
"Name of the position."
name: String
"The SalesOrderLineItem Note"
note: String
"The purchase price of the item."
purchasePriceNet: Decimal
"The quantity of the line item."
quantity: Decimal
"DEPRECATED: do not use; use SalesPriceNet instead."
salesPriceGross: Decimal
"The net sales price of the item."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales order line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesOrderLineItem LineItemType"
type: LineItemType
"List of SalesOrderLineItemVariant"
variants: [UpdateUpdateSalesOrderLineItemVariantInput]
}
"Sales order line item variant details for the sales order to be modified."
input UpdateUpdateSalesOrderLineItemVariantInput {
"The SalesOrderLineItemVariant ExtraWeight"
extraWeight: Decimal
"The SalesOrderLineItemVariant Name"
name: String!
"The SalesOrderLineItemVariant SurchargeNet"
surchargeNet: Decimal
"The SalesOrderLineItemVariant Value"
value: String
"The SalesOrderLineItemVariant ItemVariantId"
itemVariantId: ID!
"The SalesOrderLineItemVariant ItemVariantValueId"
itemVariantValueId: ID
}
"Payment details for the sales order to be modified."
input UpdateUpdateSalesOrderPaymentDetailsInput {
"The SalesOrder CashDiscount"
cashDiscount: Decimal
"The SalesOrder CashDiscountDays"
cashDiscountDays: Int
"The SalesOrder PaymentDueDateInDays"
paymentDueDateInDays: Int
"The sales order currency iso"
currencyIso: String
"The sales order currency factor"
currencyFactor: Decimal
}
"Payment info for the sales order to be modified."
input UpdateUpdateSalesOrderPaymentInfoInput {
"The SalesOrderPaymentInfo AccountHolder"
accountHolder: String
"The SalesOrderPaymentInfo BankName"
bankName: String
"The SalesOrderPaymentInfo BIC"
bic: String
"The SalesOrderPaymentInfo CreditorId"
creditorId: String
"The SalesOrderPaymentInfo DueDate"
dueDate: DateTime
"The SalesOrderPaymentInfo EndToEndId"
endToEndId: String
"The SalesOrderPaymentInfo IBAN"
iban: String
"The SalesOrderPaymentInfo MandateReference"
mandateReference: String
"The SalesOrderPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesOrderPaymentInfo PaymentInfoType"
paymentInfoType: Byte
"The SalesOrderPaymentInfo PaymentReference"
paymentReference: String
"The SalesOrderPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for the sales order to be modified."
input UpdateUpdateSalesOrderShippingDetailsInput {
"The SalesOrder DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesOrder EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesOrder ExtraWeight"
extraWeight: Decimal
"The SalesOrder MaxDeliveryDays"
maxDeliveryDays: Int
"The SalesOrder ShippingDate"
shippingDate: DateTime
"The SalesOrder ShippingPriority"
shippingPriority: Int
}
"Tax details for the sales order to be modified."
input UpdateUpdateSalesOrderTaxDetailsInput {
"The SalesOrder TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference
"The SalesOrder SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment
"The SalesOrder TaxSetting"
taxSetting: TaxSetting
}
"Text details for the sales order to be modified."
input UpdateUpdateSalesOrderTextInput {
"The SalesOrderText Comment"
comment: String
"The SalesOrderText CustomerComment"
customerComment: String
"The SalesOrderText PrintText"
printText: String
"The SalesOrderText ProcessStatus"
processStatus: String
}
"Address details for the sales quotation."
input UpdateUpdateSalesQuotationAddressInput {
"The SalesQuotationAddress Salutation"
salutation: String
"The SalesQuotationAddress Title"
title: String
"The SalesQuotationAddress FirstName"
firstName: String
"The SalesQuotationAddress LastName"
lastName: String
"The SalesQuotationAddress Company"
company: String
"The SalesQuotationAddress AdditionalCompanyLine"
additionalCompanyLine: String
"The SalesQuotationAddress Street"
street: String
"The SalesQuotationAddress AdditionalAddressLine"
additionalAddressLine: String
"The SalesQuotationAddress City"
city: String
"The SalesQuotationAddress PostalCode"
postalCode: String
"The SalesQuotationAddress State"
state: String
"The SalesQuotationAddress CountryISO"
countryIso: String
"The SalesQuotationAddress PostId"
postId: String
"The SalesQuotationAddress EmailAddress"
emailAddress: String
"The SalesQuotationAddress PhoneNumber"
phoneNumber: String
"The SalesQuotationAddress MobilePhoneNumber"
mobilePhoneNumber: String
"The SalesQuotationAddress Fax"
fax: String
"The SalesQuotationAddress VAT ID"
vatId: String
}
"Departure country information for the sales quotation to be modified."
input UpdateUpdateSalesQuotationDepartureCountryInput {
"The ISO code of the departure country."
countryIso: String
"The sales quotation departure country currency iso"
currencyIso: String
"The sales quotation departure country currency factor"
currencyFactor: Decimal
"The SalesQuotation StateCode"
stateCode: String
}
"External details for the sales quotation to be modified."
input UpdateUpdateSalesQuotationExternalDetailsInput {
"The SalesQuotation ExternalCreatedDate"
externalCreatedDate: DateTime
"The SalesQuotation ExternalInvoiceType"
externalInvoiceType: ExternalSalesInvoiceType
"The SalesQuotation ExternalSalesQuotationNumber"
externalSalesQuotationNumber: String
}
"Line item details for the sales quotation line item to be modified."
input UpdateUpdateSalesQuotationLineItemInput {
"Unique ID of the sales quotation line item to be modified."
salesQuotationLineItemId: ID
"Unique ID to identify an item."
itemId: ID
"The SalesQuotationLineItem ParentSalesQuotationLineItemId"
parentSalesQuotationLineItemId: ID
"The SalesQuotationLineItem TaxClassId"
taxClassId: ID
"The SalesQuotationLineItem TaxCodeId"
taxCodeId: ID
"The SalesQuotationLineItem BillOfMaterialsType"
billOfMaterialsType: BillOfMaterialsType
"The SalesQuotationLineItem ConfigurationItemType"
configurationItemType: ConfigurationItemType
"The discount of the line item."
discountPercent: Decimal
"The SalesQuotationLineItem FNSKU"
fnSku: String
"Name of the position."
name: String
"The SalesQuotationLineItem Note"
note: String
"The purchase price of the item."
purchasePriceNet: Decimal
"The quantity of the line item."
quantity: Decimal
"The gross sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceGross: Decimal
"The net sales price of the item. Only net or gross price can be entered. The other price will then be calculated."
salesPriceNet: Decimal
"The sales unit of the line item."
salesUnit: String
"SKU of the sales quotation line item."
sku: String
"The tax rate of the line item."
taxRate: Decimal
"The SalesQuotationLineItem LineItemType"
lineItemType: LineItemType
"List of SalesQuotationLineItemVariant"
variants: [UpdateUpdateSalesQuotationLineItemVariantInput]
}
"Sales quotation line item variant details for the sales quotation to be modified."
input UpdateUpdateSalesQuotationLineItemVariantInput {
"The SalesQuotationLineItemVariant ExtraWeight"
extraWeight: Decimal
"The SalesQuotationLineItemVariant Name"
name: String!
"The SalesQuotationLineItemVariant SurchargeNet"
surchargeNet: Decimal
"The SalesQuotationLineItemVariant Value"
value: String
"The SalesQuotationLineItemVariant ItemVariantId"
itemVariantId: ID!
"The SalesQuotationLineItemVariant ItemVariantValueId"
itemVariantValueId: ID
}
"Payment details for the sales quotation to be modified."
input UpdateUpdateSalesQuotationPaymentDetailsInput {
"The SalesQuotation CashDiscount"
cashDiscount: Decimal
"The SalesQuotation CashDiscountDays"
cashDiscountDays: Int
"The SalesQuotation PaymentDueDateInDays"
paymentDueDateInDays: Int
"The sales quotation currency iso"
currencyIso: String
"The sales quotation currency factor"
currencyFactor: Decimal
}
"Payment info for the sales quotation to be modified."
input UpdateUpdateSalesQuotationPaymentInfoInput {
"The SalesQuotationPaymentInfo AccountHolder"
accountHolder: String
"The SalesQuotationPaymentInfo BankName"
bankName: String
"The SalesQuotationPaymentInfo BIC"
bic: String
"The SalesQuotationPaymentInfo CreditorId"
creditorId: String
"The SalesQuotationPaymentInfo DueDate"
dueDate: DateTime
"The SalesQuotationPaymentInfo EndToEndId"
endToEndId: String
"The SalesQuotationPaymentInfo IBAN"
iban: String
"The SalesQuotationPaymentInfo MandateReference"
mandateReference: String
"The SalesQuotationPaymentInfo PaymentInfo"
paymentInfo: String
"The SalesQuotationPaymentInfo PaymentInfoType"
paymentInfoType: Byte
"The SalesQuotationPaymentInfo PaymentReference"
paymentReference: String
"The SalesQuotationPaymentInfo ReferenceEmail"
referenceEmail: String
}
"Shipping details for the sales quotation to be modified."
input UpdateUpdateSalesQuotationShippingDetailsInput {
"The SalesQuotation DeliveryFromDate"
deliveryFromDate: DateTime
"The SalesQuotation EstimatedDeliveryDate"
estimatedDeliveryDate: DateTime
"The SalesQuotation ExtraWeight"
extraWeight: Decimal
"The SalesQuotation MaxDeliveryDays"
maxDeliveryDays: Int
"The SalesQuotation ShippingDate"
shippingDate: DateTime
"The SalesQuotation ShippingPriority"
shippingPriority: Int
}
"Tax details for the sales quotation to be modified."
input UpdateUpdateSalesQuotationTaxDetailsInput {
"The SalesQuotation TaxReference. This setting controls which data is used during tax calculation."
taxReference: TaxReference
"The SalesQuotation SpecialTaxTreatment"
specialTaxTreatment: SpecialTaxTreatment
"The SalesQuotation TaxSetting"
taxSetting: TaxSetting
}
"Text details for the sales quotation to be modified."
input UpdateUpdateSalesQuotationTextInput {
"The SalesQuotationText Comment"
comment: String
"The SalesQuotationText CustomerComment"
customerComment: String
"The SalesQuotationText PrintText"
printText: String
"The SalesQuotationText ProcessStatus"
processStatus: String
}
input UpdateVariationInput {
"Id of the Variation"
variationId: ID!
"Position of this Variation in the List"
position: Int
"Descriptions of this Variation in multiple Languages"
descriptions: [UpdateDescriptionInput]
"Values for this Variation"
values: [UpdateVariationValueInput]
"Type of the Variation"
variationType: VariationType
}
input UpdateVariationValueInput {
"Id of the VariationValue"
variationValueId: ID!
"Itemnumber for this variationvalue"
itemNumber: String
"GTIN for this variationvalue"
gtin: String
"Offset for the weight of this variationvalue"
weightOffset: Decimal
"Descriptions of this VariationValue in multiple Languages"
descriptions: [UpdateDescriptionInput]
"Surcharges of this VariationValue"
surcharges: UpdateVariationValueSurchargesInput
"Position of this VariationValue in the List"
position: Int
"Image for this variation value. This image will be used as the main image for the variation combination if this variation value is part of it and the variation combination doesn't have its own image."
image: ID
}
input UpdateVariationValueSurchargesInput {
"Default Surcharge if there is none specified for a specific saleschannel + customergroup"
defaultSurchargeNet: Decimal
"Default Surcharges for specific customergroups in general, independent of saleschannel"
customerGroupSurcharges: [UpdateCustomerGroupSurchargeInput]
"Surcharge for specific saleschannels + customergroups"
salesChannelSurcharges: [UpdateSalesChannelSurchargeInput]
}
"Updates mutable metadata (code, description, type) of an existing warehouse zone. - Request"
input UpdateWarehouseZoneMetadataCommandRequestInput {
"The zone to update."
zoneId: ID!
"New zone short code (omit to keep existing)."
code: String!
"New zone type (omit to keep existing)."
zoneType: Int!
"New zone description (omit to keep existing)."
description: String!
}
input VerkaufAuftragKeySortInput {
kAuftrag: SortEnumType @cost(weight: "10")
}
input VerkaufAuftragPositionKeySortInput {
kAuftragPosition: SortEnumType @cost(weight: "10")
}
input VersandartKeySortInput {
kVersandart: SortEnumType @cost(weight: "10")
}
input VersandklasseKeySortInput {
kVersandklasse: SortEnumType @cost(weight: "10")
}
input VorlagenSetKeySortInput {
kVorlagenset: SortEnumType @cost(weight: "10")
}
input WaehrungKeySortInput {
kWaehrung: SortEnumType @cost(weight: "10")
}
"Single Row of the warehouse query"
input WarehouseListItemFilterInput {
and: [WarehouseListItemFilterInput!]
or: [WarehouseListItemFilterInput!]
"Id of the warehouse."
id: ComparableWarenlagerKeyOperationFilterInput
"Default warehouse name"
name: StringOperationFilterInput
"Describes if the warehouse is active"
active: ComparableBooleanOperationFilterInput
}
"Single Row of the warehouse query"
input WarehouseListItemSortInput {
"Id of the warehouse."
id: WarenlagerKeySortInput @cost(weight: "10")
"Default warehouse name"
name: SortEnumType @cost(weight: "10")
"Describes if the warehouse is active"
active: SortEnumType @cost(weight: "10")
}
"Single row of the warehouse zones overview list."
input WarehouseZoneListItemFilterInput {
and: [WarehouseZoneListItemFilterInput!]
or: [WarehouseZoneListItemFilterInput!]
"Unique zone identifier."
zoneId: ComparableWarenLagerBereichKeyOperationFilterInput
"Zone short code."
code: StringOperationFilterInput
"Warehouse that owns this zone."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
"Zone type enum value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: ComparableInt32OperationFilterInput
}
"Single row of the warehouse zones overview list."
input WarehouseZoneListItemSortInput {
"Unique zone identifier."
zoneId: WarenLagerBereichKeySortInput @cost(weight: "10")
"Zone short code."
code: SortEnumType @cost(weight: "10")
"Zone type enum value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
zoneType: SortEnumType @cost(weight: "10")
}
input WarenLagerBereichKeySortInput {
kLagerBereich: SortEnumType @cost(weight: "10")
}
input WarenLagerEingangKeySortInput {
kWarenLagerEingang: SortEnumType @cost(weight: "10")
}
input WarenLagerPlatzKeySortInput {
kWarenLagerPlatz: SortEnumType @cost(weight: "10")
}
input WarengruppeKeySortInput {
kWarengruppe: SortEnumType @cost(weight: "10")
}
input WarenlagerKeySortInput {
kWarenlager: SortEnumType @cost(weight: "10")
}
"Represents a workbench resource."
input WorkbenchResourceFilterInput {
and: [WorkbenchResourceFilterInput!]
or: [WorkbenchResourceFilterInput!]
"This workbench resource's unique ID."
id: ComparableWorkbenchResourceKeyOperationFilterInput
"This workbench resource's unique number."
number: StringOperationFilterInput
"This workbench resource's name."
name: StringOperationFilterInput
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ComparableResourceTypeKeyOperationFilterInput
"The name of the host assigned to this workbench resource."
hostName: StringOperationFilterInput
"The ID of the warehouse assigned to this workbench resource."
warehouseId: ComparableWarenlagerKeyOperationFilterInput
}
input WorkbenchResourceKeySortInput {
kWorkbenchResource: SortEnumType @cost(weight: "10")
}
"Represents a workbench resource."
input WorkbenchResourceSortInput {
"This workbench resource's unique ID."
id: WorkbenchResourceKeySortInput @cost(weight: "10")
"This workbench resource's unique number."
number: SortEnumType @cost(weight: "10")
"This workbench resource's name."
name: SortEnumType @cost(weight: "10")
"The ID of the resource type assigned to this workbench resource."
workbenchResourceTypeId: ResourceTypeKeySortInput @cost(weight: "10")
"The name of the host assigned to this workbench resource."
hostName: SortEnumType @cost(weight: "10")
"The ID of the warehouse assigned to this workbench resource."
warehouseId: WarenlagerKeySortInput @cost(weight: "10")
}
"Represents a workbench resource type"
input WorkbenchResourceTypeFilterInput {
and: [WorkbenchResourceTypeFilterInput!]
or: [WorkbenchResourceTypeFilterInput!]
"This workbench resource type's unqiue ID."
id: ComparableResourceTypeKeyOperationFilterInput
"The workbench resource type's name."
name: StringOperationFilterInput
}
"Represents a workbench resource type"
input WorkbenchResourceTypeSortInput {
"This workbench resource type's unqiue ID."
id: ResourceTypeKeySortInput @cost(weight: "10")
"The workbench resource type's name."
name: SortEnumType @cost(weight: "10")
}
"A single configuration value to assign to a worker sync."
input WorkerSyncConfigAssignmentInput {
"The identifier of the configuration entry to set."
identifier: ID!
"The value to assign to the configuration entry."
value: String
}
input ZahlungsartKeySortInput {
kZahlungsart: SortEnumType @cost(weight: "10")
}
"Represents a bin location assigned to a warehouse zone."
input ZoneBinLocationItemFilterInput {
and: [ZoneBinLocationItemFilterInput!]
or: [ZoneBinLocationItemFilterInput!]
"Zone identifier."
zoneId: ComparableWarenLagerBereichKeyOperationFilterInput
"Bin location identifier."
binLocationId: ComparableWarenLagerPlatzKeyOperationFilterInput
}
"Represents a bin location assigned to a warehouse zone."
input ZoneBinLocationItemSortInput {
"Zone identifier."
zoneId: WarenLagerBereichKeySortInput @cost(weight: "10")
"Bin location identifier."
binLocationId: WarenLagerPlatzKeySortInput @cost(weight: "10")
}
"Reference data describing an available warehouse zone type."
input ZoneTypeFilterInput {
and: [ZoneTypeFilterInput!]
or: [ZoneTypeFilterInput!]
"Zone type numeric value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
value: ComparableInt32OperationFilterInput
"Display name for the zone type."
name: StringOperationFilterInput
}
"Reference data describing an available warehouse zone type."
input ZoneTypeSortInput {
"Zone type numeric value (0=Standard, 1=Picking, 2=Replenishment, 3=Reserve)."
value: SortEnumType @cost(weight: "10")
"Display name for the zone type."
name: SortEnumType @cost(weight: "10")
}
input ZustandKeySortInput {
kZustand: SortEnumType @cost(weight: "10")
}
"Sales order address type enumeration."
enum AddressType {
"Shipment address"
SHIPMENT_ADDRESS
"Billing address"
BILLING_ADDRESS
"Other address"
OTHER
}
"Defines when a policy shall be executed."
enum ApplyPolicy {
"Before the resolver was executed."
BEFORE_RESOLVER
"After the resolver was executed."
AFTER_RESOLVER
"The policy is applied in the validation step before the execution."
VALIDATION
}
"The state of a bill of materials."
enum BillOfMaterialsState {
"The bill of materials is a draft. It can still be modified. It cannot be produced yet."
DRAFT
"The bill of materials is the one used by default for production. It can no longer be modified. It can be produced."
DEFAULT
"The bill of materials has been archived. It can no longer be modified. It can no longer be produced."
ARCHIVED
"The bill of materials is an alternative to the default bill of materials. It can no longer be modified. It can be produced."
ALTERNATIVE
"The bill of materials is used to customize a production order. It can no longer be modified. It can only be produced in connection with the production order for which it was created."
PRODUCTION_ORDER_CUSTOMIZATION
"The bill of materials is marked as deleted. Bills of materials marked as deleted can generally no longer be retrieved."
DELETED
}
"Type of bill of materials item."
enum BillOfMaterialsType {
"None"
NONE
"BillOfMaterials"
BILL_OF_MATERIALS
"Component"
COMPONENT
}
"Defines requirements for the production input of a bill of materials component regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum ComponentPostingsInventoryAccountingDataRequirements {
"Any requirements for the production input of a bill of materials component are specified by the containing bill of materials."
INHERITED
"For the production input of a bill of materials component, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of a bill of materials component, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Type of configuration item."
enum ConfigurationItemType {
"None"
NONE
"ConfigurationItem"
CONFIGURATION_ITEM
"Component"
COMPONENT
}
"Defines requirements for the production input of a bill of materials component regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum CreateComponentPostingsInventoryAccountingDataRequirements {
"Any requirements for the production input of a bill of materials component are specified by the containing bill of materials."
INHERITED
"For the production input of a bill of materials component, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of a bill of materials component, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Defines requirements for the production input of all components of a bill of materials regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum CreateOverallComponentPostingsInventoryAccountingDataRequirements {
"For the production input of all components of a bill of materials, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of all components of a bill of materials, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Indicates how a product’s shelf life end date is calculated after completing a lot."
enum CreateShelfLifeEndDateGenerationMode {
"The product’s shelf life end date is based on the earliest shelf life end date of the components used."
EARLIEST
"The product’s shelf life end date is based on the latest shelf life end date of the components used."
LATEST
"The product’s shelf life end date is based on the production date plus a separately configurable time span."
PRODUCTION_DATE
}
enum CustomFieldReferenceType {
"Item\/Product (Artikel)"
ITEM
"Category (Kategorie)"
CATEGORY
"Customer (Kunde)"
CUSTOMER
"Sales Order (Auftrag)"
SALES_ORDER
"Company (Firma)"
COMPANY
"Production Order"
PRODUCTION_ORDER
"Operations"
OPERATIONS
}
enum CustomFieldType {
"No specific type (Kein)"
NONE
"Integer number (Ganzzahl)"
INTEGER
"Floating point number (FliesskommaZahl)"
FLOATING_POINT_NUMBER
"Free text"
FREE_TEXT
"Boolean checkbox"
CHECKBOX
"Selection list"
LIST
"Website URL"
URL
"Email address"
E_MAIL
"Phone number (TelNr)"
PHONE_NUMBER
"Country ISO code (LandIso)"
COUNTRY_ISO
"Price\/Currency (Preis)"
PRICE
"Date (Datum)"
DATE
"Short text (KurzText)"
SHORT_TEXT
}
"The type of customer address."
enum CustomerAddressType {
"Address to which the goods are sent."
SHIPMENT_ADDRESS
"Address used for invoicing and payment documents."
BILLING_ADDRESS
"Address without direct relation to delivery or billing."
OTHER
}
"""
Search fields available for customer quick search.
Values correspond to nId in tKunde_suche.
"""
enum CustomerSearchField {
"Customer name (first name + last name permutations)."
NAME
"Company name."
COMPANY_NAME
"Additional company line."
ADDITIONAL_COMPANY_LINE
"Email address."
EMAIL_ADDRESS
"eBay user name."
EBAY_NAME
"Phone number."
PHONE_NUMBER
"VAT identification number."
VAT_ID
"Street address."
STREET
"City."
CITY
"Postal code."
POSTAL_CODE
"Customer number."
CUSTOMER_NUMBER
"Mobile phone number."
MOBILE_PHONE_NUMBER
}
"The type of search operator used for customer quick search."
enum CustomerSearchOperator {
"Matches values that start with the search term."
STARTS_WITH
"Matches values that contain the search term."
CONTAINS
}
"Status of delivery completion for a sales order"
enum DeliveryCompleteStatus {
"The order is not completely delivered."
DELIVERY_NOT_COMPLETE
"The order is delivered with a delivery note."
DELIVERY_COMPLETE
"The order has been delivered without a delivery note."
DELIVERY_COMPLETE_WITHOUT_DELIVERY_NOTE
}
"Status of a delivery"
enum DeliveryStatus {
"Cancelled"
CANCELLED
"Open"
OPEN
"PartiallyOnDeliveryNote"
PARTIALLY_ON_DELIVERY_NOTE
"CompletelyOnDeliveryNote"
COMPLETELY_ON_DELIVERY_NOTE
"PartiallyShipped"
PARTIALLY_SHIPPED
"CompletelyShipped"
COMPLETELY_SHIPPED
"Credited"
CREDITED
"CompletedWithoutShipment"
COMPLETED_WITHOUT_SHIPMENT
}
enum ExpiredComponentsUsage {
"The use of components with expired best-before date is not permitted."
NOT_PERMITTED
"The use of components with expired best-before date is permitted."
PERMITTED
}
"Type of external sales invoice"
enum ExternalSalesInvoiceType {
"None"
NONE
"NoInvoiceNoOutput"
NO_INVOICE_NO_OUTPUT
"NoInvoice"
NO_INVOICE
}
"Payment status of the document."
enum InvoicePaymentStatus {
"The document is unpaid."
UNPAID
"The document is partially paid."
PARTIALLY_PAID
"The document is completely paid."
COMPLETELY_PAID
"The payment status cannot be determined."
NOT_DETERMINABLE
}
"Status of a sales invoice"
enum InvoiceStatus {
"Not invoiced"
NOT_INVOICED
"Partially invoiced"
PARTIALLY_INVOICED
"Completely invoiced"
COMPLETELY_INVOICED
}
"Type of item description"
enum ItemDescriptionType {
"None"
NONE
"Brief"
BRIEF
"Long"
LONG
}
"An enum of all supported item search fields."
enum ItemSearchField {
"The item SKU."
ITEM_NUMBER
"The item GTIN (former EAN)."
GTIN
"The item number of the manufacturer (HAN)."
MANUFACTURER_NUMBER
"The item UPC."
UPC
"The item ISBN."
ISBN
"The item name."
NAME
"The item's container GTIN."
CONTAINER_GTIN
"The item ASIN."
ASIN
"The item's supplier item id."
SUPPLIER_ITEM_NUMBER
"The item's container UPC."
CONTAINER_UPC
"The item FNSKU."
FNSKU
"The item JFSKU."
JFSKU
"The item subset number."
SUBSET_NUMBER
"The shop search terms."
META_KEYWORDS
}
"Specifies whether item properties should be replaced or attached when copying."
enum ItemSettingCopyAction {
"Replaces all existing information with the copied data."
REPLACE
"Attaches\/appends the copied information to existing data without replacing it."
ATTACH
}
"Type of line item."
enum LineItemType {
"Custom line item"
CUSTOM
"Item"
ITEM
"Shipping"
SHIPPING
"Coupon"
COUPON
"Voucher"
VOUCHER
"Payment"
PAYMENT
"ShippingSurcharge"
SHIPPING_SURCHARGE
"NewCustomerCoupon"
NEW_CUSTOMER_COUPON
"CashOnDelivery"
CASH_ON_DELIVERY
"ShippingSurchargeItem"
SHIPPING_SURCHARGE_ITEM
"Packing"
PACKING
"GiftForFree"
GIFT_FOR_FREE
"TrustedShops"
TRUSTED_SHOPS
"InterestPremium"
INTEREST_PREMIUM
"ProcessingFee"
PROCESSING_FEE
"Carton"
CARTON
"ReturnDelivery"
RETURN_DELIVERY
"MultiPurposeVoucher"
MULTI_PURPOSE_VOUCHER
"MultiPurposeVoucherDigital"
MULTI_PURPOSE_VOUCHER_DIGITAL
"SinglePurposeVoucher"
SINGLE_PURPOSE_VOUCHER
"SinglePurposeVoucherDigital"
SINGLE_PURPOSE_VOUCHER_DIGITAL
"SinglePurposeVoucherRedemption"
SINGLE_PURPOSE_VOUCHER_REDEMPTION
}
"Defines the type of lot size configuration for a production item."
enum LotType {
"Fixed lot sizes are defined for the production item."
OWN
"No lot sizes are defined for the production item. The quantity to be produced must always be specified when creating a production order or at the start of an ad-hoc production."
NONE
}
"API mode type for marketplace seller metadata and event entries."
enum MarketplaceApiModeType {
"Event-based download state."
EVENT
"Metadata polling-based download state."
METADATA
"Report download state."
REPORT
"Channel download state."
CHANNEL
"Metadata pull-based download state."
METADATA_PULL
}
"Defines the origin of an external document."
enum MarketplaceExternalDocumentOrigin {
"The document originates from Wawi."
WAWI
"The document originates from an external source."
EXTERNAL
}
"Defines the type of an external document."
enum MarketplaceExternalDocumentType {
"The document is an invoice."
INVOICE
"The document is a credit note (invoice correction)."
CREDIT_NOTE
}
"Defines the status of an invoice correction upload request."
enum MarketplaceInvoiceCorrectionUploadStatus {
"The invoice correction upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The invoice correction upload is in an error state."
ERROR
}
"Invoice document transfer mode between seller and channel."
enum MarketplaceInvoiceDocumentTransferType {
"Neither upload nor download of documents is supported."
NOT_SUPPORTED
"Documents are uploaded from the seller to the channel."
FROM_SELLER
"Documents are imported from the channel."
FROM_CHANNEL
}
"Defines the print (PDF generation) status of an invoice or invoice correction PDF upload."
enum MarketplaceInvoicePdfPrintStatus {
"Further print attempts are available."
HAS_REMAINING_ATTEMPTS
"No further print attempts are available."
NO_REMAINING_ATTEMPTS
"The PDF has been generated successfully."
PDF_GENERATED
}
"Defines the upload status of an invoice or invoice correction PDF upload."
enum MarketplaceInvoicePdfUploadStatus {
"Further upload attempts are available."
HAS_REMAINING_ATTEMPTS
"No further upload attempts are available."
NO_REMAINING_ATTEMPTS
"The upload has been completed successfully."
UPLOAD_COMPLETED
}
"Defines the severity level of a marketplace notification."
enum MarketplaceNotificationSeverity {
"Informational notification."
INFO
"Warning notification."
WARNING
"Error notification."
ERROR
}
"Defines the type of a marketplace notification."
enum MarketplaceNotificationType {
"Offer-related notification."
OFFERS
"Order-related notification."
ORDERS
"Return-related notification."
RETURNS
"Credit note-related notification."
CREDIT_NOTES
"Outdated categories in offers notification."
OUTDATED_CATEGORIES_IN_OFFERS
"Invoice-related notification."
INVOICES
"Metadata changed notification."
META_DATA_CHANGED
}
"Strategy for automatically mapping SCX offers to products."
enum MarketplaceOfferAutomappingType {
"Matches offers based on the product SKU."
SKU
"Matches offers based on the product EAN."
EAN
"Matches offers directly by the internal product ID."
PRODUCT_ID
}
"Type of an SCX offer."
enum MarketplaceOfferType {
"Offer that is assigned to an article."
WAWI_OFFER
"External offer without article assignment."
EXTERNAL_OFFER
}
"Combined lifecycle and action status of an SCX offer."
enum MarketplaceOfferViewStatus {
"No pending action."
NOTHING_TO_DO
"Offer is ready and waiting for upload."
WAITING_FOR_UPLOAD
"Offer has been uploaded to SCX, waiting for channel response."
UPLOADED
"Offer is being reviewed by the channel."
IN_REVIEW
"Offer is actively listed on the channel."
LISTED
"Offer has been ended or terminated."
ENDED
"Offer has an error reported by the channel."
ERROR
"Offer needs to be created."
PENDING_CREATION
"Offer needs to be updated."
PENDING_UPDATE
"Offer is scheduled for deletion."
PENDING_DELETION
"Transfer is blocked for this seller."
TRANSFER_BLOCKED
}
"Defines the upload status of an order cancellation request."
enum MarketplaceOrderCancellationRequestUploadStatus {
"The cancellation request upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The cancellation request upload has failed."
ERROR
}
"Defines the upload status of order cancellation information sent from Wawi to the marketplace."
enum MarketplaceOrderCancellationUploadStatus {
"The order cancellation information is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The upload of order cancellation information has failed."
ERROR
}
"Order confirmation strategy."
enum MarketplaceOrderConfirmType {
"Always accept the order."
ALWAYS_ACCEPT
"Accept the order only when there is enough stock."
ACCEPT_ONLY_WHEN_ENOUGH_STOCK
}
"Defines the status of a payment upload request."
enum MarketplacePaymentUploadStatus {
"The payment upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The payment upload is in an invalid state."
ERROR
}
"Transmission behavior for refunds to the marketplace."
enum MarketplaceRefundTransmissionType {
"Refunds are always transmitted to the marketplace."
ALWAYS
"Refunds are never transmitted to the marketplace."
NEVER
"Transmission is determined individually per refund."
ON_SETTING_PER_REFUND
}
"Transmission behavior for return information to the marketplace."
enum MarketplaceReturnTransmissionType {
"Return information is always transmitted."
ALWAYS
"Return information is never transmitted."
NEVER
"Transmission is determined individually per return."
ON_SETTING_PER_RETURN
}
"Defines the status of a return upload request."
enum MarketplaceReturnUploadStatus {
"The return upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The return upload is in an invalid state."
ERROR
}
"Defines the status of a shipping information upload request."
enum MarketplaceShippingInformationUploadStatus {
"The shipping information upload is pending and waiting to be uploaded."
WAITING_FOR_UPLOAD
"The shipping information upload is in an invalid state."
ERROR
}
"Defines the status of an upload queue entry."
enum MarketplaceUploadQueueStatus {
"The entry has been queued and the PDF generation process can start."
WAITING_FOR_PDF_GENERATION
"The entry has been selected for PDF generation and will be processed shortly."
QUEUED_FOR_PDF_GENERATION
"PDF generation has started."
PDF_GENERATION_STARTED
"PDF generation is finished and the upload can be performed."
WAITING_FOR_UPLOAD
"The upload has been completed."
UPLOAD_COMPLETED
}
"Defines requirements for the production input of all components of a bill of materials regarding the shelf life end dates or batch numbers of the stock accounts to be debited."
enum OverallComponentPostingsInventoryAccountingDataRequirements {
"For the production input of all components of a bill of materials, inventory can be posted from all stock accounts of the respective item."
NONE
"For the production input of all components of a bill of materials, inventory can only be posted from stock accounts with matching shelf life end dates or matching batch numbers."
IDENTICAL
}
"Defines the type of manufacturing of a production item."
enum ProductionType {
"The production item is always manufactured in the same way according to its production bill of materials."
REGULAR
"The production item and\/or its production bill of materials have customizable properties (e.g., process parameters or configuration groups)."
CUSTOMIZED
}
"Access level for modifying the sales order"
enum ReadOnlyType {
"ChangesAllowed"
CHANGES_ALLOWED
"InvoicedExternally"
INVOICED_EXTERNALLY
"ChangesForbidden"
CHANGES_FORBIDDEN
}
"Determines how a line item price is recalculated when its quantity changes."
enum RecalculateLineItemPriceChangeMode {
"Use the calculated price (based on the new quantity, including discount and scale prices)."
USE_CALCULATED_PRICE
"Keep the current price."
USE_CURRENT_PRICE
}
"Determines how a line item price is recalculated when its quantity changes."
enum RecalculateLineItemPriceResult {
"No price change. The line item price remains the same after recalculation."
NONE
"SalesPricesNet was changed after recalculation."
SALES_PRICE_NET
"DiscountPercent was changed after recalculation."
DISCOUNT_PERCENT
SALES_PRICE_NET_AND_DISCOUNT_PERCENT
}
enum RecalculateTaxMode {
"No recalculation, even if tax-relevant fields have been changed."
NO_RECALCULATION
"Keep net prices (change in VAT rate is borne by the customer)"
KEEP_NET_PRICES
"Maintain gross prices (changes in VAT rate are borne by the retailer)"
KEEP_GROSS_PRICES
}
enum ReplenishmentCreationAvailableStockReservationMode {
"Available stock is not reserved for the production session when a replenishment order is created."
NONE
"Available stock is reserved for the production session based on a user prompt when a replenishment order is created."
USER_PROMPT
"Available stock is automatically reserved for the production session when a replenishment order is created."
AUTO
}
enum ReservationMode {
"The reservation is carried out for each operation of a production."
OPERATION
"The reservation is carried out per run (lot) of a production (for all operations at once)."
ITERATION
"The reservation is carried out directly for the entire production session (i.e., all operations of all runs\/lots)."
SESSION
}
"Type of a sales channel."
enum SalesChannelType {
"no type"
JTL_WAWI
"integer"
ONLINE_SHOP
"decimal"
JTL_POS
"text"
EBAY
"check box"
UNICORN
"list"
SCX
"TODO"
JTL_FULFILLMENT_NETWORK
"TODO"
REST_API
"TODO"
XML_IMPORT
"TODO"
AMAZON
"TODO"
JTL_BI
}
"Tax setting for the sales invoice"
enum SalesInvoiceTaxSetting {
"Delivery with VAT"
DELIVERY_WITH_VAT
"Intra-community delivery"
INTRA_COMMUNITY_DELIVERY
"Exempt from VAT – reverse charge"
EXEMPT_FROM_VAT_REVERSE_CHARGE
"Exempt from VAT"
EXEMPT_FROM_VAT
}
"EnumValuekeys beziehen sich auf FunctionOperatorType"
enum SearchOperator {
STARTS_WITH
CONTAINS
WILDCARD
}
"Type of bill of materials item."
enum SerialNumberTrackingMode {
"No serial number tracking."
NONE
"Serial number tracking for outgoing goods."
OUTGOING
"Serial number tracking for outgoing and incoming goods."
OUTGOING_INCOMING
"Serial number tracking for all movements of goods."
ALL
}
"Enumeration that defines the type of serial number management for an item. Determines whether and how serial numbers are processed for stock movements and sales."
enum SerialNumberType {
"Serial numbers are inactive. The item does not require or use serial numbers for tracking."
NO_SERIAL_NUMBERS
"Serial numbers are active. The item requires a serial number to be assigned during stock movements."
SERIAL_NUMBERS_ACTIVE
"Serial numbers are being tracked. The item requires serial numbers and maintains a full tracking history of all movements."
SERIAL_NUMBERS_TRACKING
}
"Indicates how a product’s shelf life end date is calculated after completing a lot."
enum ShelfLifeEndDateGenerationMode {
"The product’s shelf life end date is based on the earliest shelf life end date of the components used."
EARLIEST
"The product’s shelf life end date is based on the latest shelf life end date of the components used."
LATEST
"The product’s shelf life end date is based on the production date plus a separately configurable time span."
PRODUCTION_DATE
}
"Enumeration of blocking reason types that prevent a sales order from being shipped."
enum ShippingEligibilityBlockingReasonType {
"Unknown or unrecognized blocking reason."
UNKNOWN
"The article is a variant parent and cannot be delivered directly."
PARENT_ITEM
"The order is on hold (a hold reason is assigned)."
ORDER_ON_HOLD
"The customer is blocked."
CUSTOMER_BLOCKED
"The document is not an order (e.g. a quotation)."
NOT_AN_ORDER
"The order has not been paid yet."
UNPAID
"No shipping method has been assigned to the order."
NO_SHIPPING_METHOD
"A shipping lock is active on the position."
SHIPPING_LOCK
"The order has already been fully delivered."
ALREADY_DELIVERED
}
"Indicates the shipping eligibility status of a sales order based on stock availability."
enum ShippingEligibilityStatus {
"The order is not eligible for shipping due to insufficient stock."
NOT_ELIGIBLE
"The order is partially eligible for shipping (some items have stock)."
PARTIALLY_ELIGIBLE
"The order is fully eligible for shipping (all items have sufficient stock)."
FULLY_ELIGIBLE
}
enum SortEnumType {
ASC
DESC
}
"Special tax treatment options for sales invoices"
enum SpecialTaxTreatment {
"None"
NONE
"ReverseCharge"
REVERSE_CHARGE
"ExemptFromVat"
EXEMPT_FROM_VAT
"SubjectToVat"
SUBJECT_TO_VAT
}
"The current state of a worker sync."
enum SyncState {
"Exited."
SUSPENDED
"The sync is starting."
STARTING
"The sync is currently running."
RUNNING
"The sync finished successfully."
SUCCESSFULL_FINISHED
"The sync finished with errors."
SLEEPING_ERROR
"The sync is exiting."
STOPPING
"The sync finished with errors and is locked."
SLEEPING_ERROR_GESPERRT
"The sync is disabled."
DEACTIVATED
}
"Special tax treatment options for tax calculation."
enum TaxDomainSpecialTaxTreatment {
"None"
NONE
"ReverseCharge"
REVERSE_CHARGE
"ExemptFromVat"
EXEMPT_FROM_VAT
"SubjectToVat"
SUBJECT_TO_VAT
}
"This setting controls which data is used during tax calculation."
enum TaxDomainTaxReference {
"Shipment address is used for tax calculation."
SHIPMENT_ADDRESS
"Billing address is used for tax calculation."
BILLING_ADDRESS
}
"Type of line item for tax rate key assignments."
enum TaxLineItemType {
"Custom line item"
CUSTOM
"Item"
ITEM
"Shipping"
SHIPPING
"Coupon"
COUPON
"Voucher"
VOUCHER
"Payment"
PAYMENT
"Shipping surcharge"
SHIPPING_SURCHARGE
"New customer coupon"
NEW_CUSTOMER_COUPON
"Cash on delivery"
CASH_ON_DELIVERY
"Shipping surcharge item"
SHIPPING_SURCHARGE_ITEM
"Packing"
PACKING
"Gift for free"
GIFT_FOR_FREE
"TrustedShops"
TRUSTED_SHOPS
"Interest premium"
INTEREST_PREMIUM
"Processing fee"
PROCESSING_FEE
"Carton"
CARTON
"Return delivery"
RETURN_DELIVERY
"Multi-purpose voucher"
MULTI_PURPOSE_VOUCHER
"Multi-purpose voucher (digital)"
MULTI_PURPOSE_VOUCHER_DIGITAL
"Single-purpose voucher"
SINGLE_PURPOSE_VOUCHER
"Single-purpose voucher (digital)"
SINGLE_PURPOSE_VOUCHER_DIGITAL
"Single-purpose voucher redemption"
SINGLE_PURPOSE_VOUCHER_REDEMPTION
}
"The tax reference controls which data is used during tax calculation."
enum TaxReference {
"Shipment address is used for tax calculation."
SHIPMENT_ADDRESS
"Billing address is used for tax calculation."
BILLING_ADDRESS
}
"Tax setting for the sales order"
enum TaxSetting {
"Delivery with VAT"
DELIVERY_WITH_VAT
"Intra-community delivery"
INTRA_COMMUNITY_DELIVERY
"Exempt from VAT – reverse charge"
EXEMPT_FROM_VAT_REVERSE_CHARGE
"Exempt from VAT"
EXEMPT_FROM_VAT
}
"Represents the type of a tax class"
enum TaxType {
"No tax type"
NONE
"Super reduced tax rate"
SUPER_REDUCED
"Reduced low tax rate"
REDUCED_LOW
"Reduced tax rate"
REDUCED
"Standard tax rate"
STANDARD
"Intermediate tax rate"
INTERMEDIATE
}
enum VariationType {
"Undefined VariationType. This should never be used."
UNKNOWN
"A simple dropdown. One value can be selected. In variation combinations, incompatible options are greyed out. Variation children are not allowed to use this type."
SELECTBOX
"Same functionality as Dropdown, but presented as classic radio buttons. Variation children are not allowed to use this type."
RADIOBUTTON
"Same functionality as Dropdown or Radio button. Displays as buttons with descriptions or images (similar to Amazon). Variation children are not allowed to use this type."
SWATCHES
"Same functionality as Dropdown, Radio button, or Swatches. Display is text-only (like on Amazon). Variation children are not allowed to use this type."
TEXTBOX
"Cannot have predefined values. Optional free text input by the user. Variation children are allowed to use this type."
FREE_TEXT
"Cannot have predefined values. Required free text input by the user. Variation children are allowed to use this type."
MANDATORY_FREE_TEXT
}
"Determines the source for VAT ID resolution in a tax zone."
enum VatIdSource {
"VAT ID is resolved from tax determination logic."
FROM_DETERMINATION
"VAT ID is resolved from the company headquarters location."
FROM_COMPANY_LOCATION
"VAT ID is resolved from the departure country."
FROM_DEPARTURE_COUNTRY
}
"The control action that can be requested for a worker sync."
enum WorkerControlAction {
"Start the sync."
START
"Stop the sync."
STOP
"Restart the sync."
RESTART
}
"The authorize directive."
directive @authorize("The name of the authorization policy that determines access to the annotated resource." policy: String "Roles that are allowed to access the annotated resource." roles: [String!] "Defines when when the authorize directive shall be applied.By default the authorize directives are applied during the validation phase." apply: ApplyPolicy! = BEFORE_RESOLVER) repeatable on OBJECT | FIELD_DEFINITION
"The purpose of the `cost` directive is to define a `weight` for GraphQL types, fields, and arguments. Static analysis can use these weights when calculating the overall cost of a query or response."
directive @cost("The `weight` argument defines what value to add to the overall cost for every appearance, or possible appearance, of a type, field, argument, etc." weight: String!) on SCALAR | OBJECT | FIELD_DEFINITION | ARGUMENT_DEFINITION | ENUM | INPUT_FIELD_DEFINITION
"The purpose of the `@listSize` directive is to either inform the static analysis about the size of returned lists (if that information is statically available), or to point the analysis to where to find that information."
directive @listSize("The `assumedSize` argument can be used to statically define the maximum length of a list returned by a field." assumedSize: Int "The `slicingArguments` argument can be used to define which of the field's arguments with numeric type are slicing arguments, so that their value determines the size of the list returned by that field. It may specify a list of multiple slicing arguments." slicingArguments: [String!] "The `slicingArgumentDefaultValue` argument can be used to define a default value for a slicing argument, which is used if the argument is not present in a query." slicingArgumentDefaultValue: Int "The `sizedFields` argument can be used to define that the value of the `assumedSize` argument or of a slicing argument does not affect the size of a list returned by a field itself, but that of a list returned by one of its sub-fields." sizedFields: [String!] "The `requireOneSlicingArgument` argument can be used to inform the static analysis that it should expect that exactly one of the defined slicing arguments is present in a query. If that is not the case (i.e., if none or multiple slicing arguments are present), the static analysis may throw an error." requireOneSlicingArgument: Int! = 1) on FIELD_DEFINITION
"The `@specifiedBy` directive is used within the type system definition language to provide a URL for specifying the behavior of custom scalar definitions."
directive @specifiedBy("The specifiedBy URL points to a human-readable specification. This field will only read a result for scalar types." url: String!) on SCALAR
"The `Byte` scalar type represents non-fractional whole numeric values. Byte can represent values between 0 and 255."
scalar Byte
"The `DateTime` scalar represents an ISO-8601 compliant date time type."
scalar DateTime @specifiedBy(url: "https:\/\/www.graphql-scalars.com\/date-time")
"The `Decimal` scalar type represents a decimal floating-point number."
scalar Decimal
"The `Long` scalar type represents non-fractional signed whole 64-bit numeric values. Long can represent values between -(2^63) and 2^63 - 1."
scalar Long
"The `TimeSpan` scalar represents an ISO-8601 compliant duration type."
scalar TimeSpan
scalar URL @specifiedBy(url: "https:\/\/tools.ietf.org\/html\/rfc3986")
scalar UUID @specifiedBy(url: "https:\/\/tools.ietf.org\/html\/rfc4122")
```
# Vouchers API
Source: https://developer.jtl-software.com/api-reference/voucher
Create, manage, and redeem vouchers in JTL Voucher Cloud.
The Vouchers API lets you issue vouchers, control their lifecycle (activate, reserve, charge, refund, recharge), and manage client access. It is built on OAuth 2 client credentials and supports both production and sandbox environments.
Set up a client, get credentials, create your first voucher, and run through the full charge flow.
Error response format and all validation error codes grouped by operation.
The Vouchers API has its own OAuth 2 server and a pin-based credential exchange. See the quickstart for the token endpoint and setup steps.
## Environments
| Environment | Base URL |
| ----------- | ---------------------------------------------- |
| Production | `https://vouchers.api.jtl-software.com/v1` |
| Sandbox | `https://vouchers-sbx.api.jtl-software.com/v1` |
## OpenAPI Spec
Import into Postman, Insomnia, or generate a client: [Download JSON](/openapi/voucher.json).
# Refund a specific voucher charge
Source: https://developer.jtl-software.com/api-reference/voucher/charges/refund-a-specific-voucher-charge
/openapi/voucher.json post /charges/{id}/refund
This call is used to (partial) refund a specific charge that was previously done on a voucher (for example if a customer returns goods to the store).
# Connects a client
Source: https://developer.jtl-software.com/api-reference/voucher/clients/connects-a-client
/openapi/voucher.json post /clients/connect
Exchanges temporary pin for full oauth client credentials
# Disconnects a client
Source: https://developer.jtl-software.com/api-reference/voucher/clients/disconnects-a-client
/openapi/voucher.json post /clients/disconnect
Disconnects the client from the voucher cloud and resets all credentials
# Charge a specific voucher reservation
Source: https://developer.jtl-software.com/api-reference/voucher/reservations/charge-a-specific-voucher-reservation
/openapi/voucher.json post /reservations/{id}/charge
Charges the previously created temporary reservation on a voucher.
# Set the reservation for a specific voucher
Source: https://developer.jtl-software.com/api-reference/voucher/reservations/set-the-reservation-for-a-specific-voucher
/openapi/voucher.json post /reservations
This call temporary reserves an amount on a specific voucher, that can later be charged.
A reservation expires after 30 minutes or in case a new one is requested for this voucher.
# Create a new voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/create-a-new-voucher
/openapi/voucher.json post /vouchers
Use this call to create a new voucher
# Delete a voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/delete-a-voucher
/openapi/voucher.json delete /vouchers/{id}
A voucher can only be deleted when it has no charges yet.
# Get a charge of a voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/get-a-charge-of-a-voucher
/openapi/voucher.json get /vouchers/{id}/charges/{charge_id}
Use this call to get a specific charge of a voucher.
# Get a complete voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/get-a-complete-voucher
/openapi/voucher.json get /vouchers/{id}/complete
Use this call to get a voucher with its secret properties *code* and *pin*.
# Get a list of voucher charges
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/get-a-list-of-voucher-charges
/openapi/voucher.json get /vouchers/{id}/charges
This call will give you a paginated list of voucher charges.
# Get a list of vouchers
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/get-a-list-of-vouchers
/openapi/voucher.json get /vouchers
This call will give you a paginated list of vouchers.
# Get a voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/get-a-voucher
/openapi/voucher.json get /vouchers/{id}
Use this call to get a specific single voucher. Please note that you wont get the vouchers secret properties *code* and *pin* (use the vouchers/{id}/complete call instead).
# Recharge a voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/recharge-a-voucher
/openapi/voucher.json post /vouchers/recharge
Use this call to recharge a voucher. This can be used for example for customer cards. Please note that this call is not used for cancelations of previously charges.
# Set the status for a voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/set-the-status-for-a-voucher
/openapi/voucher.json patch /vouchers/{id}/status
This call is used to activate or deactivate a specific voucher.
# Update a voucher
Source: https://developer.jtl-software.com/api-reference/voucher/vouchers/update-a-voucher
/openapi/voucher.json patch /vouchers/{id}
Due to security restrictions only the sku and batch property can be updated on inactive vouchers
# Changelog
Source: https://developer.jtl-software.com/help/changelog
Platform releases, API changes, SDK updates, and developer-facing improvements for the JTL Platform.
Track platform updates, API changes, SDK releases, deprecations, and developer-facing fixes across the JTL Platform.
The most recent updates appear first.
| Badge | Meaning |
| -------------- | --------------------------------------------------------------- |
| | A change that requires action to keep your integration working. |
| | A new endpoint, feature, or capability. |
| | Existing behaviour has changed. |
| | A feature is scheduled for removal in a future release. |
| | A previously deprecated feature has been removed. |
| | A bug has been resolved. |
| | A security-related update or hardening change. |
Version tags identify the API version an entry applies to. Entries without a version tag affect the broader platform, SDKs, Partner Portal, documentation, or tooling.
***
## 2026-04-15 · App Manifest 2.0 is now the default
`Cloud Apps` `Manifest` `Partner Portal`
The App Manifest format is moving from `1.0` to `2.0`.
Manifest 2.0 separates runtime configuration from listing and marketing metadata. Technical fields remain in the manifest file, while marketing content such as app names, descriptions, icons, and screenshots move into a dedicated Listing system managed through the Partner Portal.
### Added
* New top-level fields:
* `manifest` section with `technicalName` and `lifecycle.configurationUrl`
* `listing` section with marketing metadata
These are now managed through the Partner Portal UI.
Manifest 1.0 is not backward compatible after the migration cutover completes.
### Action Required
* Update manifest file to version `2.0`
* Move marketing metadata into the `listing` section
***
## 2026-03-05 · Cloud API v2.0 is now the default
`v2.0`
`API` `Cloud API` `GraphQL` `OnPremise API`
API Reference now defaults to `v2.0`.
Earlier versions (`v1.0` through `v1.4`) remain available through the version selector, but new integrations should target `v2.0`.
Cloud API continues to use URL-path versioning.
Example:
```txt theme={null}
https://api.jtl-cloud.com/erp/v2/graphql
```
OnPremise APIs continue to use header-based versioning with:
```txt theme={null}
api-version: 2.0
```
# Service Status
Source: https://developer.jtl-software.com/help/status-page
Check the operational status of the JTL services that Cloud Apps depend on.
The JTL Platform runs on a shared infrastructure that also serves JTL-Hosting and JTL-Shipping. When that infrastructure is disrupted, APIs, the Hub, and the services your integration depends on may be affected. The pages below are the right places to check when something is not behaving as expected.
## Status Pages
JTL operates three public status pages. Each one covers a different layer of the platform.
Current and historical disruptions to JTL-Hosting. This is the right starting point if APIs are timing out or platform services are unreachable from your integration.
Live status of JTL-Shipping integrations with carriers such as DHL, DPD, and Deutsche Post. Useful when shipment label creation or carrier sync is failing in integrations that touch shipping.
A connectivity check that verifies whether JTL systems are reachable from your network. Useful for ruling out a local network or firewall issue before opening a support ticket.
Bookmark these pages so you can reach them quickly when troubleshooting an integration issue. If none of the status pages report an incident but your integration is still failing, the next step is to gather your request details and reach out through [Support](/help/support).
## What's Next?
Troubleshoot API errors, validation failures, and retry behaviour.
Reach the JTL team when a status page does not explain what you are seeing.
See what has changed across recent platform releases.
# Support
Source: https://developer.jtl-software.com/help/support
Developer resources, support channels, and community spaces for building on the JTL Cloud Platform.
Support channels and community spaces for developers building on the JTL Cloud Platform.
## Quick Links
Register apps, manage integrations, and access partner resources.
Browse the full API reference for the current stable version.
Implementation guides for authentication, webhooks, Cloud Apps, and more.
Troubleshoot API errors, validation failures, and retry behaviour.
## Support Channels
Different channels are best suited for different kinds of questions. Use the one that matches the type of help you need.
### Discord
The JTL Cloud developer Discord is the fastest place for:
* Quick implementation questions
* Architecture discussions
* Integration feedback
* Community troubleshooting
Both JTL staff and other developers participate in discussions.
Ask questions, share what you're building, and get help from the community and JTL staff.
Open to everyone - no invite required.
***
### Email Support
Best for:
* Account-specific questions
* Production issues
* Private discussions
* Cases where you want a written support thread
Contact the JTL Cloud team
General questions and feedback can always be sent to the Cloud team by email.
***
### Partner Ticket System
Existing JTL partners with a Customer Center Account can create support tickets directly through the JTL support system.
Best for:
* Escalated support requests
* Partner-specific issues
* Operational problems requiring formal tracking
* Longer-running investigations
Open the JTL support ticket system
Available to existing partners only.
The ticket system is currently available in German.
***
### GitHub
JTL's GitHub organisation hosts:
* SDKs
* Sample apps
* Starter templates
* Open-source tooling
Use GitHub issues to:
* report bugs
* request improvements
* contribute fixes or feedback for JTL-maintained repositories
Browse repositories and open issues
Open to anyone with a GitHub account.
For platform-specific issues unrelated to a repository, use Discord, email, or the support ticket system instead.
***
### Community Forum
The JTL community forum is the largest public discussion space for the ecosystem, including:
* Cloud Platform
* JTL-Wawi
* JTL-Shop
* OnPremise APIs
* Shipping integrations
Searching existing threads first is recommended; many common integration questions already have answers.
Browse discussions and ask questions
Replies may come from community members, partners, or JTL staff.
## Before Contacting Support
Including the right details in your first message usually leads to faster resolutions.
### For Technical Questions
Include:
* Your `appId`
* Whether you're working in development or production
* The API endpoint involved, including method and path
* The full error response and status code
* A minimal reproduction case
* What you've already tried
### For Account or Access Questions
Include:
* Your partner account email
* Company name
* The app or tenant involved
* What you expected to happen
* What happened instead
## Additional Resources
Track platform updates, improvements, and breaking changes.
Build and deploy your first Cloud App.
Understand AppBridge events, the setup handshake, and SCX polling.
Learn how authentication and app installation work on the platform.
# API Licence Terms
Source: https://developer.jtl-software.com/legal/api_licence_terms
Terms governing the access and usage of JTL-APIs by Users.
These API Licence Terms govern the access and usage of JTL-APIs by Users and supplement the Applicable JTL General Terms and Conditions for the relationship between JTL and Users. In case of contradictions, these API Licence Terms take precedence over the Applicable General Terms and Conditions.
## 1. Definitions
Capitalized terms have the meaning defined in JTL General Terms and Conditions. In case a definition in the JTL Customer General Terms and the JTL Third-Party Provider General Terms and Conditions differs, the definition in the Applicable JTL General Terms and Conditions takes precedence.
In addition, within the scope of these API Licence Terms the following definitions apply:
“**JTL General Terms and Conditions**” comprise JTL Customer General Terms and Conditions as well as JTL Third-Party Provider General Terms and Conditions.
**“Applicable JTL General Terms and Conditions”** are, depending on the qualification of the specific User, either – in case the User is a customer of JTL (e.g. a merchant using JTL-Wawi, JTL-Shop etc.) – the JTL Customer General Terms and Conditions or – in case the User is a Third-Party Provider (e.g. the Operator of a marketplace integration) – the JTL Third-Party Provider General Terms and Conditions.
**“User”** is a customer or a Third-Party Provider accessing a JTL-API.
**“JTL-API”** is any application programming interface, including if applicable its associated tools and documentation, provided by JTL which allows Users to access certain JTL Customer Products or certain functionalities hereof in order to interconnect and exchange data with an Application; an overview of all current JTL-APIs can be found here.
**“Application”** means software application, website, interface or any other means provided or used by the User to access a JTL-API using API Credentials.
**“API Credentials”** means the credentials that allow the User or Service to authenticate in order to send authorized requests to the respective JTL-API.
**“API Documentation”** all documentation referring to specific JTL-API, including but not limited to (technical) descriptions, guidelines, tutorials, (GitHub) repositories etc.
## 2. Access / API Credentials
In order to access a JTL-API, User must obtain API Credentials for the respective JTL-API. User shall keep its API Credentials secure and may not share them with any third parties without JTL's prior written consent, unless permitted in these API Licence Terms. Sharing API Credentials with internal personnel, contractors, and other vicarious agents (e.g. external developers) is only permitted on a need-to-know basis and if the User has ensured that those internal personnel, contractors, and vicarious agents are bound to these API Licence Terms.
API Credentials are User’s sole means for an authorized access to a JTL-API, notwithstanding any additional technical access requirements specified in the respective API Documentation.
User shall immediately notify JTL in the case of loss or unauthorized use of the API Credentials by third parties.
JTL may revoke API Credentials without prior notice if there is any suspicion of unauthorized use.
## 3. Licence grant
JTL grants the User a non-exclusive, royalty-free, non-transferable, non-sublicensable, revocable right to access and use the JTL-API limited to the extent necessary to develop, implement and/or distribute User’s Application to interoperate or integrate with JTL Customer Products and solely in accordance with these API Licence Terms, the API Documentation and, if applicable, the special licence terms of the respective JTL-API.
## 4. Usage restrictions
User may not (and will ensure that its employees, contractors and other vicarious agents may not) access and use a JTL-API in violation of the API licence grant under Section 3, especially for purposes other than those specified in the licence scope, and/or in a manner that violates applicable law and/or the rights and freedoms of JTL or third parties like e.g. (other) JTL Customers or Third-Party Providers. In particular, it is prohibited to access and use JTL-APIs to substantially replicate existing JTL Customer Products, JTL Third-Party Provider Products, including JTL-APIs itself, as well as Third-Party Provider Products, unless explicitly authorized by JTL respectively the affected Third-Party Provider(s).
The extent of access and use of JTL-APIs may be technically restricted to specific API call limits as specified in the respective API Documentation.
## 5. Data Protection
Information processed when accessing and using a JTL-API, like e.g. names, contact information and transaction related data of JTL Customers’ customers may qualify as personal data respectively personal identifiable information under applicable privacy and data protection laws, in particular the GDPR in European Union.
The User is obliged to comply with the applicable privacy and data protection laws and, if applicable, data processing agreements concerning the processing of personal data within the Application received from or forwarded to a JTL-API.
In case the User is a Third-Party Provider, providing Third-Party Provider Products to JTL Customers or acting as subcontractor of such Third-Party Provider, JTL does not act as a data (sub-)processor on behalf of the such User when processing personal data received from such User’s Application via a JTL-API. Such processing of JTL Customers’ personal data by JTL is rather covered by the data processing agreement between JTL and JTL Customers. If required by applicable privacy and data protection law, such User itself may be obliged to enter into a separate data processing agreement with the respective JTL Customers (as the data controllers) regarding the processing of such personal data within User’s Application before and after the exchange via the JTL-API.
In case the User is a Third-Party Provider engaged by JTL to develop, operate and/or maintain a JTL Customer Product for which access and usage of a JTL-API is necessary, such User acts as a data processor of JTL for the processing of JTL Customers’ personal data to and from the respective JTL-API and shall enter into a data processing agreement with JTL.
## 6. Availability and modifications
Unless otherwise specified in the API Documentation and/or, if applicable, the specific licence terms of the respective JTL-API or a JTL Third-Party Provider Product where the respective JTL-API is integral part of, JTL does neither warrant nor guarantee any specific availability, restoration and/or continuation of a JTL-API and/or its technical specifications and features towards a User.
JTL may modify the JTL-APIs, its databases, any service, or any of the benefits and/or features provided in connection with the use of the JTL-APIs at any time at its reasonable discretion. Modifications may affect the Application and may require the User to make changes to the Application at their own cost to continue to be compatible with or interface with the respective JTL-API.
JTL will undertake to inform the User in a timely manner, at least 1 month prior to any modification. In case of modifications which cause breaking changes in a JTL-API, i.e. a change that will require User to amend the Application to prevent disruptions, JTL will undertake to inform the User at least 3 months prior to any of such modifications. If modifications, including those causing breaking changes, are necessary (i) to avert sudden serious errors/malfunctions, (ii) to be able to implement the necessary remedial measures in response to a data/security/cyber incident or (iii) to be able to react to circumstances outside the area of control and responsibility of JTL, like e.g. short-term technical modifications from JTL partners (e.g. connected marketplaces), JTL may implement the corresponding modifications – in deviation from the aforementioned provisions – with less prior or even without notice. In the latter case JTL will notify the User without undue delay after the implementation of such modifications.
## 7. Monitoring of the API
JTL may monitor and audit any Application interacting with a JTL-API. Monitoring by JTL includes Application interactions such as JTL-API endpoints being consumed, error rates, amount and frequency of requests/calls.
At JTL's request, the User will provide JTL free sufficient access to the Application for the strict purpose of monitoring or auditing procedures / events.
The User will not seek to block or otherwise interfere with the monitoring or audit, and JTL may use technical means to overcome any methods the User may use to block or interfere with such monitoring. Audits may include requests for documents and information.
In case the User is a Third-Party Provider, the User must be in the possession of an emergency plan in case of a data breach (incident response plan for privacy and security breaches) or an operational disruption (incident response plan for operational disruptions); a copy of each plan must be provided to JTL for the purpose of carrying out an audit.
## 8. Blocking and other measures to restrict API access
If there are any indications that a JTL-API is being accessed and used by the User in violation of these API Licence Terms, the API Documentation and/or, if applicable, the specific licence of the respective JTL-API or in a manner that the stability, security and integrity of JTL Customers Products, JTL Third-Party Provider Products and/or Third-Party Provider Products, including the technical infrastructure used and data processed herein, is compromised or endangered, JTL shall be entitled to implement immediate adequate measures without previous warning to stop and prevent this access and use of the respective JTL-API. For this purpose, JTL shall in particular be entitled to either temporarily or permanently revoke User’s access to the respective JTL-API.
The decision on the appropriate remedial measure(s) in the specific case is at the sole reasonable discretion of JTL. JTL will take into account in particular the nature and extent of the violation respectively the hazardous use, its (potential) effects and the legitimate interest of the User in maintaining access to the respective JTL-API. The automatic (temporarily) blocking of access to a JTL-API to enforce the applicable API call limits pursuant section 4. b) (“rate limiting”) remains unaffected by thereof.
JTL shall use its best efforts to inform the User prior to the remedial measures to be taken. If a prior information is not possible or suitable for urgent reasons, JTL may implement remedial measures even without previous information or warning. JTL shall in this case without undue delay notify the User after such measures have been applied to User’s access and use of the JTL-API with the aim to create User awareness and, if necessary, collaboratively solve the problem and restore full operating status.
There is no entitlement to restoration of a blocked account, except if the allegations turn out to be wrong or – in case of automatic rate limiting – after expiry of the period to which the exhausted API call limit related.
## 9. User’s liability, indemnification
User shall be liable to JTL for any damages resulting from User’s access to the relevant JTL-API that does not comply with these API Licence Terms, the API Documentation and/or, if applicable, the specific licence terms of the respective JTL-API, unless User can prove that he/she is not responsible for the non-compliant usage of the JTL-API.
User shall indemnify JTL upon first demand from any liability claims raised by JTL Customers or other third parties if the User's non-compliance described in lit. a) above has resulted in JTL being unable to fulfill its contractual obligations (e.g. with regard to the availability of certain JTL Customer Products or certain functionalities hereof) towards JTL Customers.
## 10. Amendments to these API Licence Terms
JTL reserves the right to change these API Licence Terms. The provisions of § 5 of the Third-Party Terms and Conditions apply accordingly.
## 11. Final provisions
These API Licence Terms shall be governed by the Laws of the Federal Republic of Germany. The UN Convention on International Sale of Goods (CISG) shall not apply.
The place of jurisdiction for all disputes arising from this agreement is the court of JTL’s business location if the User is a merchant, legal entity governed by public law or special fund. The same shall apply if neither the domicile nor the habitual place of residence of the user is known at the time the action is filed.