KRISTALL DES BAUWESENS

KRISTALL DES BAUWESENS

Unten ist eine Analyse des Aufbaus als Knoten-, Röber- und Kristallsystem. Dies ist ein praktisches Modell, wenn wir die Industrie nicht nur in eine Reihe von Prozessen verwandeln wollen, sondern in eine verwaltete semantische, digitale und organisatorische Architektur.

Grundlogik des Modells

Knoten sind die Punkte der Konzentration von Funktionen, Ressourcen, Entscheidungen, Daten und Verantwortung.

Die Rippen sind die Verbindungen zwischen den Knoten: die Ströme von Materialien, Geld, Dokumenten, Befehlen, Technologien, Menschen und Kontrolle.

Ein Kristall ist eine ganzheitliche Struktur, in der alle Knoten und Rippen nicht chaotisch gesammelt werden, sondern nach den Gesetzen der Symmetrie, Hierarchie, Transparenz und Entwicklung.

Mit anderen Worten:

• Knoten = wer oder was tut;
• Rippe = wie es verbunden ist;
• Kristall = wie das ganze System hält Form und fällt nicht auseinander.

Der Bau als Graf

Die Bauindustrie ist nicht eine Kette, sondern ein mehrschichtiger Graph.

Es hat:

• Organisationseinheiten,
• Ressourcenknoten,
• technologische Knotenpunkte,
• rechtliche Knotenpunkte,
• Finanzknotenpunkte,
• Logistikknotenpunkte,
• Betriebseinheiten,
• Digitale Knoten.

Zwischen den Rippen bilden sich:

• Materialfluss,
• Menschenströme,
• Informationsflüsse,
• Kapitalflüsse,
• Berechtigungsströme,
• Verantwortungsströme,
• Risikoströme,
• Rückkopplungsströme.

Bauknoten

Knoten der Idee. Es ist der Anfang eines jeden Objekts.

Schlüsselknoten:

• staatliche Priorität;
• Auftraggeber;
• Investor;
• Entwickler;
• städtebauliche Idee;
• Grundstück;
• soziale Anfrage;
• Masterplan;
• Architektonisches Konzept.

Ihre Funktion:

Die Antwort auf die Frage bilden: was bauen wir, warum bauen wir, für wen bauen wir, mit welchen Mitteln und in welcher Logik des Territoriums.

Regulierungsknoten. Ohne sie ist das System nicht legitim.

Dazu gehören:

• Bundesbehörden;
• regionale Behörden;
• Kommunale Behörden;
• Normen und Normen;
• Prüfung;
• Genehmigungssystem;
• Kataster;
• Kontrollorgane;
• ökologische Harmonisierung;
• Brandschutz und industrielle Sicherheit.

Ihre Funktion:

Gewährleistung von Zulässigkeit, Sicherheit, Konformität und rechtlichem Rahmen.

Baugruppen

Das sind die Geburtsknoten der Form.

Dazu gehören:

• Architekturbüro;
• Der Generalplaner;
• Konstrukteur;
• Ingenieurabteilungen;
• BIM/TIM-Modell;
• geschätztes Modell;
• digitales Doppelobjekt;
• Autorenaufsicht.

Ihre Funktion:

Übersetzen Sie die Idee in ein genaues System von Lösungen, Zeichnungen, Parametern, Volumen und Einschränkungen.

Ressourcen- und Versorgungsknoten

Ohne sie wird das Objekt nicht materialisiert.

Dazu gehören:

• Hersteller von Baustoffen;
• Karriere;
• Metallurgie;
• Betonknoten;
• Holzbearbeitung;
• technische Ausrüstung;
• Technik und Mechanismen;
• Energieversorgung;
• Lagerhallen;
• Logistikzentren.

Ihre Funktion:

Bauen Sie alles, was Sie in Umfang, Zeit, Qualität und Preis benötigen.

Produktionsknoten

Es ist das Zentrum der physischen Verkörperung.

Dazu gehören

• Generalunternehmer;
• Subunternehmer;
• Baubrigaden;
• Montageorganisationen;
• Technik;
• Baustelle;
• Kalenderplan;
• Arbeitsschutz;
• Dispatching der Arbeiten;
• Bauaufsicht.

Ihre Aufgabe ist es, das Objekt in der Realität zu sammeln.

Finanzknoten

Ein Gebäude ohne Finanzrahmen verwandelt sich schnell in Chaos.

Knoten:

• Bank;
• die Treasury des Projekts;
• Escrow/Projektfinanzierung;
• Haushaltsmittel;
• private Investitionen;
• Vertragssystem;
• berechnete Konturen;
• Steuerkreis;
• Versicherung;
• Risiko- und Reservebewertung.

Ihre Funktion:

Gewährleistung der Stabilität des Cashflows und der Vorhersehbarkeit der Ausführung.

Betriebseinheiten

In der Tat wird das Objekt nicht für den Bau gebaut, sondern für das Leben nach dem Bau.

Knoten:

• die Ausbeuterorganisation;
• Verwaltungsgesellschaft;
• Ressourcenversorgungsorganisationen;
• Überwachungssystem des Objekts;
• Wartung;
• Generalüberholung;
• Benutzer;
• Einwohner/Mieter/Unternehmen;
• Rückkopplungssystem.

Ihre Funktion:

Das Errichtete in ein funktionierendes Umfeld verwandeln.

Knoten der digitalen Umwelt. Das ist der Kern der zukünftigen Industrie.

Knoten:

• eine einzige digitale Plattform;
• Registrierung von Objekten;
• Registrierung der Teilnehmer;
• digitaler Pass des Objekts;
• digitale Spuren von Entscheidungen;
• BIM/TIM-Speicher;
• Marktplätze von Materialien und Dienstleistungen;
• Geoanalyse;
• KI-Vorhersagemodul;
• Dashboard der Branche.

Ihre Funktion: das System transparent, steuerbar und prädiktiv zu machen.

Bau-Röber

Nun, die Hauptsache ist, dass Knoten ohne Rippen nur tote Punkte sind.

