public interface IMetadataModel
{
    string Id { get; }
    string Name { get; }
    string Comment { get; }
    IEnumerable<IStereotype> Stereotypes { get; }
    bool HasStereotype(string stereotypeName);
    IStereotype GetStereotype(string stereotypeName);
}

public class EntityTemplate : IntentTemplateBase<ClassModel>
{
    public override string TransformText()
    {
        var isPersistent = Model.HasStereotype("Persistent");
        var isAuditable = Model.HasStereotype("Auditable");
        
        if (isPersistent)
        {
            // Generate persistence code
        }
        
        if (isAuditable)
        {
            // Generate audit fields
        }
        
        return GenerateClass();
    }
}

public interface IStereotype
{
    string Name { get; }
    string GetProperty(string propertyName);
    T GetProperty<T>(string propertyName);
    bool TryGetProperty(string propertyName, out string value);
}

public string GetTableName()
{
    if (Model.HasStereotype("Table"))
    {
        var tableStereotype = Model.GetStereotype("Table");
        var tableName = tableStereotype.GetProperty<string>("Name");
        
        if (!string.IsNullOrWhiteSpace(tableName))
        {
            return tableName;
        }
    }
    
    // Default to class name
    return Model.Name;
}

// Generated extension methods
public static class StereotypeExtensions
{
    public static bool HasAuditableStereotype(this IMetadataModel model)
    {
        return model.HasStereotype("Auditable");
    }

    public static AuditableSettings GetAuditableSettings(this IMetadataModel model)
    {
        var stereotype = model.GetStereotype("Auditable");
        return stereotype != null ? new AuditableSettings(stereotype) : null;
    }
}

public class AuditableSettings
{
    private readonly IStereotype _stereotype;

    public AuditableSettings(IStereotype stereotype)
    {
        _stereotype = stereotype;
    }

    public bool TrackCreated => _stereotype.GetProperty<bool>("Track Created");
    public bool TrackModified => _stereotype.GetProperty<bool>("Track Modified");
    public bool TrackDeleted => _stereotype.GetProperty<bool>("Track Deleted");
}

if (Model.HasAuditableStereotype())
{
    var settings = Model.GetAuditableSettings();
    
    if (settings.TrackCreated)
    {
        // Add CreatedDate, CreatedBy properties
    }
    
    if (settings.TrackModified)
    {
        // Add ModifiedDate, ModifiedBy properties
    }
}

public interface ITypeReference
{
    IElement Element { get; }
    bool IsNullable { get; }
    bool IsCollection { get; }
    IEnumerable<ITypeReference> GenericTypeParameters { get; }
}

public class PropertyTemplate : IntentTemplateBase<PropertyModel>
{
    public string GetPropertyType()
    {
        // Use template's type resolution system
        var typeName = GetTypeName(Model.TypeReference);
        
        // Type resolution handles:
        // - Finding the correct template that outputs this type
        // - Adding it as a dependency
        // - Applying collection formatters (List<T>, IEnumerable<T>, etc.)
        // - Applying nullable formatters (T?, Nullable<T>)
        
        return typeName;
    }
}

