This page lists every JSON Schema in the Triodian/Triodian_Metamodel repository. Use these schemas for validation, code generation and API integration. Each description is taken from the schema's own title and description.
Schema Conventions
| Aspect | Value |
|---|
| JSON Schema Draft | Draft-07 (http://json-schema.org/draft-07/schema#) |
Schema $id | https://triodian.com/schemas/ followed by the file's path under schemas/, e.g. https://triodian.com/schemas/capability.schema.json |
| File names | kebab-case, singular, ending .schema.json |
| Shared vocabulary | common.schema.json |
| License | Apache License 2.0 |
All schemas follow the same rules:
- One structure. The root of each domain schema is the domain's main record (a Capability, an Initiative, a Policy). Its element types (a Capability Function, a Program, a Value Stream Stage) are named, camelCase entries under
definitions, referenced with $ref.
- No undefined fields. Every object a schema defines sets
"additionalProperties": false, so a misspelt or undocumented field fails validation.
- Identifiers. Every record has a required identifier named after its entity, such as
capabilityID, strategyID, orgUnitID or modelID (never id or …Id), using the shared identifier definition. Records link to each other by these identifiers; ID fields such as orgUnitID, parentCapabilityID and relatedStrategyIDs sit beside the corresponding name fields (orgUnitTitle, parent, relatedStrategies).
- Shared value lists. Concepts such as priority, risk level, frequency, status, maturity and domain type are defined once in
common.schema.json with camelCase values, and domains reference them with allOf/$ref.
- camelCase everywhere. Definition names, property names and enumerated values are camelCase.
- Descriptions. Every property has a
description.
- Validation in CI.
scripts/validate.py checks every schema on each push and pull request, together with the documentation's worked examples in examples/doc-examples.
Shared Vocabulary
| Schema | Description |
|---|
| common.schema.json | Shared Vocabulary Schema: controlled vocabularies and reusable structures shared by every Triodian domain. Defines no instance type of its own. |
Its definitions include:
| Definition | Purpose |
|---|
identifier | Unique identifier of a record within its domain, e.g. "CAP-001" |
entityReference | A reference to an entity in any domain, by domainType and entityID |
dependency | An entity in another domain that a record depends on |
domainType | The Triodian domains, used when one record refers to an entity in another |
ratingLevel, priority, criticality, importance, riskLevel, severity | Four-point scale low, medium, high, critical; a field may add values (relationship priority adds strategic) |
simpleLevel, fivePointLevel, likelihood, confidenceLevel, alignmentLevel | Three-, four- and five-point ratings (alignmentLevel is none, low, medium, high) |
impactMagnitude, changeMagnitude, effectiveness, complexity, scale1to5 | Magnitude, effectiveness and complexity scales |
frequency, timeHorizon | How often something happens; planning horizon (immediate to extended) |
performanceTrend, quantityTrend | Direction of a measure or an amount |
workStatus, documentStatus, implementationStatus, complianceStatus | Status lists |
lifecycleStage, adoptionStage, maturityLevel, automationLevel | Lifecycle, adoption, maturity (initial to optimizing) and automation |
riskCategory, dependencyStrength, geographicScope | Risk categories, dependency strength, geographic reach |
jurisdictionCode | ISO 3166 jurisdiction code (AU, SG, EU, US-NY), or INT for international standards |
currencyCode, moneyAmount, datePeriod, performanceIndicator | Reusable structures for money, periods and measures |
The repository's shared vocabulary report lists every shared value and the fields that use it.
Core Domain Schemas
| Domain | Schema | Description |
|---|
| Organization | organization.schema.json | Organization Domain Schema: organizations and their organization units |
| Stakeholder | stakeholder.schema.json | Stakeholder Domain Schema: people and groups with influence or interest, and their requirements |
| Capabilities | capability.schema.json | Capabilities Domain Schema, with capability functions, components and processes |
| Value Stream | value-stream.schema.json | Value Stream Domain Schema: end-to-end activities that create value for customers or internal stakeholders; stages are element records |
| Information | information.schema.json | Information Domain Schema, with information elements |
| Strategy | strategy.schema.json | Strategy Domain Schema, with strategic objectives |
| Performance | performance.schema.json | Performance Domain Schema, with performance KPIs |
| Initiatives | initiative.schema.json | Initiatives Domain Schema: Initiative > Program > Project, linked by parentInitiativeID and parentProgramID |
| Products | product.schema.json | Products Domain Schema: tangible and intangible offerings that address customer needs and deliver value |
| Services | service.schema.json | Services Domain Schema, with service features |
| Policy | policy.schema.json | Policy Domain Schema: rules, guidelines and standards that govern operations and decision-making |
Extended Domain Schemas
| Domain | Schema | Description |
|---|
| Customer | customer.schema.json | Customer Domain Schema: customer segments, with personas, journeys and relationships as element records linked by customerSegmentID |
| Market | market.schema.json | Market Domain Schema: the external business environment, market dynamics, competitive positioning and industry trends |
| Finance | finance.schema.json | Finance Domain Schema: economic resources, financial flows, structures and instruments (financial resources, budgets, investments, revenue streams, cost structures) |
| Risk Management | risk-management.schema.json | Risk Management Domain Schema: risk, assessment, control, response and monitoring |
| Technology | technology.schema.json | Technology Domain Schema |
| Supply Chain | supply-chain.schema.json | Supply Chain Domain Schema |
| People | people.schema.json | People Domain Schema: workforce capabilities, organizational culture, leadership approaches and knowledge management |
| Channel | channel.schema.json | Channel Domain Schema: the methods, pathways and networks through which an organization delivers products and services |
| Innovation | innovation.schema.json | Innovation Domain Schema: creating, developing and implementing new ideas, products, services, processes and business models |
| Sustainability | sustainability.schema.json | Sustainability Domain Schema |
| Intelligence | intelligence.schema.json | Intelligence Domain Schema: organizational intelligence activities, sources, applications and attributes |
| Manufacturing | manufacturing.schema.json | Manufacturing Domain Schema, with work orders, production units and inventory |
| Social Change | social-change.schema.json | Social Change Domain Schema: campaigns, movements and interventions addressing systemic injustice, inequality and exclusion |
Model Risk Management
| Schema | Description |
|---|
| model-risk-management.schema.json | Model Risk Management Schema, a sub-domain of Risk Management. The root is a Model Profile in the model inventory; Model Governance, Model Validation, Model Monitoring and Regulatory Framework Mapping are element records linked to the model by modelID. |
Semantic Library
Compliance and Public Reporting
Use Cases
Dynamic and Time-Series
Governance Interface
Relationship Schemas
| Schema | Description |
|---|
| cross-domain-relationship.schema.json | Cross-Domain Relationship Schema: a directional relationship between entities in different domains, from a source domain to a target domain, using one of 37 relationship types. Information, Performance, Product and Service never act as the source. |
| inter-unit-domain-relationship.schema.json | Inter-Unit Domain Relationship Schema: how an organization unit relates to a domain entity (owning, providing, consuming, governing and other roles) |
Relationship directionality is part of the cross-domain relationship schema; there is no separate directionality schema.
Strategic Response Model
| Schema | Description |
|---|
| trigger.schema.json | Trigger Schema: what prompts change; affected entities are listed in affectedEntities |
| rationale.schema.json | Rationale Schema: the reasoning that connects a trigger to a specific response; related entities are listed in relatedEntities |
| strategic-intent.schema.json | Strategic Intent Schema: a proactive aspiration or opportunity the organization intends to pursue, realised through strategic responses |
| strategic-response.schema.json | Strategic Response Schema: a planned or enacted response to triggers or strategic intents, justified by rationales and measured by performance indicators |
| strategic-response-model.schema.json | Strategic Response Model Schema: composite that groups triggers, rationales, strategicIntents and strategicResponses for exchange |
| performance-indicator.schema.json | Performance Indicator Schema: a measure with baseline, current and target values, thresholds and measurement details |
Coverage Schemas
External Organization Schemas
Extension Schemas
| Schema | Description |
|---|
| extensions/business-analysis.schema.json | Business Analysis Extension Schema: formalises BA activities, requirements and artefacts. Requirements, requirement artefacts, elicitation activities, analysis and design definitions, and solution evaluations are element types within this one file. |
| extensions/technology-one-well-architected-framework.schema.json | TechnologyOne Well-Architected Framework Extension Schema: architectural principles and patterns inspired by the TechnologyOne Well-Architected Framework |
Interoperability Mappings
The interoperability mappings are JSON-LD contexts, not JSON Schemas. They live in the repository's interoperability folder and use one Triodian namespace, https://triodian.com/ontology# (prefix triodian:).
scripts/validate.py checks that each mapping is valid JSON-LD and maps only terms the schemas define.
Schema Structure
Domain Schema Structure
Each domain schema follows the same structure. This excerpt from capability.schema.json shows the root record, a required identifier, a shared value list and an element type under definitions:
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://triodian.com/schemas/capability.schema.json",
"title": "Capabilities Domain Schema",
"type": "object",
"required": ["capabilityID", "title", "description", "purpose", "owner"],
"additionalProperties": false,
"properties": {
"capabilityID": {
"description": "Unique identifier for the Capability",
"allOf": [{ "$ref": "common.schema.json#/definitions/identifier" }]
},
"title": {
"type": "string",
"description": "The name or title of the Capability"
},
"maturityLevel": {
"description": "Current maturity level of the Capability",
"allOf": [{ "$ref": "common.schema.json#/definitions/maturityLevel" }]
},
"capabilityFunctions": {
"type": "array",
"items": { "$ref": "#/definitions/capabilityFunction" }
}
},
"definitions": {
"capabilityFunction": {
"type": "object",
"additionalProperties": false,
"properties": {}
}
}
}
Composite Schema Structure
Composite schemas group records defined in other schemas. strategic-response-model.schema.json refers to the four Strategic Response Model schemas:
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://triodian.com/schemas/strategic-response-model.schema.json",
"title": "Strategic Response Model Schema",
"type": "object",
"additionalProperties": false,
"properties": {
"triggers": { "type": "array", "items": { "$ref": "trigger.schema.json" } },
"rationales": { "type": "array", "items": { "$ref": "rationale.schema.json" } },
"strategicIntents": { "type": "array", "items": { "$ref": "strategic-intent.schema.json" } },
"strategicResponses": { "type": "array", "items": { "$ref": "strategic-response.schema.json" } }
}
}
Using the Schemas
Schemas refer to each other by relative $ref (for example common.schema.json#/definitions/riskLevel), so load every schema in the schemas/ folder before validating a record.
Validation Example (JavaScript)
const Ajv = require('ajv');
const fs = require('fs');
const path = require('path');
const ajv = new Ajv({ allErrors: true });
function loadSchemas(dir) {
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
const file = path.join(dir, entry.name);
if (entry.isDirectory()) loadSchemas(file);
else if (entry.name.endsWith('.schema.json')) ajv.addSchema(JSON.parse(fs.readFileSync(file)));
}
}
loadSchemas('./schemas');
const validate = ajv.getSchema('https://triodian.com/schemas/capability.schema.json');
const capability = {
capabilityID: "CAP-001",
title: "Customer Onboarding",
description: "Capability to register new customers",
purpose: "Bring new customers into the bank quickly and compliantly",
owner: "Retail Banking"
};
if (!validate(capability)) {
console.log(validate.errors);
}
Validation Example (Python)
import json
from pathlib import Path
from jsonschema import Draft7Validator
from referencing import Registry, Resource
schemas = [json.loads(p.read_text()) for p in Path("schemas").rglob("*.schema.json")]
registry = Registry().with_resources(
(s["$id"], Resource.from_contents(s)) for s in schemas
)
schema = registry.contents("https://triodian.com/schemas/capability.schema.json")
capability = {
"capabilityID": "CAP-001",
"title": "Customer Onboarding",
"description": "Capability to register new customers",
"purpose": "Bring new customers into the bank quickly and compliantly",
"owner": "Retail Banking",
}
errors = list(Draft7Validator(schema, registry=registry).iter_errors(capability))
for e in errors:
print(f"Invalid: {e.message}")
if not errors:
print("Valid!")
Validating the Repository
The repository's own validator runs the structural checks and validates the documentation's worked examples:
pip install -r scripts/requirements.txt
python scripts/validate.py
python scripts/validate.py --doc-examples
Code Generation Example (TypeScript)
Using json-schema-to-typescript, run from the schemas/ folder so relative references resolve:
cd schemas
npx json-schema-to-typescript capability.schema.json > ../types/capability.d.ts
Generated TypeScript (abridged):
export interface CapabilitiesDomainSchema {
capabilityID: string;
title: string;
description: string;
purpose: string;
owner: string;
maturityLevel?: 'initial' | 'repeatable' | 'defined' | 'managed' | 'optimizing';
}
Schema Versioning
The schemas carry no version number. The main branch of the repository is the current version, and every change goes through a pull request that must pass the CI checks. To pin a version, refer to a specific commit or tag of the repository.
Getting the Schemas
All schemas are maintained in the Triodian/Triodian_Metamodel repository on GitHub. Clone it, or download individual files from the links above:
git clone https://github.com/Triodian/Triodian_Metamodel.git
Online Validators
Online validators load one schema at a time, so they cannot follow references to common.schema.json unless you paste it in as well.
| Tool | Language | Installation |
|---|
| ajv-cli | Node.js | npm install -g ajv-cli |
| jsonschema | Python | pip install jsonschema |
| check-jsonschema | Python | pip install check-jsonschema |
IDE Extensions
| IDE | Extension |
|---|
| VS Code | Built-in JSON Schema support (json.schemas setting) |
| IntelliJ | Built-in JSON Schema support |
| Sublime | SublimeLinter-json |