Sinnliche Rippen

Verknüpfen:

• Bedarf der Gesellschaft ↔ Bauprogramm;
• Staatsstrategie ↔ konkretes Projekt;
• Gebiet ↔ Funktion des Objekts.

Das beantwortet die Frage, warum gerade dieser Bau ein Recht darauf hat.

Rechtliche Rahmenbedingungen

Verknüpfen:

• Projekt ↔ Normvorgabe;
• Grundstück ↔ zulässige Verwendung;
• Auftragnehmer ↔ Vertrag;
• Objekt ↔ Baugenehmigung;
• Ergebnis ↔ Inbetriebnahme.

Das sind die Grenzen der Legitimität.

Informationsrippen

Verknüpfen:

• Auftraggeber ↔ Planer;
• Planer ↔ Auftragnehmer;
• Auftragnehmer ↔ Aufsicht;
• Baustelle ↔ digitale Plattform;
• Betrieb ↔ digitaler Zwilling.

Das sind die Datenrippen.

Finanz rippen

Verknüpfen:

• Investor ↔ Projekt;
• Bank ↔ Auftragsvertrag;
• Finanzverwaltung ↔ Zahlung;
• Kostenvoranschlag ↔ tatsächlich ausgeführte Arbeiten;
• Risiko ↔ Reserve.

Das sind die Rippen des Wertes und des Vertrauens.

Materielle Rippen

Verknüpfen:

• Hersteller ↔ Lager;
• Lager ↔ Standort;
• Technik ↔ Arbeitsabschnitt;
• Lieferung ↔ Montage.

Es sind die Rippen der physischen Inkarnation.

Führungsrippen

Verknüpfen:

• KPI ↔ Ausführender;
• Frist ↔ Etappe;
• Kontrolle ↔ Abweichung;
• Entscheidung ↔ Verantwortung;
• Vorfall ↔ Reaktion des Systems.

Es sind die Rippen der Koordination.

Qualität Rippen. Verknüpfen:

• Material ↔ Zertifikat;
• Arbeit ↔ Protokoll;
• Projekt ↔ Übereinstimmung;
• Objekt ↔ Betriebsstandard;
• Defekt ↔ Korrekturmaßnahme.

Das sind die Rippen der Sicherheit.

RUBRA Feedback

Verknüpfen:

• Nutzer ↔ Betreiber;
• Betreiber ↔ Planer;
• Unfall ↔ Überarbeitung der Norm;
• Betrieb ↔ eine neue Generation von Projekten.

Das sind die Rippen der Evolution.

Kristallbau

Die Frage ist: Was ist ein Kristall?

Der Kristall ist nicht nur ein Netz. Es ist ein harmonisch organisiertes mehrschichtiges System, in dem jeder Knoten einen Ort, eine Funktion, einen Grad an Kommunikation und ein Maß an Verantwortung hat.

Im Kristallbau sind das:

ein einheitliches raumdigitales Modell der Branche, in dem:

• Jedes Objekt hat einen digitalen Pass.
• Jeder Teilnehmer hat ein digitales Profil.
• Jeder Prozess hat eine Route und Kontrolle;
• Jede Ressource hat ihren Ursprung und ihren Zustand.
• Jede Entscheidung hat den Autor, das Datum und die Folgen.
• Jeder Rubel hat eine Trace;
• Jedes Risiko ist im Voraus sichtbar.
• Jedes Ergebnis ist Teil der Gesamtarchitektur des Landes.

Geometrie des Kristallbaus

Wir werden den Kristall mindestens in 7 Facetten zerlegen.

Rand 1. Bedeutung

Was und warum gebaut wird.

Rand 2. Raum

In welchem Land, in welchem Kontext.

Rand 3. Recht

Auf welcher Grundlage und nach welchen Regeln.

Rand 4. Ressourcen

Von wem, auf was und was gebaut wird.

Rand 5. Produktion

Wie genau das Objekt in Etappen zusammengebaut wird.

Rand 6. Geld, mit welchem Geld und mit welcher Nachhaltigkeit.

Rand 7. Lebenszyklus

Wie das Objekt nach der Eingabe lebt. Wenn Sie einen digitalen Kern hinzufügen, erhalten Sie einen Kristall der 8-Ebene, in dem die digitale Umgebung alle anderen Facetten verbindet.

Kristallkern

Jedes Kristallsystem muss einen Kern haben.

Für den Bau eines solchen Kerns sollte sein:

Ein einziger digitaler Betreiber von Bauleistungen

Es ersetzt nicht alle Teilnehmer, sondern wird:

• Der Datenkoordinator,
• Integrator von Prozessen,
• Digitaler Schiedsrichter,
• Navigator des Lebenszyklus des Objekts,
• Betreiber der Transparenz,
• Interaktion zwischen Staat, Wirtschaft und Bürgern.

Er ist es, der die Industrie aus einem einzigen Teilnehmersatz in einen einzigen Baukristall verwandelt.

Kristallbau-Formel

Kristallbau = Knoten × Röbra × Regeln × Daten × Zeit

Wo:

• Knoten geben Struktur,
• Rippen geben Wechselwirkungen,
• Regeln geben Nachhaltigkeit,
• Daten transparent machen,
• Zeit gibt die Dynamik des Lebenszyklus.

Praktische Knotenarchitektur

Kontur A. Der Staat

Knoten:

• Strategie,
• NGO-Projekte,
• Normen,
• Kontrolle,
• Registern,
• Infrastrukturprogramme.

B-Kontur. Entwicklung und Bestellung

Knoten:

• Der Arbeitgeber,
• Der Investor,
• Entwickler,
• Die Landesbank,
• Finanzmodell.

Der C-Ring. Projektierung

Knoten:

• Architektur,
• Ingenieurwesen,
• BIM,
• Prüfung,
• Schätzungen.

Der Kreis D. Produktion

Knoten:

• Auftragnehmer,
• Lieferanten,
• Technik,
• Aufbaukontrolle,
• Kalenderplan.

Der Kreis E. Betrieb

