Restructured the project structure back to the way it was, there's no reasonable way to split the modules

src/NadekoBot/_common/Interaction/INadekoInteractionService.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot;
+
+public interface INadekoInteractionService
+{
+    public NadekoInteraction Create<T>(
+        ulong userId,
+        SimpleInteraction<T> inter);
+}

src/NadekoBot/_common/Interaction/NadekoInteraction.cs

@@ -0,0 +1,82 @@
+namespace NadekoBot;
+
+public sealed class NadekoInteraction
+{
+    private readonly ulong _authorId;
+    private readonly ButtonBuilder _button;
+    private readonly Func<SocketMessageComponent, Task> _onClick;
+    private readonly bool _onlyAuthor;
+    public DiscordSocketClient Client { get; }
+
+    private readonly TaskCompletionSource<bool> _interactionCompletedSource;
+
+    private IUserMessage message = null!;
+
+    public NadekoInteraction(DiscordSocketClient client,
+        ulong authorId,
+        ButtonBuilder button,
+        Func<SocketMessageComponent, Task> onClick,
+        bool onlyAuthor)
+    {
+        _authorId = authorId;
+        _button = button;
+        _onClick = onClick;
+        _onlyAuthor = onlyAuthor;
+        _interactionCompletedSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        
+        Client = client;
+    }
+
+    public async Task RunAsync(IUserMessage msg)
+    {
+        message = msg;
+
+        Client.InteractionCreated += OnInteraction;
+        await Task.WhenAny(Task.Delay(15_000), _interactionCompletedSource.Task);
+        Client.InteractionCreated -= OnInteraction;
+
+        await msg.ModifyAsync(m => m.Components = new ComponentBuilder().Build());
+    }
+    
+    private Task OnInteraction(SocketInteraction arg)
+    {
+        if (arg is not SocketMessageComponent smc)
+            return Task.CompletedTask;
+
+        if (smc.Message.Id != message.Id)
+            return Task.CompletedTask;
+
+        if (_onlyAuthor && smc.User.Id != _authorId)
+            return Task.CompletedTask;
+
+        if (smc.Data.CustomId != _button.CustomId)
+            return Task.CompletedTask;
+
+        _ = Task.Run(async () =>
+        {
+            await ExecuteOnActionAsync(smc);
+            
+            // this should only be a thing on single-response buttons
+            _interactionCompletedSource.TrySetResult(true);
+
+            if (!smc.HasResponded)
+            {
+                await smc.DeferAsync();
+            }
+        });
+        
+        return Task.CompletedTask;
+    }
+
+
+    public MessageComponent CreateComponent()
+    {
+        var comp = new ComponentBuilder()
+            .WithButton(_button);
+
+        return comp.Build();
+    }
+
+    public Task ExecuteOnActionAsync(SocketMessageComponent smc)
+        => _onClick(smc);
+}

src/NadekoBot/_common/Interaction/NadekoInteractionData.cs

@@ -0,0 +1,8 @@
+namespace NadekoBot;
+
+/// <summary>
+/// Represents essential interacation data
+/// </summary>
+/// <param name="Emote">Emote which will show on a button</param>
+/// <param name="CustomId">Custom interaction id</param>
+public record NadekoInteractionData(IEmote Emote, string CustomId, string? Text = null);

src/NadekoBot/_common/Interaction/NadekoInteractionService.cs

@@ -0,0 +1,20 @@
+namespace NadekoBot;
+
+public class NadekoInteractionService : INadekoInteractionService, INService
+{
+    private readonly DiscordSocketClient _client;
+
+    public NadekoInteractionService(DiscordSocketClient client)
+    {
+        _client = client;
+    }
+
+    public NadekoInteraction Create<T>(
+        ulong userId,
+        SimpleInteraction<T> inter)
+        => new NadekoInteraction(_client,
+            userId,
+            inter.Button,
+            inter.TriggerAsync,
+            onlyAuthor: true);
+}

src/NadekoBot/_common/Interaction/SimpleInteraction.cs

@@ -0,0 +1,20 @@
+namespace NadekoBot;
+
+public class SimpleInteraction<T>
+{
+    public ButtonBuilder Button { get; }
+    private readonly Func<SocketMessageComponent, T, Task> _onClick;
+    private readonly T? _state;
+
+    public SimpleInteraction(ButtonBuilder button, Func<SocketMessageComponent, T?, Task> onClick, T? state = default)
+    {
+        Button = button;
+        _onClick = onClick;
+        _state = state;
+    }
+
+    public async Task TriggerAsync(SocketMessageComponent smc)
+    {
+        await _onClick(smc, _state!);
+    }
+}