{
  "$schema": "https://raw.githubusercontent.com/docToolchain/Bausteinsicht/main/schemas/bausteinsicht.schema.json",

  // Define available element and relationship kinds
  "specification": {
    "elements": {
      "actor": {
        "notation": "Actor",
        "description": "A person or external system that interacts with the system"
      },
      "system": {
        "notation": "Software System",
        "description": "A top-level software system",
        "container": true
      },
      "container": {
        "notation": "Container",
        "description": "A deployable unit within a system",
        "container": true
      },
      "component": {
        "notation": "Component",
        "description": "A logical grouping within a container",
        "container": true
      }
    },
    "relationships": {
      "uses": { "notation": "uses" },
      "async": { "notation": "async", "dashed": true }
    }
  },

  // The actual architecture elements and their hierarchy
  "model": {
    "customer": {
      "kind": "actor",
      "title": "Customer",
      "description": "End user of the webshop"
    },
    "webshop": {
      "kind": "system",
      "title": "Webshop",
      "description": "Online shopping platform",
      "children": {
        "api": {
          "kind": "container",
          "title": "REST API",
          "technology": "Spring Boot",
          "description": "Handles all HTTP requests",
          "children": {
            "auth": {
              "kind": "component",
              "title": "Auth Module",
              "technology": "Spring Security"
            }
          }
        },
        "db": {
          "kind": "container",
          "title": "Database",
          "technology": "PostgreSQL",
          "description": "Stores all persistent data"
        }
      }
    }
  },

  // Connections between elements
  "relationships": [
    {
      "from": "customer",
      "to": "webshop.api",
      "label": "uses",
      "kind": "uses",
      "description": "Sends HTTP requests"
    },
    {
      "from": "webshop.api",
      "to": "webshop.db",
      "label": "reads/writes",
      "kind": "uses"
    }
  ],

  // View definitions
  "views": {
    "context": {
      "title": "System Context",
      "include": ["customer", "webshop"],
      "description": "High-level system overview"
    },
    "containers": {
      "title": "Container View",
      "scope": "webshop",
      "include": ["customer", "webshop.*"],
      "description": "Webshop internals"
    }
  },

  // Dynamic views: sequence diagrams describing runtime behaviour
  "dynamicViews": [
    {
      "key": "login-flow",
      "title": "Login Flow",
      "description": "Customer logs in to the webshop",
      "steps": [
        { "index": 1, "from": "customer",    "to": "webshop.api", "label": "POST /login",  "type": "sync" },
        { "index": 2, "from": "webshop.api", "to": "webshop.db",  "label": "findUser()",   "type": "sync" },
        { "index": 3, "from": "webshop.db",  "to": "webshop.api", "label": "user record",  "type": "return" },
        { "index": 4, "from": "webshop.api", "to": "customer",    "label": "200 OK + JWT", "type": "return" }
      ]
    }
  ]
}

// Top-level model file
type BausteinsichtModel struct {
    Schema        string                 `json:"$schema,omitempty"`
    Config        Config                 `json:"config,omitempty"`
    Meta          map[string]interface{} `json:"meta,omitempty"`
    Specification Specification          `json:"specification"`
    Model         map[string]Element     `json:"model"`
    Relationships []Relationship         `json:"relationships"`
    Views         map[string]View        `json:"views"`
    DynamicViews  []DynamicView          `json:"dynamicViews,omitempty"`
    Constraints   []Constraint           `json:"constraints,omitempty"`
    AsIs          *ModelSnapshot         `json:"asIs,omitempty"`
    ToBe          *ModelSnapshot         `json:"toBe,omitempty"`
}

// Specification defines available element and relationship kinds
type Specification struct {
    Elements      map[string]ElementKind       `json:"elements"`
    Relationships map[string]RelationshipKind  `json:"relationships,omitempty"`
    Tags          []TagDefinition              `json:"tags,omitempty"`
    Patterns      map[string]PatternDefinition `json:"patterns,omitempty"`
    Decisions     []DecisionRecord             `json:"decisions,omitempty"`
}

type ElementKind struct {
    Notation    string `json:"notation"`
    Description string `json:"description,omitempty"`
    Container   bool   `json:"container,omitempty"`
}

type RelationshipKind struct {
    Notation string `json:"notation"`
    Dashed   bool   `json:"dashed,omitempty"`
}

// Element represents an architecture building block
type Element struct {
    Kind         string             `json:"kind"`
    Title        string             `json:"title"`
    Description  string             `json:"description,omitempty"`
    Technology   string             `json:"technology,omitempty"`
    Tags         []string           `json:"tags,omitempty"`
    Status       string             `json:"status,omitempty"`       // proposed|design|implementation|deployed|deprecated|archived
    Decisions    []string           `json:"decisions,omitempty"`    // linked ADR IDs
    LastModified string             `json:"lastModified,omitempty"` // RFC3339; overrides git-based staleness
    Children     map[string]Element `json:"children,omitempty"`
    Metadata     map[string]string  `json:"metadata,omitempty"`
    Link         string             `json:"link,omitempty"`     // hyperlink on the draw.io shape and in SVG export
    DocLinks     []DocLink          `json:"docLinks,omitempty"` // typed documentation links, rendered as clickable icons (#543)
}