Knoten:

• Eigentümer,
• Verwaltungsgesellschaft,
• Dienstleistungen,
• Überwachung,
• Reparaturen.

Kontur F. Digitale Plattform

Knoten:

• Digitaler Reisepass,
• Objekt-ID,
• Digitaler Marktplatz,
• Analytik,
• AI,
• Überwachung,
• Teilnehmerbewertungen.

Welche Rippen sind die kritischsten

Wenn man hart spricht, bricht die Industrie meistens nicht wegen des Fehlens von Knoten, sondern wegen der schlechten Rippen zusammen.

Die problematischsten Rippen sind normalerweise:

• Projekt ↔ Baustelle;
• Kostenvoranschlag ↔ tatsächliche Kosten;
• Auftrag ↔ Verantwortung;
• Fristen ↔ tatsächliche Ausführung;
• Auflösung ↔ digitale Transparenz;
• Betrieb von ↔ Feedback an das neue Design;
• öffentliche Daten ↔ private Daten;
• Lieferant ↔ Qualität ↔ Herkunft des Materials.

Das heißt, die Hauptaufgabe der Reform besteht nicht nur darin, neue Knoten zu schaffen, sondern die Rippen neu zu sammeln.

Kristall durch den Lebenszyklus des Objekts

Man kann sich ein Objekt als kleinen Kristall vorstellen:

Initiieren. Idee, Bedürfnis, Standort, Modell.

Design-Konzept, Berechnungen, BIM, Schätzungen.

Abstimmung. Prüfung, Genehmigungen, Verbindungen.

Bauen. Lieferung, Arbeit, Kontrolle, Akte.

Eingabe. Inspektionen, Dokumentation, Start.

Betrieb Überwachung, Wartung, Feedback.

Transformation

Rekonstruktion, Modernisierung, Wiederverwendung von Daten. Das ist der Kristall des Lebenszyklus.

In der Sprache der Metaarchitektur

Dann kann man es so formulieren:

Knoten sind Organe des Baukörpers. Die Rippen sind seine Gefäße, Nerven und Kanäle. Der Kristall ist sein Skelett, seine Form, sein Genom und das Gesetz der inneren Harmonie. Ohne Knoten gibt es keine Funktion. Ohne Rippen keine Koordination. Ohne Kristall keine Ganzheit.

Management-Ausgabe

Für das Konzept des Einheitlichen Digitalen Baudienstleisters bedeutet dies: Der Betreiber darf nicht als Website, nicht als Service-Suite oder als Marktplatz im engeren Sinne gebaut werden, sondern als:

Kristall-Plattform-Industrie, wo:

• Branchenknoten digitalisiert,
• Branchenstandardisiert,
• Die Kristallindustrie wird visualisiert und verwaltet.

Das Portal soll zeigen können:

• Wer mit wem verbunden ist;
• wo der Bruch der Verbindung;
• Wo ist der Engpass;
• wo das korrupte Risiko;
• Mangel an Materialien;
• wo der Rückstand auf die Fristen;
• wo der Auftragnehmer überlastet ist;
• wo das Objekt aus dem normativen Kreislauf fällt;
• Der Lebenszyklus verliert an Kontrolle.

Fertige Formulierung für die Aufnahme in das Konzept

Sie können Folgendes einfügen:

Die Bauindustrie wird als ein kristallines Netzwerksystem betrachtet, das aus Knoten, Rippen und einem integrierten digitalen Kern besteht. Knoten repräsentieren die Teilnehmer, Ressourcen, Funktionen und Phasen des Lebenszyklus eines Objekts. Die Rippen spiegeln die materiellen, finanziellen, informativen, rechtlichen und verwaltungstechnischen Verbindungen zwischen ihnen wider. Der Kristall der Branche wird als ganzheitliche Architektur gebildet, in der alle Elemente miteinander verbunden, standardisiert, transparent und in Echtzeit verwaltet werden. Auf dieser Grundlage wird ein einheitlicher digitaler Betreiber von Baudienstleistungen als Systemintegrator geschaffen, der die Koordination, Rückverfolgbarkeit und evolutionäre Entwicklung des Baukomplexes gewährleistet.

Die stärkste Version dieses Modells

Wenn Sie die Idee durchziehen, können Sie 3 des Produktes tun:

• Die bedeutungsvolle Karte des Baues nach den Knoten und röbram
• Der Kristall der Bauindustrie in Russland - als visuelles Modell
• Technische Architektur der digitalen Plattform - basierend auf diesem Kristall

Es ist nicht nur eine Beschreibung, sondern eine Grundlage für:

• Straßenkarte,
• technische Aufgaben,
• Atlas der Konstruktion,
• Die Architektur des Marktplatzes,
• Staatliche digitale Plattform.

Tabelle: Knoten - Rippen - Funktionen - Digitale Dienstleistungen

1. Kontur: Konzeption und Initiierung

MVP BAU-KRISTALL

Entwicklungsplan (echte)

Woche 1–2

Roles-TabelleUU Zugriffsrollen.

Feld	Typ
id	UUID PK
code	varchar unique
name	varchar

Beispiele:

• super_admin
• government_operator
• investor
• customer
• contractor
• supervisor
• viewer

Tabelle user_roles. Benutzer und Rollen.

Tabelle companies. Marktteilnehmer.

Feld	Typ	Zweck
id	UUID PK	Unternehmens-ID
name	varchar	Name
short_name	varchar	Kurzname
inn	varchar	INN
ogrn	varchar	OGRN
company_type	varchar	customer / contractor / supplier / bank / regulator
rating	numeric(3,2)	Bewertung
status	varchar	active / inactive
website	varchar	Webseite
created_at	timestamp	Erstellungsdatum
updated_at	timestamp	Datum der Aktualisierung

Tabelle company_users. Nutzer an das Unternehmen binden.

Feld	Typ
id	UUID PK
company_id	UUID FK -> companies.id
user_id	UUID FK -> users.id
position	varchar
is_primary	boolean
created_at	timestamp

