public class FrameworkModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.AddWorkflow();

        base.Load(builder);
    }
}

[ServiceProvider]
[Import(typeof(IWorkflowModule))]
[Transient(typeof(IWorkflowTestStep<WorkflowTestContext>), typeof(WorkflowTestStep<WorkflowTestContext>))]
public partial class CustomServiceProvider
{
}

private async Task<ITypeCodeStrategy?> EvaluateModeAsync()
{
    var workflow = _workflowBuilder
        .Then(context => context.Modes, _ => _modeComposer.ComposeOrdered())
        .WriteLine(context => CreateInputMessage(context.Modes))
        .ReadLine(context => context.Input)
        .While(context => !ModeExists(context.Modes, context), whileFlow => whileFlow
            .WriteLine(_ => $@"{Cuts.Point()} Please select a valid mode")
            .ReadLine(context => context.Input)
            .ThenAsync<IExitOrContinueStep<TypeCodeContext>>()
        )
        .Then(context => context.Mode, context => context.Modes
            .SingleOrDefault(strategy => strategy
                .IsResponsibleFor(context.Input)))
        .Build();

    var workflowContext = await workflow.RunAsync(new TypeCodeContext()).ConfigureAwait(false);
    return workflowContext.Mode;
}

var workflow = _workflowEvaluationBuilder
    .ThenAsync<ISelectionStep<UnitTestDependencyEvaluationContext, SelectionStepOptions>,
        SelectionStepOptions>(config =>
        {
            config.Selections = new List<string>
            {
                "Input type by name",
                "Input dependencies manually (,)"
            };
        }
    )

internal class SelectionStep<TContext, TOptions> :
    ISelectionStep<TContext, TOptions>
    where TContext : WorkflowBaseContext, ISelectionContext
{
    private readonly IWorkflowBuilder<SelectionContext> _workflowBuilder;
    private SelectionStepOptions _options;

    public SelectionStep(IWorkflowBuilder<SelectionContext> workflowBuilder)
    {
        _workflowBuilder = workflowBuilder;

        _options = new SelectionStepOptions();
    }

    public async Task ExecuteAsync(TContext context)
    {
        var selectionContext = new SelectionContext();
        context.MapTo(selectionContext);

        var workflow = _workflowBuilder
            .While(c => string.IsNullOrEmpty(c.Input) || c.Selection == 0 || c.Selection > _options.Selections.Count, whileFlow => whileFlow
                .WriteLine(_ => $@"{Cuts.Medium()}")
                .WriteLine(_ => $@"{Cuts.Heading()} Select an option")
                .WriteLine(_ => CreateSelectionMenu(_options.Selections))
                .ReadLine(c => c.Input)
                .ThenAsync<IExitOrContinueStep<SelectionContext>>()
                .IfFlow(c => short.TryParse(c.Input?.Trim(), out _), ifFlow => ifFlow
                    .Then(c => c.Selection, c => Convert.ToInt16(c.Input?.Trim()))
                    .If(c => c.Selection > _options.Selections.Count || c.Selection < 1, _ => System.Console.WriteLine($@"{Cuts.Point()} Option is not valid"))
                )
            )
            .Build();

        var workflowContext = await workflow.RunAsync(selectionContext).ConfigureAwait(false);
        workflowContext.MapTo(context);
        context.Selection = workflowContext.Selection;
    }

    private static string CreateSelectionMenu(IReadOnlyList<string> selections)
    {
        var stringBuilder = new StringBuilder();
        stringBuilder.AppendLine($@"{Cuts.Medium()}");
        for (var index = 0; index < selections.Count; index++)
        {
            stringBuilder.AppendLine($@"{Cuts.Point()} {index + 1} - {selections[index]}");
        }

        stringBuilder.Append($@"{Cuts.Medium()}");
        return stringBuilder.ToString();
    }

    public Task<bool> ShouldExecuteAsync(TContext context)
    {
        return context.ShouldExecuteAsync();
    }

    public void SetOptions(TOptions options)
    {
        _options = options as SelectionStepOptions ?? new SelectionStepOptions();
    }
}