// DocLink is a typed link to an external documentation artifact (#543)
type DocLink struct {
    Type  string `json:"type"`  // free string; conventional: arc42|adr|persona|prd|spec
    Href  string `json:"href"`
    Title string `json:"title,omitempty"` // icon tooltip; defaults to Type when omitted
}

// Relationship connects two elements
type Relationship struct {
    From        string   `json:"from"`
    To          string   `json:"to"`
    Label       string   `json:"label,omitempty"`
    Kind        string   `json:"kind,omitempty"`
    Description string   `json:"description,omitempty"`
    Decisions   []string `json:"decisions,omitempty"`   // linked ADR IDs
    Cardinality string   `json:"cardinality,omitempty"` // 1:1|1:N|N:N
    DataFlow    string   `json:"dataFlow,omitempty"`    // sync|async|request/response|publish/subscribe
}

// View defines which elements appear in a diagram
type View struct {
    Title       string   `json:"title"`
    Scope       string   `json:"scope,omitempty"`
    Include     []string `json:"include,omitempty"`
    Exclude     []string `json:"exclude,omitempty"`
    FilterTags  []string `json:"filter-tags,omitempty"`  // include only elements with ALL of these tags
    ExcludeTags []string `json:"exclude-tags,omitempty"` // exclude elements with ANY of these tags
    Description string   `json:"description,omitempty"`
    Layout      string   `json:"layout,omitempty"`   // layered (default)|grid|none
    DocLinks    []DocLink `json:"docLinks,omitempty"` // view-level documentation links (#543)
}

// DynamicView describes a sequence diagram scenario
type DynamicView struct {
    Key         string         `json:"key"`
    Title       string         `json:"title"`
    Description string         `json:"description,omitempty"`
    Steps       []SequenceStep `json:"steps"`
}

// SequenceStep is one message in a dynamic view
type SequenceStep struct {
    Index int      `json:"index"`
    From  string   `json:"from"`
    To    string   `json:"to"`
    Label string   `json:"label"`
    Type  StepType `json:"type,omitempty"`
}

type StepType string

const (
    StepSync   StepType = "sync"
    StepAsync  StepType = "async"
    StepReturn StepType = "return"
)

// Constraint defines an architectural rule enforced via `bausteinsicht lint`.
// no-relationship/allowed-relationship endpoint selectors (from/to) and the
// required-field element selector (tag/element-kind) are checked in order of
// specificity — exact ID > tag > kind — whichever field is non-empty wins.
// The allow-list forms (from-tags/from-kinds) rank with their singular
// counterpart: tag/from-tags outrank kind/from-kinds, but not exact ID.
type Constraint struct {
    ID          string `json:"id"`
    Description string `json:"description"`
    Rule        string `json:"rule"` // no-relationship|allowed-relationship|required-field|max-depth|no-circular-dependency|technology-allowed

    // no-relationship / allowed-relationship: "from" endpoint selector
    From      string   `json:"from,omitempty"`       // exact element ID
    FromTag   string   `json:"from-tag,omitempty"`   // element must have this tag
    FromKind  string   `json:"from-kind,omitempty"`  // element must have this kind
    FromTags  []string `json:"from-tags,omitempty"`  // allow-list: element must have ANY of these tags (allowed-relationship only)
    FromKinds []string `json:"from-kinds,omitempty"` // allow-list: element must have this kind (allowed-relationship only)

    // no-relationship / allowed-relationship: "to" endpoint selector
    To     string `json:"to,omitempty"`
    ToTag  string `json:"to-tag,omitempty"`
    ToKind string `json:"to-kind,omitempty"`

    // required-field: element selector (Tag takes precedence over ElementKind if both are set)
    ElementKind string `json:"element-kind,omitempty"`
    Tag         string `json:"tag,omitempty"`
    Field       string `json:"field,omitempty"` // description|technology|title

    Max          int      `json:"max,omitempty"`          // max-depth
    Technologies []string `json:"technologies,omitempty"` // technology-allowed
}

// Config holds top-level configuration for diagram generation
type Config struct {
    Metadata *bool  `json:"metadata,omitempty"`
    Legend   *bool  `json:"legend,omitempty"`
    Author   string `json:"author,omitempty"`
    Repo     string `json:"repo,omitempty"`
}

// ModelSnapshot is an as-is or to-be capture used by the diff command
type ModelSnapshot struct {
    Elements      map[string]Element `json:"elements"`
    Relationships []Relationship     `json:"relationships"`
}