Tabelle Regionen. Verzeichnis der Regionen.

Feld	Typ
id	UUID PK
code	varchar unique
name	varchar

Tabelle locations. Adressen und Koordinaten.

Feld	Typ
id	UUID PK
region_id	UUID FK -> regions.id
address	text
lat	numeric(10,7)
lon	numeric(10,7)
cadastral_number	varchar
created_at	timestamp

Tabelle der Projekte. Karte der Baustelle.

Feld	Typ	Zweck
id	UUID PK	Objekt-ID
code	varchar unique	Interne Nummer
name	varchar	Name
description	text	Beschreibung
project_type	varchar	residential / industrial / infrastructure
lifecycle_stage	varchar	concept / design / construction / operation
status	varchar	normal / risk / problem / archived
location_id	UUID FK -> locations.id	Standort
customer_company_id	UUID FK -> companies.id	Der Auftraggeber
start_date	date	Geplanter Start
end_date	date	Geplante Fertigstellung
planned_budget	numeric(18,2)	Geplantes Budget
actual_budget	numeric(18,2)	Fakt
created_at	timestamp	Erstellungsdatum
updated_at	timestamp	Datum der Aktualisierung

Tabelle project_stages. Phasen des Projekts.

Feld	Typ
id	UUID PK
project_id	UUID FK -> projects.id
stage_code	varchar
stage_name	varchar
planned_start	date
planned_end	date
actual_start	date
actual_end	date
status	varchar
created_at	timestamp

Tabelle contracts. Verträge innerhalb des Systems.

Feld	Typ
id	UUID PK
project_id	UUID FK -> projects.id
contract_number	varchar
contract_type	varchar
customer_company_id	UUID FK -> companies.id
contractor_company_id	UUID FK -> companies.id
amount	numeric(18,2)
currency	varchar
date_start	date
date_end	date
status	varchar
created_at	timestamp
updated_at	timestamp

Tabelle documents. Projektdokumente.

Feld	Typ
id	UUID PK
project_id	UUID FK -> projects.id
company_id	UUID FK -> companies.id null
contract_id	UUID FK -> contracts.id null
doc_type	varchar
title	varchar
file_url	text
version	integer
issued_at	date
status	varchar
created_by	UUID FK -> users.id
created_at	timestamp

Risks Risks Tabelle nach Objekt.

Feld	Typ
id	UUID PK
project_id	UUID FK -> projects.id
related_company_id	UUID FK -> companies.id null
related_stage_id	UUID FK -> project_stages.id null
risk_type	varchar
severity	varchar
probability	varchar
description	text
status	varchar
detected_at	timestamp
resolved_at	timestamp null

Tabelle der Ereignisse. Ereignisband.

Feld	Typ
id	UUID PK
project_id	UUID FK -> projects.id null
company_id	UUID FK -> companies.id null
user_id	UUID FK -> users.id null
event_type	varchar
event_payload	jsonb
created_at	timestamp

Tabelle project_metrics. Metriken zum Projekt.

Feld	Typ
id	UUID PK
project_id	UUID FK -> projects.id
metric_date	date
progress_percent	numeric(5,2)
cost_variance	numeric(18,2)
schedule_variance_days	integer
open_risks_count	integer
created_at	timestamp

Postleitzahlen PostgreSQL

Minimal erforderlich:

• projects(code)
• projects(status, lifecycle_stage)
• projects(customer_company_id)
• contracts(project_id)
• contracts(customer_company_id, contractor_company_id)
• documents(project_id, doc_type)
• risks(project_id, status, severity)
• events(project_id, created_at desc)
• locations(region_id)
• GIN Index auf events.event_payload

Neo4j: Graf Modell

In der Spalte speichern wir die Entitäten als Knoten und Beziehungen als Rippen.

Knoten. Hauptetiketten:

• Project
• Company
• User
• Contract
• Document
• Stage
• Location
• Risk

Verbindliche Eigenschaften des Knotens. Für die Einheitlichkeit:

• id — UUID von PostgreSQL
• type - Entitätstyp
• name
• status
• createdAt
• updatedAt

Arten von Rippen Neo4j. Hauptbeziehungen

• [:LOCATED_AT]
  Project -> Location
• [:OWNED_BY]
  Project -> Company
• [:PARTICIPATES_IN]
  Company -> Project
• [:HAS_STAGE]
  Project -> Stage
• [:HAS_CONTRACT]
  Project -> Contract
• [:CUSTOMER_IN]
  Company -> Contract
• [:CONTRACTOR_IN]
  Company -> Contract
• [:HAS_DOCUMENT]
  Project -> Document
• [:ISSUED_BY]
  Document -> Company
• [:HAS_RISK]
  Project -> Risk
• [:RELATED_TO]
  Risk -> Company oder Risk -> Bühne
• [:EMPLOYED_BY]
  User -> Company

Eigenschaften der Rippen

Zum Beispiel bei PARTICIPATES_IN:

• role
• startDate
• endDate
• status

Bei HAS_CONTRACT:

• contractNumber
• amount
• currency
• status

Bei HAS_RISK:

• severity
• detectedAt

Beispiel Graf

(Company: Customer) -[:PARTICIPATES_IN {role:"customer"}]-> (Project)

(Company: GeneralContractor) -[:PARTICIPATES_IN {role:"general_contractor"}]-> (Project)

(Project) -[:HAS_CONTRACT]-> (Contract)

(Company: Customer) -[:CUSTOMER_IN]-> (Contract)

(Company: GeneralContractor) -[:CONTRACTOR_IN]-> (Contract)

(Project) -[:HAS_STAGE]-> (Stage: Construction)

(Project) -[:HAS_RISK {severity:"high"}]-> (Risk)

(Project) -[:LOCATED_AT]-> (Location)

Architektur API

Für MVP genug REST API v1.Später können Sie GraphQL für komplexe Graphen-Bildschirme hinzufügen.

Allgemeine Regeln API

Grundpräfix

/api/v1

Format

{

  "data": {},

  "meta": {},

  "error": null

}