public class ServiceTemplate : IntentTemplateBase<ServiceModel>
{
    public string GetServiceMethods()
    {
        var methods = new StringBuilder();
        
        foreach (var operation in Model.Operations)
        {
            var returnType = GetTypeName(operation.ReturnType);
            var parameters = string.Join(", ", 
                operation.Parameters.Select(p => $"{GetTypeName(p.TypeReference)} {p.Name}"));
            
            methods.AppendLine($"{returnType} {operation.Name}({parameters});";
        }
        
        return methods.ToString();
    }
}

protected override void OnAfterMetadataLoad(IApplication application)
{
    // Get all domain classes
    var domainClasses = application.MetadataManager
        .Domain(application)
        .GetClassModels();
    
    foreach (var domainClass in domainClasses)
    {
        ValidateDomainClass(domainClass);
    }
}

private void ValidateDomainClass(ClassModel model)
{
    // Check for required stereotypes
    if (model.Attributes.Any() && !model.HasStereotype("Table"))
    {
        Logging.Log.Warning($"Class '{model.Name}' has properties but no Table stereotype");
    }
    
    // Validate properties
    foreach (var attribute in model.Attributes)
    {
        if (attribute.TypeReference.IsCollection && attribute.Name.EndsWith("Id"))
        {
            Logging.Log.Warning($"Property '{model.Name}.{attribute.Name}' is a collection but has 'Id' suffix");
        }
    }
}

public class ClassModel : IMetadataModel
{
    public ClassModel BaseType { get; }
    public IEnumerable<ClassModel> Interfaces { get; }
    public IEnumerable<AttributeModel> Attributes { get; }
    public IEnumerable<AssociationModel> AssociatedClasses { get; }
}

public class AssociationModel : IMetadataModel
{
    public ClassModel TargetClass { get; }
    public string Multiplicity { get; } // "1", "*", "0..1", etc.
    public bool IsNullable { get; }
    public bool IsCollection { get; }
}

public string GetNavigationProperties()
{
    var properties = new StringBuilder();
    
    foreach (var association in Model.AssociatedClasses)
    {
        var targetType = GetTypeName(association.TargetClass);
        var propertyName = association.Name;
        
        if (association.IsCollection)
        {
            properties.AppendLine($"public ICollection<{targetType}> {propertyName} {{ get; set; }}");
        }
        else if (association.IsNullable)
        {
            properties.AppendLine($"public {targetType}? {propertyName} {{ get; set; }}");
        }
        else
        {
            properties.AppendLine($"public {targetType} {propertyName} {{ get; set; }}");
        }
    }
    
    return properties.ToString();
}

<?xml version="1.0" encoding="utf-8"?>
<package>
  <id>Intent.Metadata.RDBMS</id>
  <version>1.0.0</version>
  <stereotypes>
    <stereotype name="Table" appliesTo="Class">
      <property name="Name" type="string" />
      <property name="Schema" type="string" />
    </stereotype>
    <stereotype name="Primary Key" appliesTo="Attribute">
      <property name="Identity" type="boolean" default="true" />
    </stereotype>
    <stereotype name="Index" appliesTo="Attribute">
      <property name="Unique" type="boolean" default="false" />
    </stereotype>
  </stereotypes>
</package>

if (Model.HasStereotype("Entity"))
{
    // Generate entity-specific code
}

if (Model.HasStereotype("Value Object"))
{
    // Generate value object-specific code
}

public IEnumerable<ClassModel> GetInheritanceHierarchy()
{
    var hierarchy = new List<ClassModel> { Model };
    var current = Model.BaseType;
    
    while (current != null)
    {
        hierarchy.Add(current);
        current = current.BaseType;
    }
    
    return hierarchy;
}

public IEnumerable<AttributeModel> GetAllAttributes()
{
    // Include attributes from base classes
    return GetInheritanceHierarchy()
        .SelectMany(c => c.Attributes)
        .ToList();
}

public interface IHasTags
{
    IEnumerable<string> Tags { get; }
    bool HasTag(string tag);
}

// Example usage
if (Model.HasTag("Deprecated"))
{
    // Add obsolete attribute
}

if (Model.HasTag("Internal"))
{
    // Make class internal instead of public
}

public static class MetadataManagerExtensions
{
    public static IDomainMetadata Domain(this IMetadataManager manager, IApplication application)
    {
        return new DomainMetadata(manager, application);
    }
}

public interface IDomainMetadata
{
    IEnumerable<ClassModel> GetClassModels();
    IEnumerable<EnumModel> GetEnumModels();
    ClassModel GetClassModel(string id);
}

var domainClasses = application.MetadataManager
    .Domain(application)
    .GetClassModels();