Type Resolution

public CSharpTypeResolver(
    CSharpCollectionFormatter defaultCollectionFormatter,
    INullableFormatter defaultNullableFormatter,
    ISoftwareFactoryExecutionContext executionContext)

public class MyTemplate : CSharpTemplateBase<ClassModel>
{
    public MyTemplate(IOutputTarget outputTarget, ClassModel model)
        : base("Template.Id", outputTarget, model)
    {
    }

    public string GetPropertyType(AttributeModel attribute)
    {
        // Resolve type reference to C# type name
        return GetTypeName(attribute.TypeReference);
    }

    public override string RunTemplate()
    {
        foreach (var attribute in Model.Attributes)
        {
            var typeName = GetTypeName(attribute.TypeReference);
            // Use typeName in code generation
        }

        return TransformText();
    }
}

// Metadata type -> C# type
bool -> bool
int -> int
long -> long
decimal -> decimal
string -> string
guid -> Guid (System.Guid)
datetime -> DateTime (System.DateTime)
datetimeoffset -> DateTimeOffset (System.DateTimeOffset)
date -> DateOnly (System.DateOnly)
binary -> byte[]

// Examples with List<T> collection formatter
ITypeReference with IsCollection = true -> List<T>

// Examples with IEnumerable<T> collection formatter
ITypeReference with IsCollection = true -> IEnumerable<T>

// Array types
byte[] -> byte[]
string[] -> string[]

// Value types with IsNullable = true
int? -> int?
Guid? -> Guid?

// Reference types (C# 8.0+ nullable reference types)
string (IsNullable = true) -> string?
MyClass (IsNullable = true) -> MyClass?

// Single type parameter
Task<string> -> Task<string>

// Multiple type parameters
Dictionary<string, int> -> Dictionary<string, int>

// Nested generics
Task<List<string>> -> Task<List<string>>

// Generic with nullable
Task<MyClass?> -> Task<MyClass?>

// Create collection formatters
var listFormatter = CSharpCollectionFormatter.Create("List<{0}>");
var enumerableFormatter = CSharpCollectionFormatter.Create("IEnumerable<{0}>");
var arrayFormatter = CSharpCollectionFormatter.Create("{0}[]");

// Use in resolver
var resolver = new CSharpTypeResolver(
    defaultCollectionFormatter: listFormatter,
    defaultNullableFormatter: nullableFormatter,
    executionContext: ExecutionContext);

// In your designer, apply C# stereotype to a type:
// Stereotype: C#
//   Type: "System.Uri"
//   Namespace: "System"
//   Is Primitive: false
//   Is Collection: false

// The resolver will use these stereotype properties:
var typeReference = element.TypeReference;
var resolvedType = GetTypeName(typeReference);
// Result: "Uri" with namespace "System"

public class MyTemplate : CSharpTemplateBase<ClassModel>
{
    public MyTemplate(IOutputTarget outputTarget, ClassModel model)
        : base("Template.Id", outputTarget, model)
    {
        // Register type source for resolving to other templates
        AddTypeSource("Other.Template.Id");
        AddTypeSource("Another.Template.Id", "List<{0}>");
    }

    public string GetDependentType(ITypeReference typeReference)
    {
        // Will resolve to types from registered type sources
        return GetTypeName(typeReference);
    }
}

// Override collection format for specific type reference
var typeName = GetTypeName(
    attribute.TypeReference,
    collectionFormat: "IReadOnlyList<{0}>");

// Resolve generic type with parameters
public string GetGenericType(ITypeReference typeReference)
{
    if (typeReference.GenericTypeParameters.Any())
    {
        var baseType = typeReference.Element.Name;
        var typeArgs = typeReference.GenericTypeParameters
            .Select(x => GetTypeName(x))
            .ToList();

        return $"{baseType}<{string.Join(", ", typeArgs)}>";
    }

    return GetTypeName(typeReference);
}

public abstract class CSharpTemplateBase<TModel> : IntentTemplateBase<TModel>
{
    protected CSharpTemplateBase(
        string templateId,
        IOutputTarget outputTarget,
        TModel model)
        : base(templateId, outputTarget, model)
    {
        var collectionFormatter = CSharpCollectionFormatter.Create(
            GetCollectionFormat());

        var nullableFormatter = new CSharpNullableFormatter(
            IsNullableAwareContext());

        // Type resolver is available through GetTypeName methods
    }

    protected virtual string GetCollectionFormat()
    {
        return "List<{0}>"; // Default collection format
    }

    protected virtual bool IsNullableAwareContext()
    {
        return true; // Enable nullable reference types
    }
}

// Parse C# type string
if (CSharpTypeParser.TryParse("List<string>", out var parsedType))
{
    // parsedType is a CSharpType representing the parsed structure
}

// Supported formats:
// - Simple types: "string", "int"
// - Generic types: "List<string>", "Dictionary<string, int>"
// - Nullable types: "int?", "string?"
// - Array types: "byte[]", "string[]"
// - Nested generics: "Task<List<string>>"

foreach (var attribute in Model.Attributes)
{
    var typeName = GetTypeName(attribute.TypeReference);
    var propertyName = attribute.Name.ToPascalCase();

    WriteLine($"public {typeName} {propertyName} {{ get; set; }}");
}

public string GenerateMethod(OperationModel operation)
{
    var returnType = GetTypeName(operation.TypeReference);
    var parameters = operation.Parameters
        .Select(p => $"{GetTypeName(p.TypeReference)} {p.Name.ToCamelCase()}")
        .ToList();

    return $"public {returnType} {operation.Name}({string.Join(", ", parameters)})";
}