Conceptual Model

The UML-based model defining FERIN's structure: components, identifiers, statuses, relations, and proposals.

Model Overview

The FERIN conceptual model is organized into packages:

Components Package

Core entities: Register, Register Item, Concept, Concept Version

Identifiers Package

Identifier types and assignment rules

Statuses Package

Status values and transitions

Relations Package

Relationship types between entities

Proposal Package

Proposal and appeal structures

Components Package

Core Entities

┌─────────────────────────────────────────────────────────────────┐
│                           REGISTER                               │
├─────────────────────────────────────────────────────────────────┤
│ + title : String                                                 │
│ + description : String                                           │
│ + specification : RegisterSpecification                          │
│ + owner : RegisterOwner                                          │
│ + manager : RegisterManager                                      │
├─────────────────────────────────────────────────────────────────┤
│ + addItem(item) : void                                           │
│ + getItem(id) : RegisterItem                                     │
│ + query(criteria) : Collection                                   │
└─────────────────────────────────────────────────────────────────┘
                                │
                                │ contains
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                        REGISTER ITEM                              │
├─────────────────────────────────────────────────────────────────┤
│ + identifier : ObjectIdentifier                                  │
│ + functionalId : FunctionalIdentifier [0..1]                     │
│ + status : Status                                                │
│ + dateAdded : DateTime                                           │
│ + dateModified : DateTime                                        │
│ + content : Any                                                  │
├─────────────────────────────────────────────────────────────────┤
│ + realizedConcept : Concept [0..1]                               │
└─────────────────────────────────────────────────────────────────┘
                                │
                                │ realizes
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                           CONCEPT                                 │
├─────────────────────────────────────────────────────────────────┤
│ + identifier : ObjectIdentifier                                  │
│ + currentDefinition : ConceptDefinition                          │
│ + versions : ConceptVersion [*]                                  │
│ + status : Status                                                │
├─────────────────────────────────────────────────────────────────┤
│ + addVersion(definition) : ConceptVersion                        │
│ + getDefinition(atDate) : ConceptDefinition                      │
└─────────────────────────────────────────────────────────────────┘

LutaML Class Definitions

The FERIN conceptual model can be expressed using LutaML (LML) syntax, which provides a human-readable format for defining information models that can be directly serialized to multiple formats.

Core Classes

package FERIN {

  class Register {
    attribute title, String {
      definition "The official title of the register"
    }
    attribute description, String {
      definition "A description of the register's purpose and scope"
      cardinality 0..1
    }
    attribute specification, RegisterSpecification
    attribute owner, RegisterOwner
    attribute manager, RegisterManager
    attribute controlBody, ControlBody { cardinality 0..1 }
    attribute operationalStatus, OperationalStatus
  }

  class Concept {
    attribute identifier, ObjectIdentifier
    attribute currentDefinition, ConceptDefinition
    attribute versions, ConceptVersion { cardinality 0..n }
    attribute status, Status
    attribute dateAdded, DateTime
    attribute dateModified, DateTime
  }

  class ConceptVersion {
    attribute identifier, ObjectIdentifier
    attribute definition, ConceptDefinition
    attribute validFrom, DateTime
    attribute validUntil, DateTime { cardinality 0..1 }
    attribute status, Status
    attribute changeReason, String { cardinality 0..1 }
  }

  class RegisterItem {
    attribute identifier, ObjectIdentifier
    attribute functionalId, FunctionalIdentifier { cardinality 0..1 }
    attribute concept, Concept { cardinality 0..1 }
    attribute status, Status
    attribute content, Content
    attribute dateAdded, DateTime
    attribute dateModified, DateTime
  }

  class Status {
    attribute valid, Boolean { default: true }
    attribute published, Boolean { default: true }
    attribute superseded, Boolean { default: false }
    attribute supersededBy, RegisterItem { cardinality 0..1 }
    attribute redacted, Boolean { default: false }
    attribute deleted, Boolean { default: false }
  }
}

Identifier Classes

