infomodel

type AccessResolver func(r *http.Request, applicationID string) (ApplicationAccess, error)

type ApplicationAccess struct {
	Exists    bool
	CanView   bool
	CanEdit   bool
	Protected bool
}

type Association struct {
	ID   string `json:"id"`
	Name string `json:"name,omitempty"`
	Kind string `json:"kind"`
	// From is the source end. For a generalization it is the *specific* class ("an
	// ExpressOrder is an Order"); for a composition or aggregation it is the whole.
	From End `json:"from"`
	To   End `json:"to"`
}

type AssociationKind struct {
	Kind  string `json:"kind"`
	Label string `json:"label"`
	// Rule is the sentence this implements, in plain words, so a refusal can say
	// *why* rather than only that it was refused.
	Rule string `json:"rule"`
	// Directed reports whether the two ends mean different things, so the canvas
	// knows whether reversing the arrow changes the statement.
	Directed bool `json:"directed"`
}

type Attribute struct {
	Name string `json:"name"`
	// Type is a primitive (see PrimitiveTypes) or the name of another class in the
	// same model — including an «enumeration», which is how a closed set of values
	// is declared.
	Type          string `json:"type"`
	Multiplicity  string `json:"multiplicity"`
	Documentation string `json:"documentation,omitempty"`
}

type Class struct {
	// ID is stable across renames, so an association survives its class being
	// renamed; Name is what a model and a diagram refer to, and what
	// `itemSubjectRef` matches.
	ID            string `json:"id"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Stereotype says what kind of type this is, and it is what most of the
	// relationship rules in subset.go are actually about — see the constants there.
	Stereotype string      `json:"stereotype"`
	Attributes []Attribute `json:"attributes"`
	// Literals are the members of an «enumeration», which has literals where every
	// other stereotype has attributes. Empty otherwise.
	Literals []string `json:"literals,omitempty"`
	// Identity names the attributes that together form the business key: the fact
	// that makes Order#ORD-1 the same order in three processes and in a data store.
	// It is the part BPMN has no equivalent for, and every cross-process capability
	// rests on it. Empty for a class whose instances have no identity of their own.
	Identity []string `json:"identity,omitempty"`
	// Lifecycle is the states this class's instances move through, and what a BPMN
	// data state resolves against (ADR-0259). It sits here beside the business key
	// because both are facts about a business object that BPMN has no field for, and
	// because a lifecycle scoped to one process would reproduce the very problem the
	// information model exists to solve.
	//
	// nil is the normal case and means silence everywhere: a class without one is
	// exactly as it was before this existed.
	Lifecycle *Lifecycle `json:"lifecycle,omitempty"`
	// X and Y place the class on the canvas. Layout is part of the document because
	// a diagram a person arranged is a diagram they can read again.
	X float64 `json:"x"`
	Y float64 `json:"y"`
}

type Clock func() time.Time

type DataStore struct {
	ID            string `json:"id"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Class is the class whose instances this store holds. It must be a business
	// object with a business key: a store you cannot address something in by its
	// identity is not a store a process can read from.
	Class string `json:"class"`
	// Worker is the configured Worker that backs it (ADR-0036/0203) — a clio event
	// store, a database, a SharePoint list. Empty while the store is modeled but not
	// yet wired to anything, which is a normal state and not an error: a store is
	// routinely drawn before somebody configures the worker behind it.
	Worker string `json:"worker,omitempty"`
	// Mode is what a process may do with it. Read-only today; writing through a store
	// is a decision of its own (transactionality against something outside the engine)
	// and gets its own record.
	Mode string  `json:"mode"`
	X    float64 `json:"x"`
	Y    float64 `json:"y"`
}

type End struct {
	ClassID      string `json:"classId"`
	Role         string `json:"role,omitempty"`
	Multiplicity string `json:"multiplicity,omitempty"`
}

type Finding struct {
	Code    string `json:"code"`
	Reason  string `json:"reason"`
	Message string `json:"message"`
	// Exactly one of ClassID / AssociationID / StoreID identifies where the finding
	// is; Attribute names the member within a class when the finding is about one.
	ClassID       string `json:"classId,omitempty"`
	AssociationID string `json:"associationId,omitempty"`
	StoreID       string `json:"storeId,omitempty"`
	Attribute     string `json:"attribute,omitempty"`
	// State and Transition locate a finding inside a class's lifecycle, the way
	// Attribute locates one inside its members — so the state canvas can mark the
	// state or the arrow that is wrong instead of colouring the whole class.
	State      string `json:"state,omitempty"`
	Transition string `json:"transition,omitempty"`
}

type Graph struct {
	Nodes      []ObjectNode    `json:"nodes"`
	Links      []ObjectLink    `json:"links"`
	Unresolved []UnresolvedRef `json:"unresolved"`
	// Degraded says the application models nothing, so this is the instance's data
	// without the structure a model would give it.
	Degraded bool `json:"degraded"`
	// Truncated says a guard stopped the walk, so the picture is a part of one.
	Truncated bool `json:"truncated"`
}

