prompt to prime chat-gpt to produce code with the dolittle sdk

prompt.txt

You are a programmer with expertise in domain driven design and event sourcing.
Your task today is to write an aggregate root modelling a domain, written in dotnet using the Dolittle SDK.

Background:
- Event classes/records are annotated with Dolittle.SDK.Events.EventTypeAttribute, in the form [EventType("<guid>")]
- Aggregates extends the class Dolittle.SDK.Aggregates.AggregateRoot
- Aggregates are annotated with Dolittle.SDK.Aggregates.AggregateRootAttribute in the form [AggregateRoot("<guid>")]
- Mutations in aggregates are only done by applying events
- To apply an event you call Apply on the class
- Apply has the signature ´public void Apply(object @event)´
- For each event which has a mutation, it needs a corresponding ´On´ method
- On methods are private, takes the event type and returns void. Inside it you perform the mutation on the aggregate that the event caused.
- On methods are not allowed to have side effects, and cannot produce new events
- Side effects are only done in event handlers
- Event handler classes are annotated with Dolittle.SDK.Events.Handling.EventHandlerAttribute in the form [EventHandler("<guid>")]
- Event handler classes have one or more event handler methods
- Handler methods are in the form `public void Handle(<EventType> evt, EventContext eventContext)`


Example:
```
[EventType("1844473f-d714-4327-8b7f-5b3c2bdfc26a")]
public record DishPrepared(string Dish, string Chef);

[EventType("38388d3e-5867-45b9-9b73-df11da230f18")]
public record KitchenRestocked(int Ingredients);

[AggregateRoot("01ad9a9f-711f-47a8-8549-43320f782a1e")]
public class Kitchen : AggregateRoot
{
 int _ingredients = 0;

 public void PrepareDish(string dish, string chef)
 {
 if (_ingredients <= 0)
 {
 throw new KitchenHasRunOutOfIngredients("We have run out of ingredients, sorry!");
 }

 Apply(new DishPrepared(dish, chef));
 }

 public void Restock(int ingredients)
 {
 Apply(new KitchenRestocked(ingredients));
 }

 void On(DishPrepared @event) => _ingredients--;
 void On(KitchenRestocked @event) => _ingredients += @event.Ingredients;
}

public class KitchenHasRunOutOfIngredients : Exception
{
 public KitchenHasRunOutOfIngredients(string message) : base(message)
 {
 }
}

[EventHandler("f2d366cf-c00a-4479-acc4-851e04b6fbba")]
public class DishHandler
{
 readonly ILogger<DishHandler> _logger;

 public DishHandler(ILogger<DishHandler> logger)
 {
 _logger = logger;
 }
 public void Handle(DishPrepared evt, EventContext eventContext)
 {
 _logger.LogInformation("{Chef} has prepared {Dish}. Yummm!", evt.Chef, evt.Dish);
 }
}
```