Fehler

{

  "data": null,

  "meta": {},

  "error": {

    "code": "PROJECT_NOT_FOUND",

    "message": "Project not found"

  }

Autorisierung: Bearer <token>

Auth API. POST /auth/login. Eingang.

Request

{

  "email": "user@example.com",

  "password": "secret"

}

Response

{

  "data": {

    "accessToken": "jwt",

    "refreshToken": "jwt",

    "user": {

      "id": "uuid",

      "fullName": "Ivan Petrov",

      "email": "user@example.com",

      "roles": ["customer"]

    }

  },

  "meta": {},

  "error": null

}

POST /auth/refresh. Token-Update.

GET /auth/me. Das Profil des aktuellen Benutzers.

API Unternehmen

GET /companies. Liste der Unternehmen. Einstellungen:

• search
• companyType
• status
• page
• limit

POST /companies. Eine Firma gründen.

Request

{

  "name": "StroyGrad" GmbH,

  "shortName": "Baugrad",

  "inn": "1234567890",

  "ogrn": "1234567890123",

  "companyType": "contractor",

  "website": "https://example.com"

}

GET /companies/{id}. Firmenkarte.

PATCH /companies/{id}. Firma zu erneuern.

GET /companies/{id}/projects. Projekte der Firma.

GET /companies/{id}/relations. Die Verbindungen der Firma im Grafen.

Response

{

  "data": {

    "nodes": [

      { "id": "c1", "type": "company", "name": "StroyGrad LLC" },

      { "id": "p1", "type": "project", "name": "LCD Nord" }

    ],

    "edges": [

      {

        "from": "c1",

        "to": "p1",

        "type": "PARTICIPATES_IN",

        "role": "contractor",

        "status": "active"

      }

    ]

  },

  "meta": {},

  "error": null

}

API Projekte

GET /projekte. Liste der Projekte. Filter:

• status
• lifecycleStage
• regionId
• customerCompanyId
• search
• page
• limit

POST /projekte. Projekt erstellen.

Request

{

  "name": "Nördlicher LCD",

  "description": "Multifunktionale Wohnanlage",

  "projectType": "residential",

  "lifecycleStage": "design",

  "status": "normal",

  "location": {

    "regionId": "uuid",

    "Address": "St. Petersburg, ...",

    "lat": 59.93,

    "lon": 30.31,

    "cadastralNumber": "78:00:0000000:1234"

  },

  "customerCompanyId": "uuid",

  "startDate": "2026-04-01",

  "endDate": "2028-10-31",

  "plannedBudget": 2500000000

}

GET /projects/{id}Projektkarte.

PATCH /projekts/{id}. Projekt aktualisieren.

GET /projects/{id}/graph. Hauptendpoint MVP. Gibt Knoten und Kanten des Objekts zurück.

Response

{

  "data": {

    "project": {

      "id": "uuid",

      "name": "Nördlicher LCD",

      "status": "risk",

      "lifecycleStage": "construction"

    },

    "nodes": [

      { "id": "p1", "type": "project", "name": "LCD Nord", "status": "risk" },

      { "id": "c1", "type": "company", "name": "Kundenentwicklung", "status": "active" },

      { "id": "c2", "type": "company", "name": "GenReihenfolge 1", "status": "active" },

      { "id": "r1", "type": "risk", "name": "Terminverfall", "status": "open" }

    ],

    "edges": [

      { "from": "c1", "to": "p1", "type": "PARTICIPATES_IN", "role": "customer", "status": "active" },

      { "from": "c2", "to": "p1", "type": "PARTICIPATES_IN", "role": "general_contractor", "status": "active" },

      { "from": "p1", "to": "r1", "type": "HAS_RISK", "severity": "high" }

    ]

  },

  "meta": {},

  "error": null

}

GET /projekts/{id}/timeline. Band von Veränderungen und Ereignissen.

GET /projects/{id}/metrics. Projektmetriken.

GET /projects/{id}/risks. Risikoliste.

POST /projects/{id}/risks. Risiken eingehen.

GET /projects/{id}/documents. Projektdokumente.

POST /projects/{id}/documents. Dokument herunterladen.

GET /projects/{id}/companies. Projektteilnehmer.

POST /projects/{id}/companies. Teilnehmer zum Projekt hinzufügen.

Request

{

  "companyId": "uuid",

  "role": "supplier",

  "startDate": "2026-05-01",

  "status": "active"

}

API Projektphasen

GET /projekts/{id}/stages. Liste der Etappen.

POST /projekts/{id}/stages. Erstellen Sie eine Phase.

PATCH /projects/{id}/stages/{stageId}. Phase aktualisieren.

API Verträge

GET /verträge. Liste der Verträge. Filter:

• projectId
• customerCompanyId
• contractorCompanyId
• status

POST /verträge. Einen Vertrag erstellen.

Request

{

  "projectId": "uuid",

  "contractNumber": "C-2026-001",

  "contractType": "general_contract",

  "customerCompanyId": "uuid",

  "contractorCompanyId": "uuid",

  "amount": 1500000000,

  "currency": "RUB",

  "dateStart": "2026-04-10",

  "dateEnd": "2027-12-20",

  "status": "active"

}

GET /vertrage/{id}. Vertragskarte.

PATCH /vertrage/{id}. Den Vertrag erneuern.

API Risiken

GET /risks. Allgemeine Liste der Risiken. Filter:

• projectId
• severity
• status
• relatedCompanyId

POST /risks. Risiken eingehen.

PATCH /risks/{id}. Risiko ändern.

POST /risks/{id}/resolve. Risiko absichern.

API Dokumente

GET /documents/{id}. Metadaten des Dokuments.

GET /documents/{id}/download Datei herunterladen.

API Graf. Es ist ein separater Service, weil es das Herz des Systems ist.

GET /graph/projects/{id}

Graf des Projekts.

GET /graph/companies/{id}

Graf der Firma.

POST /graph/query

Such- oder analytische Anfrage an den Grafen. Für MVP ist es besser, die Template-Abfragen zu beschränken, anstatt einen willkürlichen Cypher zu geben.

Request

{

  "queryType": "project_neighbors",

  "entityId": "uuid",

  "depth": 2

}

GET /graph/search. Suche nach Entitäten in der Spalte:

• q
• type

API Analysten

GET /analytics/dashboard

Zusammenfassungen:

• Anzahl der Projekte
• Anzahl problematischer Projekte
• Anzahl der offenen Risiken
• Anzahl der aktiven Unternehmen

GET /analytics/projects/status-summary

Übersicht über den Projektstatus.

GET /analytics/companies/top-contractors

Top-Auftragnehmer nach Anzahl der Projekte.

GET /analytics/risks/hotspots

Wo die meisten Risiken.

API Ereignisse

GET /events

Ereignisprotokoll. Filter:

• projectId
• companyId
• eventType
• from
• to

Aufteilung in Dienstleistungen. Für MVP genügen 5 Dienste.

auth-service

• login
• refresh
• me
• users
• roles

directory-service

• companies
• regions
• locations

project-service

• projects
• stages
• contracts
• documents
• risks
• metrics
• events

graph-service

• graph endpoints
• sync from PostgreSQL to Neo4j
• graph queries

analytics-service

• dashboards
• summaries
• alerts

PostgreSQL- und Neo4j-Synchronisierung

Das ist ein wichtiger Punkt. Die Quelle der Wahrheit für Karten ist PostgreSQL. Die Quelle der Wahrheit für Kommunikation und Umwege ist Neo4j.

Annäherung. Nach dem Erstellen/Aktualisieren einer Entität in PostgreSQL:

• Schreiben Sie einen Eintrag in Events
• Veröffentlichen Sie das Event
• graph-service aktualisiert graph

Beispiele für Ereignisse:

• project.created
• project.updated
• company.added_to_project
• contract.created
• risk.created

Minimum DTO

CreateProjectDto

{

  "name": "string",

  "description": "string",

  "projectType": "residential",

  "lifecycleStage": "design",

  "status": "normal",

  "customerCompanyId": "uuid",

  "startDate": "2026-04-01",

  "endDate": "2027-12-31",

  "plannedBudget": 1000000

}

AddCompanyToProjectDto

{

  "companyId": "uuid",

  "role": "contractor",

  "startDate": "2026-04-01",

  "endDate": null,

  "status": "active"

}

CreateRiskDto

{

  "projectId": "uuid",

  "relatedCompanyId": "uuid",

  "riskType": "deadline_delay",

  "severity": "high",

  "probability": "medium",

  "description": "Rückstand von 21 Tag"

}

Was Sie in der ersten Version unbedingt tun sollten

Ohne dies ist MVP leer:

Unbedingt

• projects
• companies
• contracts
• risks
• events
• GET /projects/{id}/graph
• GET /companies/{id}/relations

Kann verschoben werden

• Komplexe Dokumente
• Erweiterte Analytik
• IoT
• BIM-Lagerung
• marktplatz

Direkte empfohlene Stapel unter diesem Schema

Backend

• NestJS
• PostgreSQL
• Prisma oder TypeORM
• Neo4j
• Redis für Cache und Warteschlangen
• Swagger/OpenAPI für Dokumentation

Frontend

• Next.js
• React Query
• Cytoscape.js für Graph
• Heckscheibe CSS oder MUI

Infra

• Docker
• Docker Compose für MVP
• Nginx
• S3-kompatibler Dokumentenspeicher

Struktur des Repositorys

/crystal-construction

  /apps

    /api-gateway

    /auth-service

    /directory-service

    /project-service

    /graph-service

    /analytics-service

    /web-client

  /packages

    /shared-types

    /shared-utils

    /ui

  /infra

    /docker

    /nginx

    /db

  /docs

    openapi.yaml

    database-schema.md

    graph-model.md

Die richtige Reihenfolge der Montage

• Auth-Service anheben
• Direktion-Service anheben
• Projekt-Service erstellen
• graph-service erstellen
• Verbinden Sie UI mit GET /projects/{id}/graph
• Risiken und Ereignisse hinzufügen
• Dashboard hinzufügen

MVP muss antworten auf 4 Frage:

• Was ist das für ein Objekt?
• Wer hat was mit ihm zu tun?
• Wo ist das Risiko?
• Was passiert jetzt?

Wenn API und DB dies geben, hast du bereits den Arbeitskern des Kristallbaus.

1. OpenAPI-Entwurf

Unten ist eine verkürzte, aber Arbeitsrahmen Spezifikationen OpenAPI 3.1 für MVP.

openapi: 3.1.0

info:

  title: Crystal Construction API

  version: 1.0.0

  Beschreibung: API MVP Plattform "Kristallbau"

servers:

  - url: https://api.crystal-construction.local/api/v1

tags:

  - name: Auth

  - name: Companies

  - name: Projects

  - name: Contracts

  - name: Risks

  - name: Graph

  - name: Analytics

paths:

  /auth/login:

    post:

      tags: [Auth]

      summary: Benutzeranmeldung

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/LoginRequest'

      responses:

        '200':

          Beschreibung: Erfolgreicher Login

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/AuthResponse'

  /auth/me:

    get:

      tags: [Auth]

      summary: Aktuelles Benutzerprofil

      security:

        - bearerAuth: []

      responses:

        '200':

          Beschreibung: Benutzerprofil

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/UserProfileResponse'

  /companies:

    get:

      tags: [Companies]

      summary: Liste der Unternehmen

      security:

        - bearerAuth: []

      parameters:

        - in: query

          name: search

          schema: { type: string }

        - in: query

          name: companyType

          schema: { type: string }

        - in: query

          name: status

          schema: { type: string }

        - in: query

          name: page

          schema: { type: integer, minimum: 1, default: 1 }

        - in: query

          name: limit

          schema: { type: integer, minimum: 1, maximum: 100, default: 20 }

      responses:

        '200':

          Beschreibung: Liste der Unternehmen

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/CompanyListResponse'

    post:

      tags: [Companies]

      summary: Ein Unternehmen gründen

      security:

        - bearerAuth: []

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/CreateCompanyRequest'

      responses:

        '201':

          Description: Das Unternehmen gegründet

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/CompanyResponse'

  /companies/{id}:

    get:

      tags: [Companies]

      summary: Firmenkarte

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

      responses:

        '200':

          Beschreibung: Unternehmensdaten

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/CompanyResponse'

    patch:

      tags: [Companies]

      summary: Aktualisieren Sie Ihr Unternehmen

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/UpdateCompanyRequest'

      responses:

        '200':

          Beschreibung: Das Unternehmen wurde aktualisiert

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/CompanyResponse'

  /companies/{id}/relations:

    get:

      tags: [Graph]

      summary: Firmenverbindungsgraph

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

        - in: query

          name: depth

          schema: { type: integer, minimum: 1, maximum: 3, default: 1 }

      responses:

        '200':

          Beschreibung: Graf der Firma

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/GraphResponse'

  /projects:

    get:

      tags: [Projects]

      summary: Liste der Projekte

      security:

        - bearerAuth: []

      parameters:

        - in: query

          name: status

          schema: { type: string }

        - in: query

          name: lifecycleStage

          schema: { type: string }

        - in: query

          name: regionId

          schema: { type: string, format: uuid }

        - in: query

          name: customerCompanyId

          schema: { type: string, format: uuid }

        - in: query

          name: search

          schema: { type: string }

        - in: query

          name: page

          schema: { type: integer, default: 1 }

        - in: query

          name: limit

          schema: { type: integer, default: 20 }

      responses:

        '200':

          Beschreibung: Projektliste

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ProjectListResponse'

    post:

      tags: [Projects]

      summary: Projekt erstellen

      security:

        - bearerAuth: []

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/CreateProjectRequest'

      responses:

        '201':

          Beschreibung: Projekt erstellt

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ProjectResponse'

  /projects/{id}:

    get:

      tags: [Projects]

      summary: Projektkarte

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

      responses:

        '200':

          Beschreibung: Projektdaten

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ProjectResponse'

    patch:

      tags: [Projects]

      summary: Projekt aktualisieren

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/UpdateProjectRequest'

      responses:

        '200':

          Beschreibung: Projekt wurde aktualisiert

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ProjectResponse'

  /projects/{id}/graph:

    get:

      tags: [Graph]

      summary: Projektgraph

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

        - in: query

          name: depth

          schema: { type: integer, minimum: 1, maximum: 3, default: 2 }

      responses:

        '200':

          Beschreibung: Projektgraph

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ProjectGraphResponse'

  /projects/{id}/companies:

    post:

      tags: [Projects]

      summary: Fügen Sie einen Teilnehmer zum Projekt hinzu

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/AddCompanyToProjectRequest'

      responses:

        '201':

          Beschreibung: Mitglied hinzugefügt

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/OperationResponse'

  /contracts:

    get:

      tags: [Contracts]

      summary: Liste der Verträge

      security:

        - bearerAuth: []

      parameters:

        - in: query

          name: projectId

          schema: { type: string, format: uuid }

        - in: query

          name: customerCompanyId

          schema: { type: string, format: uuid }

        - in: query

          name: contractorCompanyId

          schema: { type: string, format: uuid }

        - in: query

          name: status

          schema: { type: string }

      responses:

        '200':

          Beschreibung: Vertragsliste

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ContractListResponse'

    post:

      tags: [Contracts]

      summary: Einen Vertrag erstellen

      security:

        - bearerAuth: []

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/CreateContractRequest'

      responses:

        '201':

          Description: Vertrag erstellt

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/ContractResponse'

  /risks:

    get:

      tags: [Risks]

      summary: Liste der Risiken

      security:

        - bearerAuth: []

      parameters:

        - in: query

          name: projectId

          schema: { type: string, format: uuid }

        - in: query

          name: severity

          schema: { type: string }

        - in: query

          name: status

          schema: { type: string }

      responses:

        '200':

          Beschreibung: Risikoliste

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/RiskListResponse'

    post:

      tags: [Risks]

      summary: Risiko schaffen

      security:

        - bearerAuth: []

      requestBody:

        required: true

        content:

          application/json:

            schema:

              $ref: '#/components/schemas/CreateRiskRequest'

      responses:

        '201':

          Beschreibung: Das Risiko ist geschaffen

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/RiskResponse'

  /risks/{id}/resolve:

    post:

      tags: [Risks]

      Summary: Schließen Risiko

      security:

        - bearerAuth: []

      parameters:

        - $ref: '#/components/parameters/IdPath'

      responses:

        '200':

          Beschreibung: Das Risiko ist gebannt

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/RiskResponse'

  /analytics/dashboard:

    get:

      tags: [Analytics]

      summary: Dashboard MVP

      security:

        - bearerAuth: []

      responses:

        '200':

          Beschreibung: Analytik

          content:

            application/json:

              schema:

                $ref: '#/components/schemas/DashboardResponse'

components:

  securitySchemes:

    bearerAuth:

      type: http

      scheme: bearer

      bearerFormat: JWT

  parameters:

    IdPath:

      in: path

      name: id

      required: true

      schema:

        type: string

        format: uuid

  schemas:

    ApiError:

      type: object

      properties:

        code: { type: string }

        message: { type: string }

      required: [code, message]

    LoginRequest:

      type: object

      properties:

        email: { type: string, format: email }

        password: { type: string }

      required: [email, password]

    AuthUser:

      type: object

      properties:

        id: { type: string, format: uuid }

        fullName: { type: string }

        email: { type: string, format: email }

        roles:

          type: array

          items: { type: string }

      required: [id, fullName, email, roles]

    AuthResponse:

      type: object

      properties:

        data:

          type: object

          properties:

            accessToken: { type: string }

            refreshToken: { type: string }

            user:

              $ref: '#/components/schemas/AuthUser'

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    UserProfileResponse:

      type: object

      properties:

        data:

          $ref: '#/components/schemas/AuthUser'

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    Company:

      type: object

      properties:

        id: { type: string, format: uuid }

        name: { type: string }

        shortName: { type: string }

        inn: { type: string }

        ogrn: { type: string }

        companyType: { type: string }

        rating: { type: number }

        status: { type: string }

        website: { type: string, nullable: true }

      required: [id, name, companyType, status]

    CreateCompanyRequest:

      type: object

      properties:

        name: { type: string }

        shortName: { type: string }

        inn: { type: string }

        ogrn: { type: string }

        companyType: { type: string }

        website: { type: string }

      required: [name, inn, ogrn, companyType]

    UpdateCompanyRequest:

      type: object

      properties:

        name: { type: string }

        shortName: { type: string }

        companyType: { type: string }

        rating: { type: number }

        status: { type: string }

        website: { type: string }

    CompanyResponse:

      type: object

      properties:

        data:

          $ref: '#/components/schemas/Company'

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    CompanyListResponse:

      type: object

      properties:

        data:

          type: array

          items:

            $ref: '#/components/schemas/Company'

        meta:

          type: object

          properties:

            page: { type: integer }

            limit: { type: integer }

            total: { type: integer }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    LocationInput:

      type: object

      properties:

        regionId: { type: string, format: uuid }

        address: { type: string }

        lat: { type: number }

        lon: { type: number }

        cadastralNumber: { type: string }

      required: [regionId, address]

    Project:

      type: object

      properties:

        id: { type: string, format: uuid }

        code: { type: string }

        name: { type: string }

        description: { type: string, nullable: true }

        projectType: { type: string }

        lifecycleStage: { type: string }

        status: { type: string }

        customerCompanyId: { type: string, format: uuid }

        startDate: { type: string, format: date, nullable: true }

        endDate: { type: string, format: date, nullable: true }

        plannedBudget: { type: number, nullable: true }

        actualBudget: { type: number, nullable: true }

      required: [id, name, projectType, lifecycleStage, status]

    CreateProjectRequest:

      type: object

      properties:

        name: { type: string }

        description: { type: string }

        projectType: { type: string }

        lifecycleStage: { type: string }

        status: { type: string }

        location:

          $ref: '#/components/schemas/LocationInput'

        customerCompanyId: { type: string, format: uuid }

        startDate: { type: string, format: date }

        endDate: { type: string, format: date }

        plannedBudget: { type: number }

      required:

        - name

        - projectType

        - lifecycleStage

        - status

        - location

        - customerCompanyId

    UpdateProjectRequest:

      type: object

      properties:

        name: { type: string }

        description: { type: string }

        lifecycleStage: { type: string }

        status: { type: string }

        actualBudget: { type: number }

        endDate: { type: string, format: date }

    ProjectResponse:

      type: object

      properties:

        data:

          $ref: '#/components/schemas/Project'

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    ProjectListResponse:

      type: object

      properties:

        data:

          type: array

          items:

            $ref: '#/components/schemas/Project'

        meta:

          type: object

          properties:

            page: { type: integer }

            limit: { type: integer }

            total: { type: integer }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    GraphNode:

      type: object

      properties:

        id: { type: string }

        type: { type: string }

        name: { type: string }

        status: { type: string, nullable: true }

        metadata:

          type: object

          additionalProperties: true

      required: [id, type, name]

    GraphEdge:

      type: object

      properties:

        from: { type: string }

        to: { type: string }

        type: { type: string }

        role: { type: string, nullable: true }

        status: { type: string, nullable: true }

        metadata:

          type: object

          additionalProperties: true

      required: [from, to, type]

    GraphResponse:

      type: object

      properties:

        data:

          type: object

          properties:

            nodes:

              type: array

              items: { $ref: '#/components/schemas/GraphNode' }

            edges:

              type: array

              items: { $ref: '#/components/schemas/GraphEdge' }

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    ProjectGraphResponse:

      type: object

      properties:

        data:

          type: object

          properties:

            project:

              $ref: '#/components/schemas/Project'

            nodes:

              type: array

              items: { $ref: '#/components/schemas/GraphNode' }

            edges:

              type: array

              items: { $ref: '#/components/schemas/GraphEdge' }

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    CreateContractRequest:

      type: object

      properties:

        projectId: { type: string, format: uuid }

        contractNumber: { type: string }

        contractType: { type: string }

        customerCompanyId: { type: string, format: uuid }

        contractorCompanyId: { type: string, format: uuid }

        amount: { type: number }

        currency: { type: string }

        dateStart: { type: string, format: date }

        dateEnd: { type: string, format: date }

        status: { type: string }

      required:

        - projectId

        - contractNumber

        - contractType

        - customerCompanyId

        - contractorCompanyId

        - amount

        - currency

        - status

    Contract:

      type: object

      properties:

        id: { type: string, format: uuid }

        projectId: { type: string, format: uuid }

        contractNumber: { type: string }

        contractType: { type: string }

        customerCompanyId: { type: string, format: uuid }

        contractorCompanyId: { type: string, format: uuid }

        amount: { type: number }

        currency: { type: string }

        status: { type: string }

      required: [id, projectId, contractNumber, contractType, amount, currency, status]

    ContractResponse:

      type: object

      properties:

        data:

          $ref: '#/components/schemas/Contract'

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    ContractListResponse:

      type: object

      properties:

        data:

          type: array

          items: { $ref: '#/components/schemas/Contract' }

        meta: { type: object }

        error:

          oneOf:

            - $ref: '#/components/schemas/ApiError'

            - { type: 'null' }

    CreateRiskRequest:

      type: object

      properties:

        projectId: { type: string, format: uuid }

        relatedCompanyId: { type: string, format: uuid, nullable: true }

        riskType: { type: string }

        severity: { type: string }

        probability: { type: string }

        description: { type: string }

      required: [projectId, riskType, severity, probability, description]

    Risk:

      type: object

      properties:

        id: { type: string, format: uuid }

        projectId: { type: string, format: uuid }

        relatedCompanyId: { type: string, format