type IDGenerator func() (string, error)

type ImportNote struct {
	Level string `json:"level"`
	// Element names the thing in the source document — a class, an attribute, an id
	// — so a reader can find it in the tool the document came from.
	Element string `json:"element,omitempty"`
	Message string `json:"message"`
}

type ImportResponse struct {
	Format     string           `json:"format"`
	Notes      []ImportNote     `json:"notes"`
	Validation ValidationResult `json:"validation"`
	// Preview is the model the document would become, present on a dry run only.
	Preview *Model `json:"preview,omitempty"`
	// Model is the stored model, present when one was created.
	Model *Summary `json:"model,omitempty"`
}

type ImportResult struct {
	Format string       `json:"format"`
	Model  Model        `json:"model"`
	Notes  []ImportNote `json:"notes"`
}

type Lifecycle struct {
	States      []LifecycleState      `json:"states"`
	Transitions []LifecycleTransition `json:"transitions"`
}

type LifecycleRules struct {
	// Stereotypes that may carry one. Only a business object has an identity that
	// persists through states; a value type is equal to any other with the same
	// contents, and an enumeration is a set of values rather than a thing that moves
	// through them.
	Stereotypes []string `json:"stereotypes"`
	// Exactly one state is where an instance is created, and any number are where
	// instances end. Served rather than assumed, because "one start" is a rule the
	// canvas has to enforce while drawing and not only report afterwards.
	InitialStates int `json:"initialStates"`
	// SelfTransitions says a state may transition to itself: a record can be revised
	// without leaving the stage it is in.
	SelfTransitions bool `json:"selfTransitions"`
	// LeavesFinal says whether a transition may start at a final state. It may not —
	// "final" and "leaves" are the two saying opposite things.
	LeavesFinal bool `json:"leavesFinal"`
	// Guards says whether a transition may carry a condition. It may not, and the
	// reason travels with the answer: what causes a transition is the BPMN element
	// that writes the state, and a condition here would be a second place deciding
	// what happens.
	Guards  bool   `json:"guards"`
	Meaning string `json:"meaning"`
}

type LifecycleState struct {
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Initial marks where an instance starts. Exactly one state carries it: a machine
	// with no start says nothing about what an object is when it is created, and one
	// with two says two contradictory things.
	Initial bool `json:"initial,omitempty"`
	// Final marks a state nothing leaves. Any number of them, including none — an
	// order ends either shipped or cancelled, and a long-lived record may end nowhere.
	Final bool `json:"final,omitempty"`
	// X and Y place the state on the canvas, for the reason a class carries them: a
	// diagram somebody arranged is a diagram they can read again.
	X float64 `json:"x"`
	Y float64 `json:"y"`
}

type LifecycleTransition struct {
	ID   string `json:"id"`
	Name string `json:"name,omitempty"`
	// From and To are state names within this lifecycle. A transition to the state it
	// starts from is a self-loop and is allowed: a record can be revised without
	// leaving the stage it is in.
	From string `json:"from"`
	To   string `json:"to"`
}

type LossNote struct {
	Area   string `json:"area"`
	Reason string `json:"reason"`
}