package FERIN::Identifiers {

  class Identifier {
    attribute value, String
    attribute assignedDate, DateTime

    definition {
      Base class for all identifier types in FERIN.
    }
  }

  class ObjectIdentifier {
    attribute value, String
    attribute persistent, Boolean { default: true }
    attribute opaque, Boolean { default: false }
    attribute scheme, String

    definition {
      A unique, persistent identifier that never changes
      once assigned. Object identifiers are typically
      UUIDs or other opaque identifiers.
    }
  }

  class FunctionalIdentifier {
    attribute value, String
    attribute semantic, Boolean { default: true }
    attribute resolvable, Boolean { default: false }
    attribute validFrom, DateTime
    attribute validUntil, DateTime { cardinality 0..1 }

    definition {
      A human-meaningful identifier that may be reassigned
      through governance processes. Examples include
      country codes, currency codes, etc.
    }
  }
}

Governance Classes

package FERIN::Governance {

  enum OperationalStatus {
    value "establishment" {
      definition "Register is being set up"
    }
    value "operational" {
      definition "Register is actively maintained"
    }
    value "dormant" {
      definition "Register exists but not actively updated"
    }
    value "decommissioned" {
      definition "Register has been retired"
    }
  }

  class RegisterOwner {
    attribute name, String
    attribute contactInfo, String { cardinality 0..1 }
    attribute responsibilities, String

    definition {
      The entity accountable for the register's existence
      and strategic direction.
    }
  }

  class RegisterManager {
    attribute name, String
    attribute contactInfo, String { cardinality 0..1 }
    attribute responsibilities, String

    definition {
      The entity responsible for day-to-day register operations.
    }
  }

  class ControlBody {
    attribute name, String
    attribute members, String { cardinality 0..n }
    attribute meetingSchedule, String { cardinality 0..1 }

    definition {
      The entity responsible for reviewing and deciding
      on proposals to change register content.
    }
  }

  class Proposal {
    attribute identifier, ObjectIdentifier
    attribute proposer, String
    attribute actionType, ActionType
    attribute justification, String
    attribute status, ProposalStatus
    attribute dateSubmitted, DateTime
    attribute dateDecided, DateTime { cardinality 0..1 }
    attribute decision, Decision { cardinality 0..1 }
  }

  enum ActionType {
    value "add"
    value "change"
    value "invalidate"
    value "supersede"
    value "unpublish"
    value "redact"
    value "delete"
  }

  enum ProposalStatus {
    value "submitted"
    value "under_review"
    value "approved"
    value "rejected"
    value "withdrawn"
  }
}

Identifiers Package

Identifier Types

                    ┌───────────────────┐
                    │    Identifier     │«abstract»
                    ├───────────────────┤
                    │ + value : String  │
                    └─────────┬─────────┘
                              │
              ┌───────────────┴───────────────┐
              │                               │
              ▼                               ▼
┌─────────────────────────┐   ┌─────────────────────────┐
│   ObjectIdentifier      │   │  FunctionalIdentifier   │
├─────────────────────────┤   ├─────────────────────────┤
│ + persistent : Boolean  │   │ + semantic : Boolean    │
│ + opaque : Boolean      │   │ + resolvable : Boolean  │
└─────────────────────────┘   └─────────────────────────┘

Identifier Assignment Rules

  • Object identifiers are assigned at creation and never change
  • Functional identifiers may be reassigned with governance approval
  • Both types may coexist on the same item

Statuses Package

Status Model

┌─────────────────────────────────────────────────────────────────┐
│                          STATUS                                  │
├─────────────────────────────────────────────────────────────────┤
│ + valid : Boolean          (default: true)                      │
│ + published : Boolean      (default: true)                      │
│ + superseded : Boolean     (default: false)                     │
│ + supersededBy : Item      (if superseded)                      │
│ + redacted : Boolean       (default: false)                     │
│ + deleted : Boolean        (default: false)                     │
└─────────────────────────────────────────────────────────────────┘

Status Transitions

Statuses change through specific actions:

ActionStatus Change
Addvalid=true, published=true
Invalidatevalid=false
Unpublishpublished=false
Supersedesuperseded=true, link to superseding item
Redactredacted=true
Deletedeleted=true

Relations Package

Relation Types

RelationFromToDescription
hasConceptConceptConceptGeneralization (parent concept)
instanceOfConceptConceptMembership in a category
hasDefinitionConceptConceptSchema reference
supersedesConcept/ItemConcept/ItemReplacement
inheritsConceptConceptProperty inheritance
hasPartConceptConceptComposition

Related Topics

See Also

Glossary

Term definitions

Statuses

Status reference

Relations

Relationship types