Wiresphere Docs

Everything you need to work with Wiresphere — organized by audience: end users (admin system), DevOps & architects (platform, operations, concepts), and developers (SDK, CLI, APIs).

Access & Login

How to sign in to the admin system:

• Open your admin URL in the browser (e.g. https://your-domain.com/admin/login)
• Enter the username and password from your welcome email — note that they are case-sensitive
• Use the eye icon to reveal the password; "Remember login" keeps you signed in
• Forgot your password? Use "Reset password" below the login button to receive a reset link

Dashboard

The dashboard provides an overview of your company's performance and helps you track the most important metrics. Most widgets can be switched to weekly, monthly, or yearly periods via a dropdown.

Process Overview

The process overview shows all transactions and their status. Processes can be filtered (sorting, type, channel, period), analyzed, and managed.

• Table: Transaction number, customer, date, amount (net), payment status, channel, type number, and type (quote, invoice, order)
• Payment status: Paid (green) · Awaiting payment (yellow) · Pending (orange) · Due/overdue (red)
• Actions: "+ Add transaction", "Export selection", and "Apply filters"

Process Details

Clicking a process in the overview opens the detail view with all information about the process history.

• Customer & payment details: Name, customer number, email; invoice status and payment method (e.g. NFC Payment)
• Addresses: Billing and shipping address can be adjusted via the edit icon
• Item table: Item number, description, quantity, unit price, VAT, total weight, total price
• Price summary: Subtotal, discount, shipping costs, VAT, grand total
• Actions: Add item, cancel selection, print QR code, delete process, save

Managing Products

The product overview (menu "Inventory Management" → "Product Overview") lists all products with item number, net price, stock level, and status.

Creating & editing products

Create new products via "+ Add product" (item name, item number, category, price, stock level → Save). Edit existing products via the pencil icon in the table row.

Tiered pricing

In the "Tiered prices" tab of the product detail view, define a minimum quantity and price per tier; use "+ add" to add further tiers.

Add-on sellings

Add-on sales (accessories, upgrades, warranties) can be assigned directly to a main product and are automatically suggested during ordering — increasing cart value and supporting cross-selling.

Exporting / Importing Products

Export: All product data (name, item number, prices, stock levels, categories) as an XLS or CSV file — for analysis, external editing, or documentation.

Import: Revised or new product data in XLS/CSV format. The system recognizes existing products by item number and updates changed information; new products are added without overwriting existing ones.

Categories

Under "Categories" you organize your products into groups — making them easier to manage and find within your assortment.

• Name: descriptive and unique
• Slug: URL-friendly version of the name (lowercase, no special characters or spaces) — important for links and SEO
• Filter properties & navigation: added automatically by the system after saving
• Save / delete: deletions require an extra confirmation for safety

CRM: Contacts & Organizations

The CRM module manages contact persons (people) and organizations centrally — accessible via the "CRM" tab in the main navigation.

• Creating a contact: "+ Add contact" → choose person or organization → enter details → optionally assign the person to organizations → Save
• Editing: pencil icon next to the entry — adding and deleting are available there too (note: deletion is permanent)
• Search & filter: use the search bar to search by name, email address, and other criteria

Exporting / Importing Contacts

Export: All contacts as an XLS or CSV file — for further processing, archiving, or analysis.

Import: Revised or new contact data in XLS/CSV format. Changed data is detected automatically and existing entries are updated — without duplicate records. Ideal for regular data maintenance and merging data from different sources.

Activating / Deactivating Accounts

Under CRM → People → Edit person you will find the "Account is deactivated" toggle — useful for department changes, absences, or departures.

When the toggle is on, the person can no longer sign in; when it is turned off, they regain regular access. Confirm changes with "Save". Deactivation does not delete any data — the account can be reactivated at any time.

Settings

The gear icon in the top right takes you to the central configuration — organized on the left into Shop (payment methods, plugins, currencies), Users (roles and permissions), Tax rates, and Units.

What is Wiresphere?

Wiresphere is a modular runtime for enterprise software. Applications are not built once and then maintained — they are composed at runtime from interchangeable modules. The ecosystem consists of four building blocks: The Runtime loads, isolates, and orchestrates modules. The Module SDK defines how modules are built — contract-first, type-safe, versioned. The Enterprise SDK extends it with Private Functions without any publishing obligation, plus SSO, policies, and audit integration. The Marketplace handles discovery, licensing, and automatic updates of verified modules.

The core is open source and runs in the EU cloud or on your own infrastructure. There are no licenses and no GMV share — you only pay for infrastructure.

Core Concepts

Module

The basic unit of Wiresphere. A module encapsulates a business capability (e.g. checkout, warehouse integration, configurator) in an isolated scope with an explicitly typed contract. Anything not in the contract does not exist for other modules.

Scope

A module's isolation space. Scopes limit access and the impact of failures: a module cannot access foreign state, and an error stays within its own scope. Scopes are deliberately small — small enough that even a coding agent with limited context can fully grasp them.

Contract

A module's typed, semantically versioned interface. Contracts are enforced at the Service Broker: it accepts module requests via HTTP and validates them before processing — incompatible calls are rejected, not discovered in production.

Composition

The state of an application: which modules are active in which version and how they are connected. Compositions are changed at runtime — loading, replacing, deactivating modules — without a redeploy.

Glossary

Deployment Options

• Wiresphere Cloud (EU): Preconfigured, auto-scaling infrastructure. 1-click deploy to Wiresphere Cloud — free to get started.
• Self-hosting: The open-source runtime runs on your own infrastructure — on-prem or in the cloud of your choice. Full feature set, full data sovereignty.
• Hybrid: Runtime on-prem, marketplace connection for modules and updates via controlled channels.

Regardless of deployment, source code and data remain in your hands — the platform is exit-ready by design.

Live Composition

Modules are deployed into, replaced in, or deactivated from the running application — with no downtime and no maintenance windows. Before every change, the runtime checks the contract compatibility of the target composition; incompatible changes are rejected before they take effect.

How a change proceeds

• The new module version is loaded and initialized in its scope
• The runtime wires up contracts and atomically redirects calls to the new version
• The old version is unloaded; on errors, automatic per-module rollback kicks in

Isolated Scopes

Each module runs in its own scope with defined boundaries. This limits the blast radius of failures, prevents hidden coupling, and makes modules independently developable, testable, and maintainable — including by coding agents whose context would never suffice for a monolith.

Updates & Rollback

Modules receive updates via versioned channels from the marketplace. Before applying them, the runtime checks semantic compatibility against the active composition. Every update can be rolled back per module — a faulty update does not require restoring the application.

Frontends

Frontends are decoupled from the modules and consume the same contracts — whether web, app, B2B back office, or kiosk hardware without a browser context. The frontend stack is freely selectable; switching does not require a backend migration.

Channels & Checkout Handlers

Wiresphere works in channels: independent channels through which orders are placed. Available channels are E-Commerce, Kiosk, POS, Live Chat, and AI Chat. All channels feed the same modules — the order logic exists only once.

Roles & permissions

Each channel is governed by its own role and permission model. Rights are granted per channel — a chat agent, a cashier, and an AI assistant act with different permissions, without global approvals.

Checkout handlers

Flexible checkout handlers determine how the ordering flow works in each channel. The same order can thus take a completely different path depending on the channel:

Admin Console

The admin console is the operations center of a Wiresphere application. It shows the active composition — all modules, versions, update channels, and contract connections — and logs every change.

• Composition overview: Which modules run in which version, since when, from which source
• Change log: Who deployed, updated, or rolled back which module and when
• Environments: Separate compositions for production, staging, and development

Managing Modules

• Install: Select a module from the marketplace, confirm the license, choose the target composition — the compatibility check runs automatically
• Update: Set the update channel per module (stable/beta); updates flow automatically or after manual approval
• Roll back: Every module version can be individually reset to its previous state
• Deactivate: Modules can be removed from the composition without uninstalling them

Users & Permissions

Access to the admin console is role-based. Typical roles: Owner (everything, incl. billing), Operator (change composition, approve updates), Auditor (read-only access to composition and logs). Changes to production compositions can require four-eyes approval.

Operations & Monitoring

• State per scope: Health, load, and errors are captured per module — incidents can be attributed directly to their source
• Audit & compliance: Composition state and change history can be exported at any time (relevant for NIS2 evidence)
• Deployment control: EU region or on-prem; data never leaves the chosen jurisdiction

Quickstart

Start the local runtime, generate a module skeleton, compose — no registration required:

# Start the local runtime
npx wiresphere dev

# Generate a module skeleton (TypeScript, contract-first)
npx wiresphere create module my-checkout

# Compose the module into the running application — no rebuild
npx wiresphere compose add ./my-checkout

The dev runtime runs at localhost:4200 by default and shows the active composition including all loaded modules and their contract versions.

Module SDK

Modules are built in TypeScript against the SDK. The contract is the core — it defines what the module offers and consumes:

import { defineModule } from "@wiresphere/sdk";
import { CartContract, PaymentContract } from "./contracts";

export default defineModule({
  name: "checkout",
  version: "1.4.2",
  contracts: { cart: CartContract, payment: PaymentContract },
  scope: { isolation: "strict" },
  setup({ runtime, config }) {
    runtime.expose("checkout.session", createSession(config));
  },
});

Runtime API

Contracts & Versioning

Contracts are semantically versioned. The runtime accepts minor and patch updates automatically (backwards compatible); major updates require an explicit composition change. Incompatibilities are caught at the Service Broker (validation of every HTTP request against the versioned contract) and at composition time — never first in production.

CLI

REST API

In addition to the SDK and CLI, Wiresphere provides a multi-tenant REST API. The complete endpoint reference with all request/response schemas is available as a dedicated page:

Open the full API reference 

Authentication

The API uses token-based authentication (Bearer JWT). Tokens are requested via POST /api/v1/auth/token-auth with username and password and are valid for 24 hours. An expired or invalid token results in 409 Conflict.

Authorization: Bearer <your-token>

Tenant concept

The API is multi-tenant: nearly every request must identify the shop context via the tenant-id header — without it, requests are rejected. Exception: authentication as an admin user (the header must not be sent there).

tenant-id: my-shop-id

Pagination, filtering & sorting

All list endpoints support uniform query parameters:

# Simple filter (substring search)
f=fieldName::value

# Multiple values (OR-combined)
f=fieldName::val1~~val2

# Exclude (prefix --)
f=fieldName::--excludedValue

# Date range filter (ISO 8601)
f=min_createdAt::2024-01-01T00:00:00.000Z

# Sorting
o=createdAt::DESC,name::ASC

Endpoint groups

Guide: Composing a Shop

A headless shop is built from four catalog modules — with no custom development:

• checkout — cart, payment, fulfillment
• lager-interface — stock levels and availability from inventory management
• subscription-management — optional for subscriptions and recurring payments
• Frontend of your choice — web, app, or kiosk, connected via the same contracts

Add custom requirements (e.g. pricing logic) as your own module — the rest of the composition remains untouched.

Guide: Publishing a Module

• Develop: Build the module against the SDK, validate locally with wiresphere dev and wiresphere test
• Submit: wiresphere publish — type checking, compatibility, and quality review run as part of the certification process
• Distribute: The marketplace handles licensing and auto-updates — with a fair revenue share

Details on the partner program and certification: Developers → Publish a Module.