type Model struct {
	ID            string `json:"id"`
	ApplicationID string `json:"applicationId"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	// Revision guards a concurrent overwrite: a write states the revision it read,
	// and a write against a stale one is refused rather than silently winning.
	Revision     int64         `json:"revision"`
	Classes      []Class       `json:"classes"`
	Associations []Association `json:"associations"`
	// Stores are where instances of a class live beyond one process instance — the
	// cross-process channel BPMN gestures at with <dataStoreReference> and then says
	// nothing about. They live in this document because a store is per application,
	// declared once and named by every process that reaches it; and beside the
	// classes rather than inside one, because a class stays storage-agnostic. Only
	// the store says where its instances are kept.
	Stores    []DataStore `json:"stores"`
	CreatedAt int64       `json:"createdAt"`
	CreatedBy string      `json:"createdBy,omitempty"`
	UpdatedAt int64       `json:"updatedAt"`
	UpdatedBy string      `json:"updatedBy,omitempty"`
}

type MultiplicityOption struct {
	Multiplicity string `json:"multiplicity"`
	Label        string `json:"label"`
	// Required and Collection are what the JSON Schema projection and the canvas
	// both need, derived here once rather than by parsing the string in two places.
	Required   bool `json:"required"`
	Collection bool `json:"collection"`
}

type ObjectAttribute struct {
	Name  string `json:"name"`
	Value string `json:"value"`
	Key   bool   `json:"key,omitempty"`
	// Absent distinguishes "this object does not carry that member" from "it carries
	// it, empty" — different facts about a datum, and the first is usually the one
	// worth noticing.
	Absent bool `json:"absent,omitempty"`
}

type ObjectLink struct {
	From  string `json:"from"`
	To    string `json:"to"`
	Kind  string `json:"kind"`
	Label string `json:"label,omitempty"`
	Via   string `json:"via"`
}

type ObjectNode struct {
	ID    string `json:"id"`
	Label string `json:"label"`
	Name  string `json:"name"`
	Class string `json:"class,omitempty"`
	State string `json:"state,omitempty"`
	// Key is the object's business key, rendered — what makes this object *this*
	// one, and what another object's reference has to match to become a line.
	Key        string            `json:"key,omitempty"`
	Attributes []ObjectAttribute `json:"attributes"`
	// Value is what the object holds, rendered as an attribute's value is (a scalar
	// as itself, a structure as its JSON). Carried for an object whose class is
	// unknown or whose value is not a structure — there is no attribute list to show
	// instead, and an object with neither would be an empty box.
	Value string `json:"value,omitempty"`
	// Nested marks a node that came out of a whole's value rather than being a data
	// object of the instance in its own right.
	Nested bool `json:"nested,omitempty"`
	Unset  bool `json:"unset,omitempty"`
}

type ObjectValue struct {
	Name string
	// Class is the resolved declared type, "" when the object is untyped or its
	// itemSubjectRef resolves to nothing.
	Class string
	State string
	// Value is the object's value as canonical JSON, nil when it is unset.
	Value json.RawMessage
}

type PrimitiveType struct {
	Type  string `json:"type"`
	Label string `json:"label"`
	// JSONType and JSONFormat are the projection: the draft 2020-12 type and the
	// format keyword this primitive becomes. A primitive with no format projects to
	// its bare type.
	JSONType   string `json:"jsonType"`
	JSONFormat string `json:"jsonFormat,omitempty"`
}

type Projection struct {
	Class  string         `json:"class"`
	Schema map[string]any `json:"schema"`
	Loss   []LossNote     `json:"loss"`
}

type Refusal struct {
	Reason  string `json:"reason"`
	Message string `json:"message"`
}

type Service struct {

	// Limits are the installation's resource budgets. New sets them to
	// [limits.Default]; the server overwrites them with its own once it has read the
	// environment, so every ceiling in this service is the one operators configured
	// (ADR-0291).
	Limits limits.Limits
	// contains filtered or unexported fields
}

type StereotypeKind struct {
	Stereotype string `json:"stereotype"`
	Label      string `json:"label"`
	// Meaning is the sentence a modeler needs to choose correctly. It travels to the
	// browser because the difference between a business object and a value type is
	// the single most consequential choice in this metamodel, and a palette that only
	// lists three words makes it by accident.
	Meaning string `json:"meaning"`
	// HasIdentity reports whether this kind may declare a business key. Only a
	// business object may: identity is what makes Order#ORD-1 the same order in three
	// processes, and a value with no independent existence has none to declare.
	HasIdentity bool `json:"hasIdentity"`
	// HasAttributes is false for an enumeration, which carries literals instead.
	HasAttributes bool `json:"hasAttributes"`
}

type Store struct {
	*sidecar.Store[Model]
}

type StoreMode struct {
	Mode    string `json:"mode"`
	Label   string `json:"label"`
	Meaning string `json:"meaning"`
}

type Subset struct {
	Version          int                  `json:"version"`
	Notation         string               `json:"notation"`
	Stereotypes      []StereotypeKind     `json:"stereotypes"`
	AssociationKinds []AssociationKind    `json:"associationKinds"`
	Primitives       []PrimitiveType      `json:"primitives"`
	Multiplicities   []MultiplicityOption `json:"multiplicities"`
	StoreModes       []StoreMode          `json:"storeModes"`
	// Lifecycles is the state machine a class may carry (ADR-0259).
	Lifecycles LifecycleRules `json:"lifecycles"`
	// Matrix is AllowAssociation precomputed for every stereotype pair, so the canvas
	// can grey out a connection while it is being dragged without a round trip. Keyed
	// "from>to".
	Matrix map[string][]string `json:"matrix"`
	Limits []SubsetLimit       `json:"limits"`
}

type SubsetLimit struct {
	Area   string `json:"area"`
	Reason string `json:"reason"`
}

type Summary struct {
	ID            string `json:"id"`
	ApplicationID string `json:"applicationId"`
	Name          string `json:"name"`
	Documentation string `json:"documentation,omitempty"`
	Revision      int64  `json:"revision"`
	Classes       int    `json:"classes"`
	Associations  int    `json:"associations"`
	Stores        int    `json:"stores"`
	CreatedAt     int64  `json:"createdAt"`
	CreatedBy     string `json:"createdBy,omitempty"`
	UpdatedAt     int64  `json:"updatedAt"`
	UpdatedBy     string `json:"updatedBy,omitempty"`
}

type UnresolvedRef struct {
	From  string `json:"from"`
	Role  string `json:"role"`
	Class string `json:"class"`
	Value string `json:"value"`
}

type ValidationResult struct {
	Valid    bool      `json:"valid"`
	Findings []Finding `json:"findings"`
}

type Vocabulary struct {
	// contains filtered or unexported fields
}