* Added building delegate to UseTelegrator method

* Fixed Webhooker trying to resolve IEndpointRouteBuildr from DI

.gitignore

@@ -361,8 +361,5 @@ MigrationBackup/
 
 # Fody - auto-generated XML schema
 FodyWeavers.xsd
-/GETTING_STARTED.md
+
-/ANNOTATION_OVERVIEW.md
+.aider*
-/.aider.input.history
-/.aider.chat.history.md
-/.aider.tags.cache.v4

README.md

@@ -1,14 +1,10 @@
-# Telegrator
-
 ![Telegrator Banner](https://github.com/Rikitav/Telegrator/blob/master/resources%2FTelegrator_banner.png)
 
-> **A modern reactive framework for Telegram bots in C# with aspect-oriented design, mediator-based dispatching, and flexible architecture.**
-
 ---
 
 ## 🚀 About Telegrator
 
-Telegrator is a next-generation framework for building Telegram bots in C#, inspired by AOP (Aspect-Oriented Programming) and the mediator pattern. It enables decentralized, easily extensible, and maintainable bot logic without traditional state machines or monolithic handlers.
+Telegrator is a modern C# framework for building Telegram bots, inspired by AOP (Aspect-Oriented Programming) and the mediator pattern. It enables decentralized, easily extensible, and maintainable bot logic without traditional state machines or monolithic handlers.
 
 ---
 
@@ -95,13 +91,12 @@ bot.Handlers.AddHandler<StartCommandHandler>();
 using Telegrator.Handlers;
 using Telegrator.Annotations;
 
-[CommandHandler, CommandAlias("first"), NumericState(SpecialState.NoState)]
+[CommandHandler, CommandAlias("first"), State<SetupWizard>(null)]
 public class StateKeepFirst : CommandHandler
 {
     public override async Task<Result> Execute(IHandlerContainer<Message> container, CancellationToken cancellation)
     {
-        container.CreateNumericState();
+        StateStorage.GetStateMachine<SetupWizard>().BysenderId().Advance();
-        container.ForwardNumericState();
         await Reply("first state moved (1)", cancellationToken: cancellation);
         return Result.Ok();
     }

Telegrator.slnx

@@ -1,5 +1,6 @@
 <Solution>
   <Project Path="dev/Telegrator.RoslynGenerators/Telegrator.RoslynGenerators.csproj" />
+  <Project Path="src/Telegartor.RedisStateStorage/Telegartor.RedisStateStorage.csproj" />
   <Project Path="src/Telegrator.Analyzers/Telegrator.Analyzers.csproj" />
   <Project Path="src/Telegrator.Hosting.Web/Telegrator.Hosting.Web.csproj" />
   <Project Path="src/Telegrator.Hosting/Telegrator.Hosting.csproj" />

dev/Telegrator.RoslynGenerators/ImplicitHandlerBuilderExtensionsGenerator.cs

@@ -5,10 +5,6 @@ using System.Collections.Immutable;
 using System.Text;
 using Telegrator.RoslynGenerators.RoslynExtensions;
 
-#if DEBUG
-using System.Diagnostics;
-#endif
-
 namespace Telegrator.RoslynGenerators;
 
 [Generator(LanguageNames.CSharp)]
@@ -72,6 +68,9 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
                 if (className == "FilterAnnotation")
                     continue;
 
+                if (className == "StateAttribute")
+                    continue;
+
                 MethodDeclarationSyntax? targeter = classDeclaration.Members.OfType<MethodDeclarationSyntax>().SingleOrDefault(IsTargeterMethod);
                 if (targeter != null)
                 {
@@ -101,7 +100,13 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
                 continue;
 
             usings.UnionAdd(classDeclaration.FindAncestor<CompilationUnitSyntax>().Usings, UsingEqualityComparer);
-            MethodDeclarationSyntax targeter = FindTargetterMethod(targetters, classDeclaration);
+            MethodDeclarationSyntax? targeter = FindTargetterMethod(targetters, classDeclaration);
+
+            if (targeter == null)
+            {
+                debugExport.AppendLine("Targetter not found");
+                continue;
+            }
 
             if (classDeclaration.ParameterList != null && classDeclaration.BaseList != null)
             {
@@ -140,16 +145,16 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
         {
             ClassDeclarationSyntax extensionsClass = SyntaxFactory.ClassDeclaration("HandlerBuilderExtensions")
                 .WithModifiers(Modifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword, SyntaxKind.PartialKeyword))
-                .AddMembers([.. targetters.Values, .. extensions])
+                .AddMembers([.. targetters.Values, .. extensions]);
-                .DecorateType(1);
 
             NamespaceDeclarationSyntax namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName("Telegrator"))
-                .WithMembers([extensionsClass])
+                .WithLeadingTrivia(SyntaxFactory.ParseLeadingTrivia("#pragma warning disable CS1591"))
-                .Decorate();
+                .WithMembers([extensionsClass]);
 
             CompilationUnitSyntax compilationUnit = SyntaxFactory.CompilationUnit()
                 .WithUsings([.. usings])
-                .WithMembers([namespaceDeclaration]);
+                .WithMembers([namespaceDeclaration])
+                .NormalizeWhitespace();
 
             context.AddSource("GeneratedHandlerBuilderExtensions.cs", compilationUnit.ToFullString());
         }
@@ -175,7 +180,7 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
         if (targetterMethod.ExpressionBody != null)
             method = method.WithExpressionBody(targetterMethod.ExpressionBody).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
 
-        return method.DecorateMember(2);
+        return method;
     }
 
     private static MethodDeclarationSyntax GeneratedExtensionsMethod(ClassDeclarationSyntax classDeclaration, ParameterListSyntax methodParameters, ArgumentListSyntax invokerArguments, MethodDeclarationSyntax targetterMethod)
@@ -204,11 +209,10 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
 
         MethodDeclarationSyntax method = SyntaxFactory.MethodDeclaration(returnType, identifier)
             .WithParameterList(parameters)
-            .WithBody(body.DecorateBlock(2))
+            .WithBody(body)
             .WithTypeParameterList(typeParameters)
             .WithModifiers(Modifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword))
             .WithConstraintClauses([typeParameterConstraint])
-            .DecorateMember(2)
             .WithLeadingTrivia(xmlDoc);
          
         return method;
@@ -230,7 +234,7 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
     private static IEnumerable<ConstructorDeclarationSyntax> GetConstructors(ClassDeclarationSyntax classDeclaration)
         => classDeclaration.Members.OfType<ConstructorDeclarationSyntax>().Where(ctor => ctor.Modifiers.HasModifiers("public"));
 
-    private static MethodDeclarationSyntax FindTargetterMethod(Dictionary<string, MethodDeclarationSyntax> targeters, ClassDeclarationSyntax classDeclaration)
+    private static MethodDeclarationSyntax? FindTargetterMethod(Dictionary<string, MethodDeclarationSyntax> targeters, ClassDeclarationSyntax classDeclaration)
     {
         if (targeters.TryGetValue(classDeclaration.Identifier.ValueText, out MethodDeclarationSyntax targeter))
             return targeter;
@@ -238,7 +242,7 @@ public class ImplicitHandlerBuilderExtensionsGenerator : IIncrementalGenerator
         if (classDeclaration.BaseList != null && targeters.TryGetValue(classDeclaration.BaseList.Types.ElementAt(0).Type.ToString(), out targeter))
             return targeter;
 
-        throw new TargteterNotFoundException();
+        return null;
     }
 
     private static SyntaxTriviaList BuildExtensionXmlDocTrivia(ClassDeclarationSyntax classDeclaration, ParameterListSyntax methodParameters)

dev/Telegrator.RoslynGenerators/RoslynExtensions/MemberDeclarationSyntaxExtensions.cs

@@ -1,38 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace Telegrator.RoslynGenerators.RoslynExtensions
-{
-    public static class MemberDeclarationSyntaxExtensions
-    {
-        private static SyntaxTrivia TabulationTrivia => SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, "\t");
-        private static SyntaxTrivia WhitespaceTrivia => SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " ");
-        private static SyntaxTrivia NewLineTrivia => SyntaxFactory.SyntaxTrivia(SyntaxKind.EndOfLineTrivia, "\n");
-
-        public static SyntaxTokenList Decorate(this SyntaxTokenList tokens)
-            => new SyntaxTokenList(tokens.Select(token => token.WithoutTrivia().WithTrailingTrivia(WhitespaceTrivia)).ToArray());
-
-        public static BlockSyntax DecorateBlock(this BlockSyntax block, int times) => block
-            .WithStatements([.. block.Statements.Select(statement => statement.DecorateStatememnt(times + 1))])
-            .WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithLeadingTrivia(WhitespaceTrivia).WithTrailingTrivia(NewLineTrivia))
-            .WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithLeadingTrivia(TabulationTrivia.Repeat(times)).WithTrailingTrivia(NewLineTrivia));
-
-        public static T DecorateStatememnt<T>(this T statememnt, int times) where T : StatementSyntax => statememnt
-            .WithoutTrivia().WithLeadingTrivia(TabulationTrivia.Repeat(times)).WithTrailingTrivia(NewLineTrivia);
-
-        public static T DecorateMember<T>(this T typeDeclaration, int times) where T : MemberDeclarationSyntax => typeDeclaration
-            .WithoutTrivia().WithLeadingTrivia(TabulationTrivia.Repeat(times)).WithTrailingTrivia(NewLineTrivia);
-
-        public static NamespaceDeclarationSyntax Decorate(this NamespaceDeclarationSyntax namespaceDeclaration) => namespaceDeclaration
-            .WithName(namespaceDeclaration.Name.WithoutTrivia().WithLeadingTrivia(WhitespaceTrivia))
-            .WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithLeadingTrivia(NewLineTrivia).WithTrailingTrivia(NewLineTrivia))
-            .WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
-
-        public static T DecorateType<T>(this T typeDeclaration, int times = 1) where T : TypeDeclarationSyntax => (T)typeDeclaration
-            .WithoutTrivia().WithLeadingTrivia(TabulationTrivia.Repeat(times))
-            .WithIdentifier(typeDeclaration.Identifier.WithoutTrivia().WithLeadingTrivia(WhitespaceTrivia).WithTrailingTrivia(NewLineTrivia))
-            .WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithLeadingTrivia(TabulationTrivia.Repeat(times)).WithTrailingTrivia(NewLineTrivia))
-            .WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithLeadingTrivia(TabulationTrivia.Repeat(times)).WithTrailingTrivia(NewLineTrivia));
-    }
-}

docs/GETTING_STARTED.md

@@ -47,7 +47,7 @@ This guide will walk you through the core concepts and advanced features of **Te
 **Telegrator** is distributed as a NuGet package. You can install it using the .NET CLI, the NuGet Package Manager Console, or by managing NuGet packages in Visual Studio.
 
 ### Prerequisites
-- .NET >= 5.0 `or` .NET Core >= 2.0 `or` Framework >= 4.6.1 (.NET Standard 2.0 compatible)
+- .NET >= 5.0 `or` .NET Core >= 2.0 `or` Framework >= 4.6.1 (.NET Standard 2.1 compatible)
 - A Telegram Bot Token from [@BotFather](https://t.me/BotFather).
 
 ### .NET CLI
@@ -61,7 +61,7 @@ Install-Package Telegrator
 ```
 
 ### Hosting Integrations
-- .NET Core >= 8.0 
+- .NET Core >= 10.0 
 - `Telegrator.Hosting`: For console/background services
 - `Telegrator.Hosting.Web`: For ASP.NET Core/Webhook
 
@@ -325,7 +325,7 @@ builder.Handlers.AddMethod<CallbackQuery>(Option1Handler);
 ```csharp
 public enum UserState
 {
-    Start = SpecialState.NoState,
+    Start,
     WaitingForName,
     WaitingForAge
 }
@@ -333,39 +333,40 @@ public enum UserState
 // Start conversation
 [CommandHandler]
 [CommandAlias("register")]
-[EnumState<UserState>(UserState.Start)]
+[State<UserState>(UserState.Start)]
 private static async Task<Result> StartRegistration(IHandlerContainer<Message> container, CancellationToken cancellationToken)
 {
-    container.ForwardEnumState<UserState>();
+    StateStorage.GetStateMachine<UserState>().BySenderId().Advance();
     await container.Reply("Please enter your name:", cancellationToken: cancellationToken);
     return Ok;
 }
 
 // Handle name input
 [MessageHandler]
-[EnumState<UserState>(UserState.WaitingForName)]
+[State<UserState>(UserState.WaitingForName)]
 private static async Task<Result> HandleName(IHandlerContainer<Message> container, CancellationToken cancellationToken)
 {
     var name = container.Input.Text;
-    container.ForwardEnumState<UserState>();
+    StateStorage.GetStateMachine<UserState>().BySenderId().Advance();
     await container.Reply($"Hello {name}! Please enter your age:", cancellationToken: cancellationToken);
     return Ok;
 }
 
 // Handle age input
 [MessageHandler]
-[EnumState<UserState>(UserState.WaitingForAge)]
+[State<UserState>(UserState.WaitingForAge)]
 private static async Task<Result> HandleAge(IHandlerContainer<Message> container, CancellationToken cancellationToken)
 {
     if (int.TryParse(container.Input.Text, out int age))
     {
-        container.DeleteEnumState<UserState>();
+        StateStorage.GetStateMachine<UserState>().BySenderId().Reset();
         await container.Reply($"Registration complete! Name: {name}, Age: {age}", cancellationToken: cancellationToken);
     }
     else
     {
         await container.Reply("Please enter a valid age (number):", cancellationToken: cancellationToken);
     }
+
     return Ok;
 }
 
@@ -497,50 +498,43 @@ public class RestrictedHandler : MessageHandler
 
 ### 3.3. State Management
 
-Telegrator provides built-in state management for multi-step conversations (wizards, forms, quizzes) without a database.
+Telegrator provides built-in state management for multi-step conversations (wizards, forms, quizzes) with or without a database.
 
 > [!NOTE]
-> Each type of `StateKeeper`'s (EnumStateKeeper, NumericStateKeeper) is shared between **EVERY** handler in project.
+> Each type of `StateKeeper`'s keys and states are shared between **EVERY** handler in project.
-
-**Types of State:**
-- **NumericState**: Integer-based steps
-- **StringState**: Named steps
-- **EnumState**: Enum-based scenarios
 
 **How to Use:**
 1. Define your state (enum/int/string)
 2. Use a state filter attribute on your handler:
-   - `[EnumState<MyEnum>(MyEnum.Step1)]`
+   - `[State<MyEnum>(MyEnum.Step1)]`
-   - `[NumericState(1)]`
-   - `[StringState("waiting_input")]`
 3. Change state inside the handler using extension methods:
-   - `container.ForwardEnumState<MyEnum>()`
+   - `StateStorage.GetStateMachine<MyEnum>().BySenderId().Current()`
-   - `container.ForwardNumericState()`
+   - `StateStorage.GetStateMachine<MyEnum>().BySenderId().Advance()`
-   - `container.ForwardStringState()`
+   - `StateStorage.GetStateMachine<MyEnum>().BySenderId().Retreat()`
-   - `container.DeleteEnumState<MyEnum>()`
+   - `StateStorage.GetStateMachine<MyEnum>().BySenderId().Reset()`
 
 **Example:**
 ```csharp
 public enum QuizState
 {
-    Start = SpecialState.NoState, Q1, Q2
+    Start, Q1, Q2
 }
 
 [CommandHandler]
 [CommandAlias("quiz")]
-[EnumState<QuizState>(QuizState.Start)]
+[State<QuizState>(QuizState.Start)]
 public class StartQuizHandler : CommandHandler
 {
     public override async Task<Result> Execute(IHandlerContainer<Message> container, CancellationToken cancellation)
     {
-        container.ForwardEnumState<QuizState>();
+        StateStorage.GetStateMachine<QuizState>().BySenderId().Advance();
         await Reply("Quiz started! Question 1: What is the capital of France?");
         return Ok;
     }
 }
 
 [MessageHandler]
-[EnumState<QuizState>(QuizState.Q1)]
+[State<QuizState>(QuizState.Q1)]
 public class Q1Handler : MessageHandler
 {
     public override async Task<Result> Execute(IHandlerContainer<Message> container, CancellationToken cancellation)
@@ -550,7 +544,7 @@ public class Q1Handler : MessageHandler
         else
             await Reply("Incorrect. The answer is Paris.");
 
-        container.ForwardEnumState<QuizState>();
+        StateStorage.GetStateMachine<QuizState>().BySenderId().Advance();
         await Reply("Question 2: What is 2 + 2?");
         return Ok;
     }
@@ -559,8 +553,8 @@ public class Q1Handler : MessageHandler
 
 > **How is it working?**
 > 1. **Enum State Definition**: `QuizState` enum defines the conversation flow with `Start = SpecialState.NoState` indicating no initial state.
-> 2. **State Filter**: `[EnumState<QuizState>(QuizState.Start)]` ensures the handler only runs when the user is in the "Start" state.
+> 2. **State Filter**: `[State<QuizState>(QuizState.Start)]` ensures the handler only runs when the user is in the "Start" state.
-> 3. **State Transition**: `container.ForwardEnumState<QuizState>()` moves the user to the next state (Q1).
+> 3. **State Transition**: `StateStorage.GetStateMachine<QuizState>().BySenderId().Advance()` moves the user to the next state (Q1).
 > 4. **Next Handler**: The `Q1Handler` will only run when the user is in state `QuizState.Q1`.
 > 5. **State Management**: Each handler manages its own state transition, creating a clear conversation flow.
 
@@ -1425,28 +1419,28 @@ public enum UserState
 // Start conversation
 [CommandHandler]
 [CommandAlias("register")]
-[EnumState<UserState>(UserState.Start)]
+[State<UserState>(UserState.Start)]
 private static async Task<Result> StartRegistration(IHandlerContainer<Message> container, CancellationToken cancellationToken)
 {
-    container.ForwardEnumState<UserState>();
+    StateStorage.GetStateMachine<UserState>().BySenderId().Advance();
     await container.Reply("Please enter your name:", cancellationToken: cancellationToken);
     return Ok;
 }
 
 // Handle name input
 [MessageHandler]
-[EnumState<UserState>(UserState.WaitingForName)]
+[State<UserState>(UserState.WaitingForName)]
 private static async Task<Result> HandleName(IHandlerContainer<Message> container, CancellationToken cancellationToken)
 {
     var name = container.Input.Text;
-    container.ForwardEnumState<UserState>();
+    StateStorage.GetStateMachine<UserState>().BySenderId().Advance();
     await container.Reply($"Hello {name}! Please enter your age:", cancellationToken: cancellationToken);
     return Ok;
 }
 
 // Handle age input
 [MessageHandler]
-[EnumState<UserState>(UserState.WaitingForAge)]
+[State<UserState>(UserState.WaitingForAge)]
 private static async Task<Result> HandleAge(IHandlerContainer<Message> container, CancellationToken cancellationToken)
 {
     if (int.TryParse(container.Input.Text, out int age))

docs/Telegartor.RedisStateStorage.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>Telegartor.RedisStateStorage</name>
+    </assembly>
+    <members>
+        <member name="T:Telegrator.States.RedisStateStorage">
+            <summary>
+            Provides a Redis-based implementation of the <see cref="T:Telegrator.Core.States.IStateStorage"/> interface.
+            Serializes state objects to JSON format before storing them in the Redis database.
+            </summary>
+        </member>
+        <member name="M:Telegrator.States.RedisStateStorage.#ctor(StackExchange.Redis.IConnectionMultiplexer)">
+            <summary>
+            Provides a Redis-based implementation of the <see cref="T:Telegrator.Core.States.IStateStorage"/> interface.
+            Serializes state objects to JSON format before storing them in the Redis database.
+            </summary>
+        </member>
+        <member name="M:Telegrator.States.RedisStateStorage.SetAsync``1(System.String,``0,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Telegrator.States.RedisStateStorage.GetAsync``1(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+        <member name="M:Telegrator.States.RedisStateStorage.DeleteAsync(System.String,System.Threading.CancellationToken)">
+            <inheritdoc/>
+        </member>
+    </members>
+</doc>

docs/Telegrator.Hosting.Web.xml

@@ -28,6 +28,9 @@
             This application's logger
             </summary>
         </member>
+        <member name="P:Telegrator.Hosting.Web.TelegramBotWebHost.Properties">
+            <inheritdoc/>
+        </member>
         <member name="M:Telegrator.Hosting.Web.TelegramBotWebHost.#ctor(Microsoft.AspNetCore.Builder.WebApplicationBuilder)">
             <summary>
             Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.Builder.WebApplicationBuilder"/> class.
@@ -100,6 +103,12 @@
         <member name="P:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.Environment">
             <inheritdoc/>
         </member>
+        <member name="P:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.Properties">
+            <inheritdoc/>
+        </member>
+        <member name="P:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.Metrics">
+            <inheritdoc/>
+        </member>
         <member name="M:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.#ctor(Microsoft.AspNetCore.Builder.WebApplicationBuilder,Microsoft.AspNetCore.Builder.WebApplicationOptions)">
             <summary>
             Initializes a new instance of the <see cref="T:Telegrator.Hosting.Web.TelegramBotWebHostBuilder"/> class.
@@ -107,6 +116,14 @@
             <param name="webApplicationBuilder"></param>
             <param name="settings"></param>
         </member>
+        <member name="M:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.#ctor(Microsoft.AspNetCore.Builder.WebApplicationBuilder,Telegrator.TelegratorOptions,Microsoft.AspNetCore.Builder.WebApplicationOptions)">
+            <summary>
+            Initializes a new instance of the <see cref="T:Telegrator.Hosting.Web.TelegramBotWebHostBuilder"/> class.
+            </summary>
+            <param name="webApplicationBuilder"></param>
+            <param name="options"></param>
+            <param name="settings"></param>
+        </member>
         <member name="M:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.#ctor(Microsoft.AspNetCore.Builder.WebApplicationBuilder,Telegrator.Core.IHandlersCollection,Microsoft.AspNetCore.Builder.WebApplicationOptions)">
             <summary>
             Initializes a new instance of the <see cref="T:Telegrator.Hosting.Web.TelegramBotWebHostBuilder"/> class.
@@ -115,12 +132,24 @@
             <param name="handlers"></param>
             <param name="settings"></param>
         </member>
+        <member name="M:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.#ctor(Microsoft.AspNetCore.Builder.WebApplicationBuilder,Telegrator.Core.IHandlersCollection,Telegrator.TelegratorOptions,Microsoft.AspNetCore.Builder.WebApplicationOptions)">
+            <summary>
+            Initializes a new instance of the <see cref="T:Telegrator.Hosting.Web.TelegramBotWebHostBuilder"/> class.
+            </summary>
+            <param name="webApplicationBuilder"></param>
+            <param name="handlers"></param>
+            <param name="options"></param>
+            <param name="settings"></param>
+        </member>
         <member name="M:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.Build">
             <summary>
             Builds the host.
             </summary>
             <returns></returns>
         </member>
+        <member name="M:Telegrator.Hosting.Web.TelegramBotWebHostBuilder.ConfigureContainer``1(Microsoft.Extensions.DependencyInjection.IServiceProviderFactory{``0},System.Action{``0})">
+            <inheritdoc/>
+        </member>
         <member name="T:Telegrator.Hosting.Web.WebhookerOptions">
             <summary>
             Configuration options for Telegram bot behavior and execution settings.
@@ -155,7 +184,7 @@
             Service for receiving updates for Hosted telegram bots via Webhooks
             </summary>
         </member>
-        <member name="M:Telegrator.Mediation.HostedUpdateWebhooker.#ctor(Microsoft.AspNetCore.Routing.IEndpointRouteBuilder,Telegram.Bot.ITelegramBotClient,Telegrator.Core.IUpdateRouter,Microsoft.Extensions.Options.IOptions{Telegrator.Hosting.Web.WebhookerOptions})">
+        <member name="M:Telegrator.Mediation.HostedUpdateWebhooker.#ctor(Telegram.Bot.ITelegramBotClient,Telegrator.Core.IUpdateRouter,Microsoft.Extensions.Options.IOptions{Telegrator.Hosting.Web.WebhookerOptions})">
             <summary>
             Initiallizes new instance of <see cref="T:Telegrator.Mediation.HostedUpdateWebhooker"/>
             </summary>
@@ -171,6 +200,12 @@
         <member name="M:Telegrator.Mediation.HostedUpdateWebhooker.StopAsync(System.Threading.CancellationToken)">
             <inheritdoc/>
         </member>
+        <member name="M:Telegrator.Mediation.HostedUpdateWebhooker.MapWebhook(Microsoft.AspNetCore.Routing.IEndpointRouteBuilder)">
+            <summary>
+            Maps bot webhook to application builder
+            </summary>
+            <param name="routeBuilder"></param>
+        </member>
         <member name="T:Telegrator.ServicesCollectionExtensions">
             <summary>
             Contains extensions for <see cref="T:Microsoft.Extensions.DependencyInjection.IServiceCollection"/>
@@ -185,12 +220,22 @@
         <member name="M:Telegrator.ServicesCollectionExtensions.get_Handlers(Microsoft.AspNetCore.Builder.WebApplicationBuilder)">
             <inheritdoc cref="P:Telegrator.ServicesCollectionExtensions.&lt;G&gt;$41F16C2D39AF52899E745C9C9F42FF83.Handlers"/>
         </member>
-        <member name="M:Telegrator.ServicesCollectionExtensions.AddTelegratorWeb(Microsoft.Extensions.Hosting.IHostApplicationBuilder,Microsoft.AspNetCore.Builder.WebApplicationOptions,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection)">
+        <member name="M:Telegrator.ServicesCollectionExtensions.AddTelegratorWeb(Telegrator.Hosting.ITelegramBotHostBuilder,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection,System.Action{Telegrator.Hosting.ITelegramBotHostBuilder})">
             <summary>
             Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
             </summary>
         </member>
-        <member name="M:Telegrator.ServicesCollectionExtensions.UseTelegratorWeb(Microsoft.AspNetCore.Builder.WebApplication)">
+        <member name="M:Telegrator.ServicesCollectionExtensions.AddTelegratorWeb(Microsoft.AspNetCore.Builder.WebApplicationBuilder,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection,System.Action{Telegrator.Hosting.ITelegramBotHostBuilder})">
+            <summary>
+            Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+            </summary>
+        </member>
+        <member name="M:Telegrator.ServicesCollectionExtensions.AddTelegratorWebInternal(Microsoft.Extensions.Hosting.IHostApplicationBuilder,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection)">
+            <summary>
+            Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+            </summary>
+        </member>
+        <member name="M:Telegrator.ServicesCollectionExtensions.UseTelegratorWeb``1(``0)">
             <summary>
             Replaces the initialization logic from TelegramBotWebHost constructor. 
             Initializes the bot and logs handlers on application startup.

docs/Telegrator.Hosting.xml

@@ -13,7 +13,7 @@
             <param name="services"></param>
             <param name="configuration"></param>
         </member>
-        <member name="M:Telegrator.Hosting.HostedTelegramBotInfo.#ctor(Telegram.Bot.ITelegramBotClient,System.IServiceProvider,Microsoft.Extensions.Configuration.IConfigurationManager)">
+        <member name="M:Telegrator.Hosting.HostedTelegramBotInfo.#ctor(Telegram.Bot.ITelegramBotClient,System.IServiceProvider,Microsoft.Extensions.Configuration.IConfiguration)">
             <summary>
             Implementation of <see cref="T:Telegrator.Core.ITelegramBotInfo"/> that provides bot information.
             Contains metadata about the Telegram bot including user details and service provider for wider filterring abilities
@@ -35,27 +35,6 @@
             Provides access to configuration of this Hosted telegram bot
             </summary>
         </member>
-        <member name="T:Telegrator.Hosting.ITelegramBotHostBuilder">
-            <summary>
-            Interface for building Telegram bot hosts with dependency injection support.
-            Combines host application building capabilities with handler collection functionality.
-            </summary>
-        </member>
-        <member name="P:Telegrator.Hosting.ITelegramBotHostBuilder.Configuration">
-            <summary>
-            Gets the set of key/value configuration properties.
-            </summary>
-        </member>
-        <member name="P:Telegrator.Hosting.ITelegramBotHostBuilder.Logging">
-            <summary>
-            Gets a collection of logging providers for the application to compose. This is useful for adding new logging providers.
-            </summary>
-        </member>
-        <member name="P:Telegrator.Hosting.ITelegramBotHostBuilder.Services">
-            <summary>
-            Gets a collection of services for the application to compose. This is useful for adding user provided or framework provided services.
-            </summary>
-        </member>
         <member name="T:Telegrator.Hosting.TelegramBotHost">
             <summary>
             Represents a hosted telegram bot
@@ -133,6 +112,12 @@
         <member name="P:Telegrator.Hosting.TelegramBotHostBuilder.Environment">
             <inheritdoc/>
         </member>
+        <member name="P:Telegrator.Hosting.TelegramBotHostBuilder.Properties">
+            <inheritdoc/>
+        </member>
+        <member name="P:Telegrator.Hosting.TelegramBotHostBuilder.Metrics">
+            <inheritdoc/>
+        </member>
         <member name="M:Telegrator.Hosting.TelegramBotHostBuilder.#ctor(Microsoft.Extensions.Hosting.HostApplicationBuilder,Microsoft.Extensions.Hosting.HostApplicationBuilderSettings)">
             <summary>
             Initializes a new instance of the <see cref="T:Telegrator.Hosting.TelegramBotHostBuilder"/> class.
@@ -140,6 +125,14 @@
             <param name="hostApplicationBuilder"></param>
             <param name="settings"></param>
         </member>
+        <member name="M:Telegrator.Hosting.TelegramBotHostBuilder.#ctor(Microsoft.Extensions.Hosting.HostApplicationBuilder,Telegrator.TelegratorOptions,Microsoft.Extensions.Hosting.HostApplicationBuilderSettings)">
+            <summary>
+            Initializes a new instance of the <see cref="T:Telegrator.Hosting.TelegramBotHostBuilder"/> class.
+            </summary>
+            <param name="hostApplicationBuilder"></param>
+            <param name="options"></param>
+            <param name="settings"></param>
+        </member>
         <member name="M:Telegrator.Hosting.TelegramBotHostBuilder.#ctor(Microsoft.Extensions.Hosting.HostApplicationBuilder,Telegrator.Core.IHandlersCollection,Microsoft.Extensions.Hosting.HostApplicationBuilderSettings)">
             <summary>
             Initializes a new instance of the <see cref="T:Telegrator.Hosting.TelegramBotHostBuilder"/> class.
@@ -148,12 +141,24 @@
             <param name="handlers"></param>
             <param name="settings"></param>
         </member>
+        <member name="M:Telegrator.Hosting.TelegramBotHostBuilder.#ctor(Microsoft.Extensions.Hosting.HostApplicationBuilder,Telegrator.Core.IHandlersCollection,Telegrator.TelegratorOptions,Microsoft.Extensions.Hosting.HostApplicationBuilderSettings)">
+            <summary>
+            Initializes a new instance of the <see cref="T:Telegrator.Hosting.TelegramBotHostBuilder"/> class.
+            </summary>
+            <param name="hostApplicationBuilder"></param>
+            <param name="handlers"></param>
+            <param name="options"></param>
+            <param name="settings"></param>
+        </member>
         <member name="M:Telegrator.Hosting.TelegramBotHostBuilder.Build">
             <summary>
             Builds the host.
             </summary>
             <returns></returns>
         </member>
+        <member name="M:Telegrator.Hosting.TelegramBotHostBuilder.ConfigureContainer``1(Microsoft.Extensions.DependencyInjection.IServiceProviderFactory{``0},System.Action{``0})">
+            <inheritdoc/>
+        </member>
         <member name="T:Telegrator.Logging.MicrosoftLoggingAdapter">
             <summary>
             Adapter for Microsoft.Extensions.Logging to work with Telegrator logging system.
@@ -190,12 +195,6 @@
         <member name="M:Telegrator.Polling.HostedUpdateReceiver.ExecuteAsync(System.Threading.CancellationToken)">
             <inheritdoc/>
         </member>
-        <member name="T:Telegrator.Polling.HostUpdateHandlersPool">
-            <inheritdoc/>
-        </member>
-        <member name="M:Telegrator.Polling.HostUpdateHandlersPool.#ctor(Telegrator.Core.IUpdateRouter,Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions})">
-            <inheritdoc/>
-        </member>
         <member name="T:Telegrator.Polling.HostUpdateRouter">
             <inheritdoc/>
         </member>
@@ -204,7 +203,7 @@
             <see cref="T:Microsoft.Extensions.Logging.ILogger"/> of this router
             </summary>
         </member>
-        <member name="M:Telegrator.Polling.HostUpdateRouter.#ctor(Telegrator.Core.IHandlersProvider,Telegrator.Core.IAwaitingProvider,Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions},Telegrator.Core.IUpdateHandlersPool,Telegrator.Core.ITelegramBotInfo,Microsoft.Extensions.Logging.ILogger{Telegrator.Polling.HostUpdateRouter})">
+        <member name="M:Telegrator.Polling.HostUpdateRouter.#ctor(Telegrator.Core.IHandlersProvider,Telegrator.Core.IAwaitingProvider,Telegrator.Core.States.IStateStorage,Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions},Telegrator.Core.ITelegramBotInfo,Microsoft.Extensions.Logging.ILogger{Telegrator.Polling.HostUpdateRouter})">
             <inheritdoc/>
         </member>
         <member name="M:Telegrator.Polling.HostUpdateRouter.HandleUpdateAsync(Telegram.Bot.ITelegramBotClient,Telegram.Bot.Types.Update,System.Threading.CancellationToken)">
@@ -222,7 +221,7 @@
         <member name="T:Telegrator.Providers.HostAwaitingProvider">
             <inheritdoc/>
         </member>
-        <member name="M:Telegrator.Providers.HostAwaitingProvider.#ctor(Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions},Microsoft.Extensions.Logging.ILogger{Telegrator.Providers.HostAwaitingProvider})">
+        <member name="M:Telegrator.Providers.HostAwaitingProvider.#ctor(Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions})">
             <inheritdoc/>
         </member>
         <member name="T:Telegrator.Providers.HostHandlersCollection">
@@ -240,7 +239,7 @@
         <member name="T:Telegrator.Providers.HostHandlersProvider">
             <inheritdoc/>
         </member>
-        <member name="M:Telegrator.Providers.HostHandlersProvider.#ctor(Telegrator.Core.IHandlersCollection,Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions},System.IServiceProvider,Microsoft.Extensions.Logging.ILogger{Telegrator.Providers.HostHandlersProvider})">
+        <member name="M:Telegrator.Providers.HostHandlersProvider.#ctor(Telegrator.Core.IHandlersCollection,Microsoft.Extensions.Options.IOptions{Telegrator.TelegratorOptions},System.IServiceProvider)">
             <inheritdoc/>
         </member>
         <member name="M:Telegrator.Providers.HostHandlersProvider.GetHandlerInstance(Telegrator.Core.Descriptors.HandlerDescriptor,System.Threading.CancellationToken)">
@@ -256,15 +255,25 @@
             The key used to store the <see cref="T:Telegrator.Core.IHandlersCollection"/> in the builder properties.
             </summary>
         </member>
-        <member name="M:Telegrator.HostBuilderExtensions.get_Handlers(Microsoft.Extensions.Hosting.IHostApplicationBuilder)">
+        <member name="M:Telegrator.HostBuilderExtensions.get_Handlers(Microsoft.Extensions.Hosting.HostApplicationBuilder)">
-            <inheritdoc cref="P:Telegrator.HostBuilderExtensions.&lt;G&gt;$605D8CCF64349EA050C790D67C500BD9.Handlers"/>
+            <inheritdoc cref="P:Telegrator.HostBuilderExtensions.&lt;G&gt;$BF7227490CCA365283B3A9274C9033C7.Handlers"/>
         </member>
-        <member name="M:Telegrator.HostBuilderExtensions.AddTelegrator(Microsoft.Extensions.Hosting.IHostApplicationBuilder,Microsoft.Extensions.Hosting.HostApplicationBuilderSettings,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection)">
+        <member name="M:Telegrator.HostBuilderExtensions.AddTelegrator(Telegrator.Hosting.ITelegramBotHostBuilder,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection,System.Action{Telegrator.Hosting.ITelegramBotHostBuilder})">
             <summary>
-            Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+            Replaces TelegramBotHostBuilder. Configures DI, options, and handlers.
             </summary>
         </member>
-        <member name="P:Telegrator.HostBuilderExtensions.&lt;G&gt;$605D8CCF64349EA050C790D67C500BD9.Handlers">
+        <member name="M:Telegrator.HostBuilderExtensions.AddTelegrator(Microsoft.Extensions.Hosting.HostApplicationBuilder,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection,System.Action{Telegrator.Hosting.ITelegramBotHostBuilder})">
+            <summary>
+            Replaces TelegramBotHostBuilder. Configures DI, options, and handlers.
+            </summary>
+        </member>
+        <member name="M:Telegrator.HostBuilderExtensions.AddTelegratorInternal(Microsoft.Extensions.Hosting.IHostApplicationBuilder,Telegrator.TelegratorOptions,Telegrator.Core.IHandlersCollection)">
+            <summary>
+            Replaces TelegramBotHostBuilder. Configures DI, options, and handlers.
+            </summary>
+        </member>
+        <member name="P:Telegrator.HostBuilderExtensions.&lt;G&gt;$BF7227490CCA365283B3A9274C9033C7.Handlers">
             <summary>
             Gets the <see cref="T:Telegrator.Core.IHandlersCollection"/> from the builder properties.
             </summary>
@@ -275,6 +284,14 @@
             Provides method to configure Telegram Bot Host
             </summary>
         </member>
+        <member name="M:Telegrator.ServicesCollectionExtensions.AddStateStorage``1(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
+            <summary>
+            Registers <see cref="T:Telegrator.Core.States.IStateStorage"/> service
+            </summary>
+            <typeparam name="TStorage"></typeparam>
+            <param name="services"></param>
+            <returns></returns>
+        </member>
         <member name="M:Telegrator.ServicesCollectionExtensions.AddTelegramBotHostDefaults(Microsoft.Extensions.DependencyInjection.IServiceCollection)">
             <summary>
             Registers <see cref="T:Telegrator.Hosting.TelegramBotHost"/> default services

examples/EchoBot/EchoBot.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+	<PackageReference Include="Telegrator" Version="1.16.2"/>
+  </ItemGroup>
+</Project>

examples/EchoBot/Program.cs

@@ -0,0 +1,11 @@
+using Telegrator;
+
+namespace Telegrator.Examples;
+
+public class EchoBot
+{
+    public static void Main(string[] args)
+    {
+        var client = new TelegratorClient();
+    }
+}

src/Telegartor.RedisStateStorage/README.md

@@ -0,0 +1,57 @@
+# Telegrator.RedisStateStorage
+
+**Telegrator.RedisStateStorage** is an extension for the Telegrator framework that provides Redis powered IStateStorage implementation.
+
+---
+
+## Requirements
+- .NET standart 2.1 or later
+- [Telegrator](https://github.com/Rikitav/Telegrator)
+
+---
+
+## Installation
+
+```shell
+dotnet add package Telegrator.RedisStateStorage
+```
+
+---
+
+## Quick Start Example
+
+**Program.cs:**
+```csharp
+using Telegrator.Hosting;
+
+// Creating builder
+TelegramBotHostBuilder builder = TelegramBotHost.CreateBuilder(new HostApplicationBuilderSettings()
+{
+    Args = args,
+    ApplicationName = "TelegramBotHost example",
+});
+
+// Registerring handlers
+builder.Handlers.CollectHandlersAssemblyWide();
+
+// Register your services and 
+builder.Services.AddService<IStateStorage, RedisStateStorage>(services =>
+    new RedisStateStorage(ConnectionMultiplexer.Connect("server1:6379, server2:6379")));
+
+// Building and running application
+TelegramBotHost telegramBot = builder.Build();
+telegramBot.SetBotCommands();
+telegramBot.Run();
+```
+
+---
+
+## Documentation
+- [Telegrator Main Docs](https://github.com/Rikitav/Telegrator)
+- [Getting Started Guide](https://github.com/Rikitav/Telegrator/wiki/Getting-started)
+- [Annotation Overview](https://github.com/Rikitav/Telegrator/wiki/Annotation-overview)
+
+---
+
+## License
+GPLv3 

src/Telegartor.RedisStateStorage/States/RedisStateStorage.cs

@@ -0,0 +1,39 @@
+using StackExchange.Redis;
+using System.Text.Json;
+using Telegrator.Core.States;
+
+namespace Telegrator.States;
+
+/// <summary>
+/// Provides a Redis-based implementation of the <see cref="IStateStorage"/> interface.
+/// Serializes state objects to JSON format before storing them in the Redis database.
+/// </summary>
+public class RedisStateStorage(IConnectionMultiplexer redis) : IStateStorage
+{
+    private readonly IDatabase _db = redis.GetDatabase();
+
+    /// <inheritdoc/>
+    public async Task SetAsync<T>(string key, T state, CancellationToken cancellationToken)
+    {
+        string json = JsonSerializer.Serialize(state);
+        await _db.StringSetAsync(key, json);
+    }
+
+    /// <inheritdoc/>
+    public async Task<T?> GetAsync<T>(string key, CancellationToken cancellationToken)
+    {
+        RedisValue json = await _db.StringGetAsync(key);
+        string? jsonStr = json;
+
+        if (jsonStr is null)
+            return default;
+
+        return JsonSerializer.Deserialize<T?>(json: jsonStr);
+    }
+
+    /// <inheritdoc/>
+    public async Task DeleteAsync(string key, CancellationToken cancellationToken = default)
+    {
+        await _db.KeyDeleteAsync(key);
+    }
+}

src/Telegartor.RedisStateStorage/Telegartor.RedisStateStorage.csproj

@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+	<LangVersion>latest</LangVersion>
+	<RootNamespace>Telegrator</RootNamespace>
+	<BaseOutputPath>..\..\bin</BaseOutputPath>
+	<DocumentationFile>..\..\docs\$(AssemblyName).xml</DocumentationFile>
+	  
+    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+    <EnableNETAnalyzers>True</EnableNETAnalyzers>
+    <EnforceCodeStyleInBuild>True</EnforceCodeStyleInBuild>
+	  
+    <Title>Telegrator.RedisStateStorage</Title>
+    <Version>1.16.6</Version>
+	<Authors>Rikitav Tim4ik</Authors>
+    <Company>Rikitav Tim4ik</Company>
+    <RepositoryUrl>https://github.com/Rikitav/Telegrator</RepositoryUrl>
+    <PackageTags>telegram;bot;mediator;attributes;aspect;hosting;host;framework;easy;simple;handlers</PackageTags>
+	  
+    <PackageIcon>telegrator_nuget.png</PackageIcon>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageLicenseFile>LICENSE</PackageLicenseFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Telegrator\Telegrator.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="StackExchange.Redis" Version="2.11.8" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include=".\README.md" Pack="True" PackagePath="\" />
+    <None Include="..\..\LICENSE" Pack="True" PackagePath="\" />
+    <None Include="..\..\resources\telegrator_nuget.png" Pack="True" PackagePath="\" />
+  </ItemGroup>
+  
+</Project>

src/Telegrator.Hosting.Web/GlobalSuppressions.cs

@@ -9,3 +9,4 @@ using System.Diagnostics.CodeAnalysis;
 [assembly: SuppressMessage("Style", "IDE0090")]
 [assembly: SuppressMessage("Usage", "CA2254")]
 [assembly: SuppressMessage("Maintainability", "CA1510")]
+[assembly: SuppressMessage("Style", "IDE0270")]

src/Telegrator.Hosting.Web/Hosting.Web/TelegramBotWebHost.cs

@@ -7,8 +7,8 @@ using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Telegrator.Core;
 
-namespace Telegrator.Hosting.Web
+namespace Telegrator.Hosting.Web;
-{
+
 /// <summary>
 /// Represents a web hosted telegram bot
 /// </summary>
@@ -39,11 +39,13 @@ namespace Telegrator.Hosting.Web
     /// </summary>
     public ILogger<TelegramBotWebHost> Logger => _logger;
 
+    /// <inheritdoc/>
+    public IDictionary<string, object?> Properties => ((IApplicationBuilder)_innerApp).Properties;
+
     // Private interface fields
     IServiceProvider IEndpointRouteBuilder.ServiceProvider => Services;
     IServiceProvider IApplicationBuilder.ApplicationServices { get => Services; set => throw new NotImplementedException(); }
     IFeatureCollection IApplicationBuilder.ServerFeatures => ((IApplicationBuilder)_innerApp).ServerFeatures;
-        IDictionary<string, object?> IApplicationBuilder.Properties => ((IApplicationBuilder)_innerApp).Properties;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="WebApplicationBuilder"/> class.
@@ -53,7 +55,6 @@ namespace Telegrator.Hosting.Web
     {
         // Building proxy application
         _innerApp = webApplicationBuilder.Build();
-            _innerApp.UseTelegratorWeb();
 
         // Reruesting services for this host
         _updateRouter = Services.GetRequiredService<IUpdateRouter>();
@@ -69,9 +70,7 @@ namespace Telegrator.Hosting.Web
         ArgumentNullException.ThrowIfNull(settings, nameof(settings));
         WebApplicationBuilder innerApp = WebApplication.CreateBuilder(settings);
         TelegramBotWebHostBuilder builder = new TelegramBotWebHostBuilder(innerApp, settings);
-
+        builder.AddTelegratorWeb();
-            builder.Services.AddTelegramBotHostDefaults();
-            builder.Services.AddTelegramWebhook();
         return builder;
     }
 
@@ -84,9 +83,7 @@ namespace Telegrator.Hosting.Web
         ArgumentNullException.ThrowIfNull(settings, nameof(settings));
         WebApplicationBuilder innerApp = WebApplication.CreateSlimBuilder(settings);
         TelegramBotWebHostBuilder builder = new TelegramBotWebHostBuilder(innerApp, settings);
-
+        builder.AddTelegratorWeb();
-            builder.Services.AddTelegramBotHostDefaults();
-            builder.Services.AddTelegramWebhook();
         return builder;
     }
 
@@ -98,7 +95,9 @@ namespace Telegrator.Hosting.Web
     {
         ArgumentNullException.ThrowIfNull(settings, nameof(settings));
         WebApplicationBuilder innerApp = WebApplication.CreateEmptyBuilder(settings);
-            return new TelegramBotWebHostBuilder(innerApp, settings);
+        TelegramBotWebHostBuilder builder = new TelegramBotWebHostBuilder(innerApp, settings);
+        builder.AddTelegratorWeb();
+        return builder;
     }
 
     /// <inheritdoc/>
@@ -158,4 +157,3 @@ namespace Telegrator.Hosting.Web
         _disposed = true;
     }
 }
-}

src/Telegrator.Hosting.Web/Hosting.Web/TelegramBotWebHostBuilder.cs

@@ -1,13 +1,14 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Diagnostics.Metrics;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Telegrator.Core;
 
 #pragma warning disable IDE0001
-namespace Telegrator.Hosting.Web
+namespace Telegrator.Hosting.Web;
-{
+
 /// <summary>
 /// Represents a web hosted telegram bots and services builder that helps manage configuration, logging, lifetime, and more.
 /// </summary>
@@ -32,17 +33,33 @@ namespace Telegrator.Hosting.Web
     /// <inheritdoc/>
     public IHostEnvironment Environment => _innerBuilder.Environment;
 
+    /// <inheritdoc/>
+    public IDictionary<object, object> Properties => ((IHostApplicationBuilder)_innerBuilder).Properties;
+
+    /// <inheritdoc/>
+    public IMetricsBuilder Metrics => _innerBuilder.Metrics;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TelegramBotWebHostBuilder"/> class.
     /// </summary>
     /// <param name="webApplicationBuilder"></param>
     /// <param name="settings"></param>
-        public TelegramBotWebHostBuilder(WebApplicationBuilder webApplicationBuilder, WebApplicationOptions settings)
+    public TelegramBotWebHostBuilder(WebApplicationBuilder webApplicationBuilder, WebApplicationOptions? settings = null)
     {
         _innerBuilder = webApplicationBuilder ?? throw new ArgumentNullException(nameof(webApplicationBuilder));
         _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+    }
 
-            _innerBuilder.AddTelegratorWeb();
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TelegramBotWebHostBuilder"/> class.
+    /// </summary>
+    /// <param name="webApplicationBuilder"></param>
+    /// <param name="options"></param>
+    /// <param name="settings"></param>
+    public TelegramBotWebHostBuilder(WebApplicationBuilder webApplicationBuilder, TelegratorOptions? options, WebApplicationOptions? settings)
+    {
+        _innerBuilder = webApplicationBuilder ?? throw new ArgumentNullException(nameof(webApplicationBuilder));
+        _settings = settings ?? throw new ArgumentNullException(nameof(settings));
     }
 
     /// <summary>
@@ -55,8 +72,19 @@ namespace Telegrator.Hosting.Web
     {
         _innerBuilder = webApplicationBuilder ?? throw new ArgumentNullException(nameof(webApplicationBuilder));
         _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+    }
 
-            _innerBuilder.AddTelegratorWeb(null, handlers);
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TelegramBotWebHostBuilder"/> class.
+    /// </summary>
+    /// <param name="webApplicationBuilder"></param>
+    /// <param name="handlers"></param>
+    /// <param name="options"></param>
+    /// <param name="settings"></param>
+    public TelegramBotWebHostBuilder(WebApplicationBuilder webApplicationBuilder, IHandlersCollection handlers, TelegratorOptions? options, WebApplicationOptions settings)
+    {
+        _innerBuilder = webApplicationBuilder ?? throw new ArgumentNullException(nameof(webApplicationBuilder));
+        _settings = settings ?? throw new ArgumentNullException(nameof(settings));
     }
 
     /// <summary>
@@ -69,5 +97,10 @@ namespace Telegrator.Hosting.Web
         host.UseTelegrator();
         return host;
     }
+
+    /// <inheritdoc/>
+    public void ConfigureContainer<TContainerBuilder>(IServiceProviderFactory<TContainerBuilder> factory, Action<TContainerBuilder>? configure = null) where TContainerBuilder : notnull
+    {
+        ((IHostApplicationBuilder)_innerBuilder).ConfigureContainer(factory, configure);
     }
 }

src/Telegrator.Hosting.Web/Hosting.Web/WebhookerOptions.cs

@@ -1,7 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 
-namespace Telegrator.Hosting.Web
+namespace Telegrator.Hosting.Web;
-{
+
 /// <summary>
 /// Configuration options for Telegram bot behavior and execution settings.
 /// Controls various aspects of bot operation including concurrency, routing, webhook receiving, and execution policies.
@@ -32,4 +32,3 @@ namespace Telegrator.Hosting.Web
     /// </summary>
     public bool DropPendingUpdates { get; set; } = false;
 }
-}

src/Telegrator.Hosting.Web/Mediation/HostedUpdateWebhooker.cs

@@ -10,8 +10,8 @@ using Telegram.Bot.Types;
 using Telegrator.Core;
 using Telegrator.Hosting.Web;
 
-namespace Telegrator.Mediation
+namespace Telegrator.Mediation;
-{
+
 /// <summary>
 /// Service for receiving updates for Hosted telegram bots via Webhooks
 /// </summary>
@@ -19,7 +19,6 @@ namespace Telegrator.Mediation
 {
     private const string SecretTokenHeader = "X-Telegram-Bot-Api-Secret-Token";
 
-        private readonly IEndpointRouteBuilder _botHost;
     private readonly ITelegramBotClient _botClient;
     private readonly IUpdateRouter _updateRouter;
     private readonly WebhookerOptions _options;
@@ -32,12 +31,11 @@ namespace Telegrator.Mediation
     /// <param name="updateRouter"></param>
     /// <param name="options"></param>
     /// <exception cref="ArgumentNullException"></exception>
-        public HostedUpdateWebhooker(IEndpointRouteBuilder botHost, ITelegramBotClient botClient, IUpdateRouter updateRouter, IOptions<WebhookerOptions> options)
+    public HostedUpdateWebhooker(ITelegramBotClient botClient, IUpdateRouter updateRouter, IOptions<WebhookerOptions> options)
     {
         if (string.IsNullOrEmpty(options.Value.WebhookUri))
             throw new ArgumentNullException(nameof(options), "Option \"WebhookUrl\" must be set to subscribe for update recieving");
 
-            _botHost = botHost;
         _botClient = botClient;
         _updateRouter = updateRouter;
         _options = options.Value;
@@ -52,9 +50,6 @@ namespace Telegrator.Mediation
 
     private async void StartInternal(CancellationToken cancellationToken)
     {
-            string pattern = new UriBuilder(_options.WebhookUri).Path;
-            _botHost.MapPost(pattern, (Delegate)ReceiveUpdate);
-
         await _botClient.SetWebhook(
             url: _options.WebhookUri,
             maxConnections: _options.MaxConnections,
@@ -71,6 +66,16 @@ namespace Telegrator.Mediation
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Maps bot webhook to application builder
+    /// </summary>
+    /// <param name="routeBuilder"></param>
+    public void MapWebhook(IEndpointRouteBuilder routeBuilder)
+    {
+        string pattern = new UriBuilder(_options.WebhookUri).Path;
+        routeBuilder.MapPost(pattern, (Delegate)ReceiveUpdate);
+    }
+
     private async Task<IResult> ReceiveUpdate(HttpContext ctx)
     {
         if (_options.SecretToken != null)
@@ -94,4 +99,3 @@ namespace Telegrator.Mediation
         return Results.Ok();
     }
 }
-}

src/Telegrator.Hosting.Web/Program.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
 using Telegrator.Hosting;
 using Telegrator.Hosting.Web;
@@ -43,10 +44,14 @@ internal class Program
 
     public static void TelegramBotHostBuilder_Example(string[] args)
     {
+        ConfigurationManager configuration = new ConfigurationManager();
+        configuration.AddJsonFile("appsettings.json");
+
         TelegramBotHostBuilder builder = TelegramBotHost.CreateBuilder(new HostApplicationBuilderSettings()
         {
             Args = args,
             ApplicationName = "TelegramBotHost example",
+            Configuration = configuration
         });
 
         builder.Handlers.CollectHandlersAssemblyWide();

src/Telegrator.Hosting.Web/Telegrator.Hosting.Web.csproj

@@ -15,7 +15,7 @@
     <EnforceCodeStyleInBuild>True</EnforceCodeStyleInBuild>
 	  
     <Title>Telegrator.Hosting.Web</Title>
-    <Version>1.16.1</Version>
+    <Version>1.16.6</Version>
 	<Authors>Rikitav Tim4ik</Authors>
     <Company>Rikitav Tim4ik</Company>
     <RepositoryUrl>https://github.com/Rikitav/Telegrator</RepositoryUrl>

src/Telegrator.Hosting.Web/TypesExtensions.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -7,6 +8,7 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Telegram.Bot;
 using Telegrator.Core;
+using Telegrator.Hosting;
 using Telegrator.Hosting.Web;
 using Telegrator.Mediation;
 using Telegrator.Providers;
@@ -41,7 +43,27 @@ namespace Telegrator
         /// <summary>
         /// Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
         /// </summary>
-        public static IHostApplicationBuilder AddTelegratorWeb(this IHostApplicationBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null)
+        public static ITelegramBotHostBuilder AddTelegratorWeb(this ITelegramBotHostBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null, Action<ITelegramBotHostBuilder>? action = null)
+        {
+            builder.AddTelegratorWebInternal(options, handlers);
+            action?.Invoke(builder);
+            return builder;
+        }
+
+        /// <summary>
+        /// Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+        /// </summary>
+        public static IHostApplicationBuilder AddTelegratorWeb(this WebApplicationBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null, Action<ITelegramBotHostBuilder>? action = null)
+        {
+            builder.AddTelegratorWebInternal(options, handlers);
+            action?.Invoke(new TelegramBotWebHostBuilder(builder));
+            return builder;
+        }
+
+        /// <summary>
+        /// Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+        /// </summary>
+        internal static IHostApplicationBuilder AddTelegratorWebInternal(this IHostApplicationBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null)
         {
             IServiceCollection services = builder.Services;
             IConfigurationManager configuration = builder.Configuration;
@@ -102,11 +124,12 @@ namespace Telegrator
         /// Replaces the initialization logic from TelegramBotWebHost constructor. 
         /// Initializes the bot and logs handlers on application startup.
         /// </summary>
-        public static WebApplication UseTelegratorWeb(this WebApplication app)
+        public static T UseTelegratorWeb<T>(this T app) where T : IEndpointRouteBuilder, IHost
         {
-            ITelegramBotInfo info = app.Services.GetRequiredService<ITelegramBotInfo>();
+            HostedUpdateWebhooker webhooker = app.ServiceProvider.GetRequiredService<HostedUpdateWebhooker>();
-            IHandlersCollection handlers = app.Services.GetRequiredService<IHandlersCollection>();
+            ITelegramBotInfo info = app.ServiceProvider.GetRequiredService<ITelegramBotInfo>();
-            ILoggerFactory loggerFactory = app.Services.GetRequiredService<ILoggerFactory>();
+            IHandlersCollection handlers = app.ServiceProvider.GetRequiredService<IHandlersCollection>();
+            ILoggerFactory loggerFactory = app.ServiceProvider.GetRequiredService<ILoggerFactory>();
             ILogger logger = loggerFactory.CreateLogger("Telegrator.Hosting.Web.TelegratorHost");
 
             if (logger.IsEnabled(LogLevel.Information))
@@ -116,6 +139,7 @@ namespace Telegrator
                 logger.LogHandlers(handlers);
             }
 
+            webhooker.MapWebhook(app);
             return app;
         }
 

src/Telegrator.Hosting/GlobalSuppressions.cs

@@ -9,3 +9,4 @@ using System.Diagnostics.CodeAnalysis;
 [assembly: SuppressMessage("Style", "IDE0090")]
 [assembly: SuppressMessage("Usage", "CA2254")]
 [assembly: SuppressMessage("Maintainability", "CA1510")]
+[assembly: SuppressMessage("Style", "IDE0270")]

src/Telegrator.Hosting/Hosting/HostedTelegramBotInfo.cs

@@ -3,8 +3,8 @@ using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegrator.Core;
 
-namespace Telegrator.Hosting
+namespace Telegrator.Hosting;
-{
+
 /// <summary>
 /// Implementation of <see cref="ITelegramBotInfo"/> that provides bot information.
 /// Contains metadata about the Telegram bot including user details and service provider for wider filterring abilities
@@ -12,7 +12,7 @@ namespace Telegrator.Hosting
 /// <param name="client"></param>
 /// <param name="services"></param>
 /// <param name="configuration"></param>
-    public class HostedTelegramBotInfo(ITelegramBotClient client, IServiceProvider services, IConfigurationManager configuration) : ITelegramBotInfo
+public class HostedTelegramBotInfo(ITelegramBotClient client, IServiceProvider services, IConfiguration configuration) : ITelegramBotInfo
 {
     /// <inheritdoc/>
     public User User { get; } = client.GetMe().Result;
@@ -25,6 +25,5 @@ namespace Telegrator.Hosting
     /// <summary>
     /// Provides access to configuration of this Hosted telegram bot
     /// </summary>
-        public IConfigurationManager Configuration { get; } = configuration;
+    public IConfiguration Configuration { get; } = configuration;
-    }
 }

src/Telegrator.Hosting/Hosting/ITelegramBotHostBuilder.cs

@@ -1,29 +1,12 @@
-using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.DependencyInjection;
+using System;
-using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Text;
 using Telegrator.Core;
 
-namespace Telegrator.Hosting
+namespace Telegrator.Hosting;
-{
-    /// <summary>
-    /// Interface for building Telegram bot hosts with dependency injection support.
-    /// Combines host application building capabilities with handler collection functionality.
-    /// </summary>
-    public interface ITelegramBotHostBuilder : ICollectingProvider
-    {
-        /// <summary>
-        /// Gets the set of key/value configuration properties.
-        /// </summary>
-        IConfigurationManager Configuration { get; }
 
-        /// <summary>
+public interface ITelegramBotHostBuilder : IHostApplicationBuilder, ICollectingProvider
-        /// Gets a collection of logging providers for the application to compose. This is useful for adding new logging providers.
+{
-        /// </summary>
-        ILoggingBuilder Logging { get; }
 
-        /// <summary>
-        /// Gets a collection of services for the application to compose. This is useful for adding user provided or framework provided services.
-        /// </summary>
-        IServiceCollection Services { get; }
-    }
 }

src/Telegrator.Hosting/Hosting/TelegramBotHost.cs

@@ -1,25 +1,23 @@
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Telegrator.Core;
 
-namespace Telegrator.Hosting
+namespace Telegrator.Hosting;
-{
+
 /// <summary>
 /// Represents a hosted telegram bot
 /// </summary>
 public class TelegramBotHost : IHost, ITelegratorBot
 {
     private readonly IHost _innerHost;
-        private readonly IServiceProvider _serviceProvider;
     private readonly IUpdateRouter _updateRouter;
     private readonly ILogger<TelegramBotHost> _logger;
 
     private bool _disposed;
 
     /// <inheritdoc/>
-        public IServiceProvider Services => _serviceProvider;
+    public IServiceProvider Services => _innerHost.Services;
 
     /// <inheritdoc/>
     public IUpdateRouter UpdateRouter => _updateRouter;
@@ -40,8 +38,6 @@ namespace Telegrator.Hosting
 
         // Building proxy hoster
         _innerHost = hostApplicationBuilder.Build();
-            _serviceProvider = _innerHost.Services;
-            _innerHost.UseTelegrator();
 
         // Reruesting services for this host
         _updateRouter = Services.GetRequiredService<IUpdateRouter>();
@@ -56,9 +52,6 @@ namespace Telegrator.Hosting
     {
         HostApplicationBuilder innerBuilder = new HostApplicationBuilder(settings: null);
         TelegramBotHostBuilder builder = new TelegramBotHostBuilder(innerBuilder, null);
-
-            builder.Services.AddTelegramBotHostDefaults();
-            builder.Services.AddTelegramReceiver();
         return builder;
     }
 
@@ -70,9 +63,6 @@ namespace Telegrator.Hosting
     {
         HostApplicationBuilder innerBuilder = new HostApplicationBuilder(settings);
         TelegramBotHostBuilder builder = new TelegramBotHostBuilder(innerBuilder, settings);
-
-            builder.Services.AddTelegramBotHostDefaults();
-            builder.Services.AddTelegramReceiver();
         return builder;
     }
 
@@ -122,4 +112,3 @@ namespace Telegrator.Hosting
         _disposed = true;
     }
 }
-}

src/Telegrator.Hosting/Hosting/TelegramBotHostBuilder.cs

@@ -1,17 +1,17 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Diagnostics.Metrics;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Telegrator.Core;
-using Telegrator.Providers;
 
 #pragma warning disable IDE0001
-namespace Telegrator.Hosting
+namespace Telegrator.Hosting;
-{
+
 /// <summary>
 /// Represents a hosted telegram bots and services builder that helps manage configuration, logging, lifetime, and more.
 /// </summary>
-    public class TelegramBotHostBuilder : ICollectingProvider
+public class TelegramBotHostBuilder : ITelegramBotHostBuilder
 {
     private readonly HostApplicationBuilder _innerBuilder;
     private readonly HostApplicationBuilderSettings _settings;
@@ -32,6 +32,12 @@ namespace Telegrator.Hosting
     /// <inheritdoc/>
     public IHostEnvironment Environment => _innerBuilder.Environment;
 
+    /// <inheritdoc/>
+    public IDictionary<object, object> Properties => ((IHostApplicationBuilder)_innerBuilder).Properties;
+
+    /// <inheritdoc/>
+    public IMetricsBuilder Metrics => _innerBuilder.Metrics;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TelegramBotHostBuilder"/> class.
     /// </summary>
@@ -41,9 +47,18 @@ namespace Telegrator.Hosting
     {
         _innerBuilder = hostApplicationBuilder ?? throw new ArgumentNullException(nameof(hostApplicationBuilder));
         _settings = settings ?? new HostApplicationBuilderSettings();
+    }
 
-            _innerBuilder.AddTelegrator();
+    /// <summary>
-            _innerBuilder.Logging.ClearProviders();
+    /// Initializes a new instance of the <see cref="TelegramBotHostBuilder"/> class.
+    /// </summary>
+    /// <param name="hostApplicationBuilder"></param>
+    /// <param name="options"></param>
+    /// <param name="settings"></param>
+    public TelegramBotHostBuilder(HostApplicationBuilder hostApplicationBuilder, TelegratorOptions? options, HostApplicationBuilderSettings? settings)
+    {
+        _innerBuilder = hostApplicationBuilder ?? throw new ArgumentNullException(nameof(hostApplicationBuilder));
+        _settings = settings ?? new HostApplicationBuilderSettings();
     }
 
     /// <summary>
@@ -52,13 +67,23 @@ namespace Telegrator.Hosting
     /// <param name="hostApplicationBuilder"></param>
     /// <param name="handlers"></param>
     /// <param name="settings"></param>
-        public TelegramBotHostBuilder(HostApplicationBuilder hostApplicationBuilder, IHandlersCollection handlers, HostApplicationBuilderSettings? settings = null)
+    public TelegramBotHostBuilder(HostApplicationBuilder hostApplicationBuilder, IHandlersCollection handlers, HostApplicationBuilderSettings? settings)
     {
         _innerBuilder = hostApplicationBuilder ?? throw new ArgumentNullException(nameof(hostApplicationBuilder));
         _settings = settings ?? new HostApplicationBuilderSettings();
+    }
 
-            _innerBuilder.AddTelegrator(null, handlers);
+    /// <summary>
-            _innerBuilder.Logging.ClearProviders();
+    /// Initializes a new instance of the <see cref="TelegramBotHostBuilder"/> class.
+    /// </summary>
+    /// <param name="hostApplicationBuilder"></param>
+    /// <param name="handlers"></param>
+    /// <param name="options"></param>
+    /// <param name="settings"></param>
+    public TelegramBotHostBuilder(HostApplicationBuilder hostApplicationBuilder, IHandlersCollection handlers, TelegratorOptions? options, HostApplicationBuilderSettings? settings)
+    {
+        _innerBuilder = hostApplicationBuilder ?? throw new ArgumentNullException(nameof(hostApplicationBuilder));
+        _settings = settings ?? new HostApplicationBuilderSettings();
     }
 
     /// <summary>
@@ -71,5 +96,10 @@ namespace Telegrator.Hosting
         host.UseTelegrator();
         return host;
     }
+
+    /// <inheritdoc/>
+    public void ConfigureContainer<TContainerBuilder>(IServiceProviderFactory<TContainerBuilder> factory, Action<TContainerBuilder>? configure = null) where TContainerBuilder : notnull
+    {
+        _innerBuilder.ConfigureContainer(factory, configure);
     }
 }

src/Telegrator.Hosting/Logging/MicrosoftLoggingAdapter.cs

@@ -1,20 +1,18 @@
-using Microsoft.Extensions.Logging;
+namespace Telegrator.Logging;
 
-namespace Telegrator.Logging
-{
 /// <summary>
 /// Adapter for Microsoft.Extensions.Logging to work with Telegrator logging system.
 /// This allows seamless integration with ASP.NET Core logging infrastructure.
 /// </summary>
 public class MicrosoftLoggingAdapter : ITelegratorLogger
 {
-        private readonly ILogger _logger;
+    private readonly Microsoft.Extensions.Logging.ILogger _logger;
 
     /// <summary>
     /// Initializes a new instance of MicrosoftLoggingAdapter.
     /// </summary>
     /// <param name="logger">The Microsoft.Extensions.Logging logger instance.</param>
-        public MicrosoftLoggingAdapter(ILogger logger)
+    public MicrosoftLoggingAdapter(Microsoft.Extensions.Logging.ILogger logger)
     {
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
@@ -24,11 +22,11 @@ namespace Telegrator.Logging
     {
         var msLogLevel = level switch
         {
-                Telegrator.Logging.LogLevel.Trace => Microsoft.Extensions.Logging.LogLevel.Trace,
+            LogLevel.Trace => Microsoft.Extensions.Logging.LogLevel.Trace,
-                Telegrator.Logging.LogLevel.Debug => Microsoft.Extensions.Logging.LogLevel.Debug,
+            LogLevel.Debug => Microsoft.Extensions.Logging.LogLevel.Debug,
-                Telegrator.Logging.LogLevel.Information => Microsoft.Extensions.Logging.LogLevel.Information,
+            LogLevel.Information => Microsoft.Extensions.Logging.LogLevel.Information,
-                Telegrator.Logging.LogLevel.Warning => Microsoft.Extensions.Logging.LogLevel.Warning,
+            LogLevel.Warning => Microsoft.Extensions.Logging.LogLevel.Warning,
-                Telegrator.Logging.LogLevel.Error => Microsoft.Extensions.Logging.LogLevel.Error,
+            LogLevel.Error => Microsoft.Extensions.Logging.LogLevel.Error,
             _ => Microsoft.Extensions.Logging.LogLevel.Information
         };
 
@@ -42,4 +40,3 @@ namespace Telegrator.Logging
         }
     }
 }
-} 

src/Telegrator.Hosting/Polling/HostUpdateHandlersPool.cs

@@ -1,13 +0,0 @@
-using Microsoft.Extensions.Options;
-using Telegrator.Core;
-using Telegrator.Mediation;
-
-namespace Telegrator.Polling
-{
-    /// <inheritdoc/>
-    public class HostUpdateHandlersPool(IUpdateRouter router, IOptions<TelegratorOptions> options)
-        : UpdateHandlersPool(router, options.Value, options.Value.GlobalCancellationToken)
-    {
-
-    }
-}

src/Telegrator.Hosting/Polling/HostUpdateRouter.cs

@@ -4,10 +4,11 @@ using Telegram.Bot;
 using Telegram.Bot.Polling;
 using Telegram.Bot.Types;
 using Telegrator.Core;
+using Telegrator.Core.States;
 using Telegrator.Mediation;
 
-namespace Telegrator.Polling
+namespace Telegrator.Polling;
-{
+
 /// <inheritdoc/>
 public class HostUpdateRouter : UpdateRouter
 {
@@ -20,10 +21,10 @@ namespace Telegrator.Polling
     public HostUpdateRouter(
         IHandlersProvider handlersProvider,
         IAwaitingProvider awaitingProvider,
+        IStateStorage stateStorage,
         IOptions<TelegratorOptions> options,
-            IUpdateHandlersPool handlersPool,
         ITelegramBotInfo botInfo,
-            ILogger<HostUpdateRouter> logger) : base(handlersProvider, awaitingProvider, options.Value, handlersPool, botInfo)
+        ILogger<HostUpdateRouter> logger) : base(handlersProvider, awaitingProvider, stateStorage, options.Value, botInfo)
     {
         Logger = logger;
         ExceptionHandler = new DefaultRouterExceptionHandler(HandleException);
@@ -56,4 +57,3 @@ namespace Telegrator.Polling
         Logger.LogError("Exception was thrown during update routing faulted :\n{exception}", exception.ToString());
     }
 }
-}

src/Telegrator.Hosting/Polling/HostedUpdateReceiver.cs

@@ -6,8 +6,8 @@ using Telegram.Bot.Polling;
 using Telegrator.Core;
 using Telegrator.Mediation;
 
-namespace Telegrator.Polling
+namespace Telegrator.Polling;
-{
+
 /// <summary>
 /// Service for receiving updates for Hosted telegram bots
 /// </summary>
@@ -29,4 +29,3 @@ namespace Telegrator.Polling
         await updateReceiver.ReceiveAsync(_updateRouter, stoppingToken).ConfigureAwait(false);
     }
 }
-}

src/Telegrator.Hosting/Providers/HostAwaitingProvider.cs

@@ -1,11 +1,9 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
-using Microsoft.Extensions.Options;
+
+namespace Telegrator.Providers;
 
-namespace Telegrator.Providers
-{
 /// <inheritdoc/>
-    public class HostAwaitingProvider(IOptions<TelegratorOptions> options, ILogger<HostAwaitingProvider> logger) : AwaitingProvider(options.Value)
+public class HostAwaitingProvider(IOptions<TelegratorOptions> options) : AwaitingProvider(options.Value)
 {
-        private readonly ILogger<HostAwaitingProvider> _logger = logger;
+
-    }
 }

src/Telegrator.Hosting/Providers/HostHandlersCollection.cs

@@ -2,8 +2,8 @@
 using Telegrator.Core;
 using Telegrator.Core.Descriptors;
 
-namespace Telegrator.Providers
+namespace Telegrator.Providers;
-{
+
 /// <inheritdoc/>
 public class HostHandlersCollection(IServiceCollection hostServiceColletion, TelegratorOptions options) : HandlersCollection(options)
 {
@@ -59,4 +59,3 @@ namespace Telegrator.Providers
         return base.AddDescriptor(descriptor);
     }
 }
-}

src/Telegrator.Hosting/Providers/HostHandlersProvider.cs

@@ -1,27 +1,23 @@
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Telegrator.Core;
 using Telegrator.Core.Descriptors;
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Providers
+namespace Telegrator.Providers;
-{
+
 /// <inheritdoc/>
 public class HostHandlersProvider : HandlersProvider
 {
     private readonly IServiceProvider Services;
-        private readonly ILogger<HostHandlersProvider> Logger;
 
     /// <inheritdoc/>
     public HostHandlersProvider(
         IHandlersCollection handlers,
         IOptions<TelegratorOptions> options,
-            IServiceProvider serviceProvider,
+        IServiceProvider serviceProvider) : base(handlers, options.Value)
-            ILogger<HostHandlersProvider> logger) : base(handlers, options.Value)
     {
         Services = serviceProvider;
-            Logger = logger;
     }
 
     /// <inheritdoc/>
@@ -42,4 +38,3 @@ namespace Telegrator.Providers
         return updateHandler;
     }
 }
-}

src/Telegrator.Hosting/Telegrator.Hosting.csproj

@@ -15,7 +15,7 @@
     <EnforceCodeStyleInBuild>True</EnforceCodeStyleInBuild>
 	  
     <Title>Telegrator.Hosting</Title>
-    <Version>1.16.1</Version>
+    <Version>1.16.6</Version>
 	<Authors>Rikitav Tim4ik</Authors>
     <Company>Rikitav Tim4ik</Company>
     <RepositoryUrl>https://github.com/Rikitav/Telegrator</RepositoryUrl>

src/Telegrator.Hosting/TypesExtensions.cs

@@ -11,10 +11,12 @@ using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
 using Telegrator.Core;
 using Telegrator.Core.Descriptors;
+using Telegrator.Core.States;
 using Telegrator.Hosting;
 using Telegrator.Logging;
 using Telegrator.Polling;
 using Telegrator.Providers;
+using Telegrator.States;
 
 namespace Telegrator;
 
@@ -28,7 +30,7 @@ public static class HostBuilderExtensions
     /// </summary>
     public const string HandlersCollectionPropertyKey = nameof(IHandlersCollection);
 
-    extension (IHostApplicationBuilder builder)
+    extension (HostApplicationBuilder builder)
     {
         /// <summary>
         /// Gets the <see cref="IHandlersCollection"/> from the builder properties.
@@ -37,18 +39,35 @@ public static class HostBuilderExtensions
         {
             get
             {
-                if (builder is TelegramBotHostBuilder botHostBuilder)
+                return (IHandlersCollection)((IHostApplicationBuilder)builder).Properties[HandlersCollectionPropertyKey];
-                    return botHostBuilder.Handlers;
-
-                return (IHandlersCollection)builder.Properties[HandlersCollectionPropertyKey];
             }
         }
     }
 
     /// <summary>
-    /// Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+    /// Replaces TelegramBotHostBuilder. Configures DI, options, and handlers.
     /// </summary>
-    public static IHostApplicationBuilder AddTelegrator(this IHostApplicationBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null)
+    public static ITelegramBotHostBuilder AddTelegrator(this ITelegramBotHostBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null, Action<ITelegramBotHostBuilder>? action = null)
+    {
+        builder.AddTelegratorInternal(options, handlers);
+        action?.Invoke(builder);
+        return builder;
+    }
+
+    /// <summary>
+    /// Replaces TelegramBotHostBuilder. Configures DI, options, and handlers.
+    /// </summary>
+    public static IHostApplicationBuilder AddTelegrator(this HostApplicationBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null, Action<ITelegramBotHostBuilder>? action = null)
+    {
+        builder.AddTelegratorInternal(options, handlers);
+        action?.Invoke(new TelegramBotHostBuilder(builder));
+        return builder;
+    }
+
+    /// <summary>
+    /// Replaces TelegramBotHostBuilder. Configures DI, options, and handlers.
+    /// </summary>
+    public static IHostApplicationBuilder AddTelegratorInternal(this IHostApplicationBuilder builder, TelegratorOptions? options = null, IHandlersCollection? handlers = null)
     {
         IServiceCollection services = builder.Services;
         IConfigurationManager configuration = builder.Configuration;
@@ -112,6 +131,18 @@ public static class HostBuilderExtensions
 /// </summary>
 public static class ServicesCollectionExtensions
 {
+    /// <summary>
+    /// Registers <see cref="IStateStorage"/> service
+    /// </summary>
+    /// <typeparam name="TStorage"></typeparam>
+    /// <param name="services"></param>
+    /// <returns></returns>
+    public static IServiceCollection AddStateStorage<TStorage>(this IServiceCollection services) where TStorage : IStateStorage
+    {
+        services.Replace(new ServiceDescriptor(typeof(IStateStorage), typeof(TStorage), ServiceLifetime.Singleton));
+        return services;
+    }
+
     /// <summary>
     /// Registers <see cref="TelegramBotHost"/> default services
     /// </summary>
@@ -119,12 +150,11 @@ public static class ServicesCollectionExtensions
     /// <returns></returns>
     public static IServiceCollection AddTelegramBotHostDefaults(this IServiceCollection services)
     {
-        services.AddLogging(builder => builder.AddConsole().AddDebug());
-        services.AddSingleton<IUpdateHandlersPool, HostUpdateHandlersPool>();
         services.AddSingleton<IAwaitingProvider, HostAwaitingProvider>();
         services.AddSingleton<IHandlersProvider, HostHandlersProvider>();
         services.AddSingleton<IUpdateRouter, HostUpdateRouter>();
         services.AddSingleton<ITelegramBotInfo, HostedTelegramBotInfo>();
+        services.AddSingleton<IStateStorage, DefaultStateStorage>();
 
         return services;
     }

src/Telegrator.Localized/LocalizedMessageHandlerExtensions.cs

@@ -4,8 +4,8 @@ using System.Threading.Tasks;
 using Telegram.Bot.Types;
 using Telegrator.Handlers;
 
-namespace Telegrator.Localized
+namespace Telegrator.Localized;
-{
+
 public static class LocalizedMessageHandlerExtensions
 {
     public static async Task<Message> ResponseLocalized(this ILocalizedHandler<Message> localizedHandler, string localizedReplyIdentifier, params IEnumerable<string> formatArgs)
@@ -14,4 +14,3 @@ namespace Telegrator.Localized
         return await localizedHandler.Container.Responce(localizedString.Value);
     }
 }
-}

src/Telegrator.Localized/Telegrator.Localized.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard2.1</TargetFramework>
 	<LangVersion>latest</LangVersion>
   </PropertyGroup>
 

src/Telegrator/Annotations/CallbackQueryAttributes.cs

@@ -4,8 +4,8 @@ using Telegrator.Attributes;
 using Telegrator.Core.Filters;
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Abstract base attribute for filtering callback-based updates.
 /// Supports various message types including regular messages, edited messages, channel posts, and business messages.
@@ -41,4 +41,3 @@ namespace Telegrator.Annotations
 public class CallbackInlineIdAttribute(string inlineMessageId)
     : CallbackQueryAttribute(new CallbackInlineIdFilter(inlineMessageId))
 { }
-}

src/Telegrator/Annotations/CommandAlliasAttribute.cs

@@ -3,8 +3,8 @@ using Telegram.Bot.Types.Enums;
 using Telegrator.Filters;
 using Telegrator.Attributes;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages based on command aliases.
 /// Allows handlers to respond to multiple command variations using a single attribute.
@@ -57,4 +57,3 @@ namespace Telegrator.Annotations
     /// <returns>The message from the update, or null if not present.</returns>
     public override Message? GetFilterringTarget(Update update) => update.Message;
 }
-}

src/Telegrator/Annotations/CommandArgumentAttributes.cs

@@ -1,8 +1,8 @@
 using System.Text.RegularExpressions;
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages where a command has arguments count >= <paramref name="count"/>.
 /// </summary>
@@ -60,4 +60,3 @@ namespace Telegrator.Annotations
 public class ArgumentRegexAttribute(string pattern, RegexOptions options = RegexOptions.None, int index = 0)
     : MessageFilterAttribute(new ArgumentRegexFilter(pattern, options, index: index))
 { }
-}

src/Telegrator/Annotations/DontCollectAttribute.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute that prevents a class from being automatically collected by the handler collection system.
 /// When applied to a class, it will be excluded from domain-wide handler collection operations.
@@ -9,4 +9,3 @@
 {
 
 }
-}

src/Telegrator/Annotations/EnvironmentFilterAttributes.cs

@@ -4,8 +4,8 @@ using Telegrator.Filters;
 using Telegrator.Attributes;
 using Telegrator.Core.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Abstract base attribute for filtering updates based on environment conditions.
 /// Can process all types of updates and provides environment-specific filtering logic.
@@ -82,4 +82,3 @@ namespace Telegrator.Annotations
     public EnvironmentVariableAttribute(string variable, StringComparison comparison)
         : base(new EnvironmentVariableFilter(variable, comparison)) { }
 }
-}

src/Telegrator/Annotations/MentionedAttribute.cs

@@ -1,8 +1,8 @@
 using Telegram.Bot.Types.Enums;
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages that contain mentions.
 /// Allows handlers to respond only to messages that mention the bot or specific users.
@@ -37,4 +37,3 @@ namespace Telegrator.Annotations
     public MentionedAttribute(string mention, int offset)
         : base(new MessageHasEntityFilter(MessageEntityType.Mention, offset, null), new MentionedFilter(mention)) { }
 }
-}

src/Telegrator/Annotations/MessageChatFilterAttributes.cs

@@ -1,8 +1,8 @@
 using Telegram.Bot.Types.Enums;
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages sent in forum chats.
 /// </summary>
@@ -102,4 +102,3 @@ namespace Telegrator.Annotations
     public ChatNameAttribute(string? firstName, string? lastName)
         : base(new MessageChatNameFilter(firstName, lastName)) { }
 }
-}

src/Telegrator/Annotations/MessageFilterAttributes.cs

@@ -5,8 +5,8 @@ using Telegrator.Filters;
 using Telegrator.Attributes;
 using Telegrator.Core.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Abstract base attribute for filtering message-based updates.
 /// Supports various message types including regular messages, edited messages, channel posts, and business messages.
@@ -158,4 +158,3 @@ namespace Telegrator.Annotations
     public MessageHasEntityAttribute(MessageEntityType type, int offset, int? length, string content, StringComparison stringComparison = StringComparison.CurrentCulture)
         : base(new MessageHasEntityFilter(type, offset, length, content, stringComparison)) { }
 }
-}

src/Telegrator/Annotations/MessageRepliedAttributes.cs

@@ -1,7 +1,7 @@
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages with reply to messages of this bot.
 /// </summary>
@@ -24,4 +24,3 @@ namespace Telegrator.Annotations
 public class FromReplyChainAttribute(int replyDepth = 1)
     : MessageFilterAttribute(new FromReplyChainFilter(replyDepth))
 { }
-}

src/Telegrator/Annotations/MessageSenderFilterAttributes.cs

@@ -1,7 +1,7 @@
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages based on the sender's username.
 /// </summary>
@@ -89,4 +89,3 @@ namespace Telegrator.Annotations
 public class FromPremiumUserAttribute()
     : MessageFilterAttribute(new FromPremiumUserFilter())
 { }
-}

src/Telegrator/Annotations/MessageTextFilterAttributes.cs

@@ -1,7 +1,7 @@
 using Telegrator.Filters;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute for filtering messages where the text starts with the specified content.
 /// </summary>
@@ -55,4 +55,3 @@ namespace Telegrator.Annotations
 public class TextContainsWordAttribute(string word, StringComparison comparison = StringComparison.InvariantCulture, int startIndex = 0)
     : MessageFilterAttribute(new TextContainsWordFilter(word, comparison, startIndex))
 { }
-}

src/Telegrator/Annotations/MightAwaitAttribute.cs

@@ -1,7 +1,7 @@
 using Telegram.Bot.Types.Enums;
 
-namespace Telegrator.Annotations
+namespace Telegrator.Annotations;
-{
+
 /// <summary>
 /// Attribute that says if this handler can await some of await types, that is not listed by its handler base.
 /// Used for automatic collecting allowed to receiving <see cref="UpdateType"/>'s.
@@ -24,4 +24,3 @@ namespace Telegrator.Annotations
     public MightAwaitAttribute(params UpdateType[] updateTypes)
         => _updateTypes = updateTypes;
 }
-}

src/Telegrator/Annotations/StateAttribute.cs

@@ -0,0 +1,32 @@
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using Telegrator.Attributes;
+using Telegrator.Core.States;
+using Telegrator.Filters;
+
+namespace Telegrator.Annotations;
+
+/// <summary>
+/// Attribute for filtering updates where resolved state matches target value.
+/// </summary>
+/// <typeparam name="TKey"></typeparam>
+/// <typeparam name="TValue"></typeparam>
+/// <param name="value"></param>
+public class StateAttribute<TKey, TValue>(TValue? value) : UpdateFilterAttribute<Update>(new StateKeyFilter<TKey, TValue>(value))
+    where TKey : IStateKeyResolver, new()
+    where TValue : IEquatable<TValue>
+{
+    /// <summary>
+    /// The targetting state value.
+    /// </summary>
+    public TValue? Value => value;
+
+    /// <inheritdoc/>
+    public override UpdateType[] AllowedTypes => Update.AllTypes;
+
+    /// <inheritdoc/>
+    public override Update? GetFilterringTarget(Update update)
+    {
+        return update;
+    }
+}

src/Telegrator/Annotations/StateKeeping/EnumStateAttribute.cs

@@ -1,44 +0,0 @@
-using Telegrator.StateKeeping;
-using Telegrator.Attributes;
-using Telegrator.Core.StateKeeping;
-
-namespace Telegrator.Annotations.StateKeeping
-{
-    /// <summary>
-    /// Attribute for managing enum-based states in Telegram bot handlers.
-    /// Provides a convenient way to associate enum values with state management functionality.
-    /// </summary>
-    /// <typeparam name="TEnum">The enum type to be used for state management.</typeparam>
-    public class EnumStateAttribute<TEnum> : StateKeeperAttribute<long, TEnum, EnumStateKeeper<TEnum>> where TEnum : Enum
-    {
-        /// <summary>
-        /// Initializes a new instance of the EnumStateAttribute with a special state and custom key resolver.
-        /// </summary>
-        /// <param name="specialState">The special state to be managed.</param>
-        /// <param name="keyResolver">The resolver for extracting keys from updates.</param>
-        public EnumStateAttribute(SpecialState specialState, IStateKeyResolver<long> keyResolver)
-            : base(specialState, keyResolver) { }
-
-        /// <summary>
-        /// Initializes a new instance of the EnumStateAttribute with a specific enum state and custom key resolver.
-        /// </summary>
-        /// <param name="myState">The specific enum state to be managed.</param>
-        /// <param name="keyResolver">The resolver for extracting keys from updates.</param>
-        public EnumStateAttribute(TEnum myState, IStateKeyResolver<long> keyResolver)
-            : base(myState, keyResolver) { }
-
-        /// <summary>
-        /// Initializes a new instance of the EnumStateAttribute with a special state and default sender ID resolver.
-        /// </summary>
-        /// <param name="specialState">The special state to be managed.</param>
-        public EnumStateAttribute(SpecialState specialState)
-            : base(specialState, new SenderIdResolver()) { }
-
-        /// <summary>
-        /// Initializes a new instance of the EnumStateAttribute with a specific enum state and default sender ID resolver.
-        /// </summary>
-        /// <param name="myState">The specific enum state to be managed.</param>
-        public EnumStateAttribute(TEnum myState)
-            : this(myState, new SenderIdResolver()) { }
-    }
-}

src/Telegrator/Annotations/StateKeeping/NumericStateAttribute.cs

@@ -1,43 +0,0 @@
-using Telegrator.StateKeeping;
-using Telegrator.Attributes;
-using Telegrator.Core.StateKeeping;
-
-namespace Telegrator.Annotations.StateKeeping
-{
-    /// <summary>
-    /// Attribute for associating a handler or method with a numeric (integer) state keeper.
-    /// Provides constructors for flexible state and key resolver configuration.
-    /// </summary>
-    public class NumericStateAttribute : StateKeeperAttribute<long, int, NumericStateKeeper>
-    {
-        /// <summary>
-        /// Initializes the attribute with a special state and a custom key resolver.
-        /// </summary>
-        /// <param name="specialState">The special state to associate</param>
-        /// <param name="keyResolver">The key resolver for state keeping</param>
-        public NumericStateAttribute(SpecialState specialState, IStateKeyResolver<long> keyResolver)
-            : base(specialState, keyResolver) { }
-
-        /// <summary>
-        /// Initializes the attribute with a specific numeric state and a custom key resolver.
-        /// </summary>
-        /// <param name="myState">The integer state to associate</param>
-        /// <param name="keyResolver">The key resolver for state keeping</param>
-        public NumericStateAttribute(int myState, IStateKeyResolver<long> keyResolver)
-            : base(myState, keyResolver) { }
-
-        /// <summary>
-        /// Initializes the attribute with a special state and the default sender ID resolver.
-        /// </summary>
-        /// <param name="specialState">The special state to associate</param>
-        public NumericStateAttribute(SpecialState specialState)
-            : base(specialState, new SenderIdResolver()) { }
-
-        /// <summary>
-        /// Initializes the attribute with a specific numeric state and the default sender ID resolver.
-        /// </summary>
-        /// <param name="myState">The integer state to associate</param>
-        public NumericStateAttribute(int myState)
-            : this(myState, new SenderIdResolver()) { }
-    }
-}

src/Telegrator/Annotations/StateKeeping/SpecialState.cs

@@ -1,21 +0,0 @@
-namespace Telegrator.Annotations.StateKeeping
-{
-    /// <summary>
-    /// Represents special states for state keeping logic.
-    /// </summary>
-    public enum SpecialState
-    {
-        /// <summary>
-        /// No special state.
-        /// </summary>
-        None,
-        /// <summary>
-        /// Indicates that no state is present.
-        /// </summary>
-        NoState,
-        /// <summary>
-        /// Indicates that any state is acceptable.
-        /// </summary>
-        AnyState
-    }
-}

src/Telegrator/Annotations/StateKeeping/StringStateAttribute.cs

@@ -1,43 +0,0 @@
-using Telegrator.StateKeeping;
-using Telegrator.Attributes;
-using Telegrator.Core.StateKeeping;
-
-namespace Telegrator.Annotations.StateKeeping
-{
-    /// <summary>
-    /// Attribute for associating a handler or method with a string-based state keeper.
-    /// Provides various constructors for flexible state and key resolver configuration.
-    /// </summary>
-    public class StringStateAttribute : StateKeeperAttribute<long, string, StringStateKeeper>
-    {
-        /// <summary>
-        /// Initializes the attribute with a special state and a custom key resolver.
-        /// </summary>
-        /// <param name="specialState">The special state to associate</param>
-        /// <param name="keyResolver">The key resolver for state keeping</param>
-        public StringStateAttribute(SpecialState specialState, IStateKeyResolver<long> keyResolver)
-            : base(specialState, keyResolver) { }
-
-        /// <summary>
-        /// Initializes the attribute with a specific state and a custom key resolver.
-        /// </summary>
-        /// <param name="myState">The string state to associate</param>
-        /// <param name="keyResolver">The key resolver for state keeping</param>
-        public StringStateAttribute(string myState, IStateKeyResolver<long> keyResolver)
-            : base(myState, keyResolver) { }
-
-        /// <summary>
-        /// Initializes the attribute with a special state and the default sender ID resolver.
-        /// </summary>
-        /// <param name="specialState">The special state to associate</param>
-        public StringStateAttribute(SpecialState specialState)
-            : base(specialState, new SenderIdResolver()) { }
-
-        /// <summary>
-        /// Initializes the attribute with a specific state and the default sender ID resolver.
-        /// </summary>
-        /// <param name="myState">The string state to associate</param>
-        public StringStateAttribute(string myState)
-            : base(myState, new SenderIdResolver()) { }
-    }
-}

src/Telegrator/Annotations/Targetted/WelcomeAttribute.cs

@@ -1,23 +0,0 @@
-using Telegram.Bot.Types;
-using Telegram.Bot.Types.Enums;
-using Telegrator.Filters;
-
-namespace Telegrator.Annotations.Targetted
-{
-    /// <summary>
-    /// Attribute for filtering message with command "start" in bot's private chats.
-    /// Allows handlers to respond to "welcome" bot commands.
-    /// </summary>
-    public class WelcomeAttribute : MessageFilterAttribute
-    {
-        /// <summary>
-        /// Creates new instance of <see cref="WelcomeAttribute"/>
-        /// </summary>
-        /// <param name="onlyFirst"></param>
-        public WelcomeAttribute(bool onlyFirst = false) : base(
-            new MessageChatTypeFilter(ChatType.Private),
-            new CommandAlliasFilter("start"),
-            Filter<Message>.If(ctx => !onlyFirst || ctx.Input.Id == 0))
-        { }
-    }
-}

src/Telegrator/Annotations/WelcomeAttribute.cs

@@ -0,0 +1,22 @@
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using Telegrator.Filters;
+
+namespace Telegrator.Annotations;
+
+/// <summary>
+/// Attribute for filtering message with command "start" in bot's private chats.
+/// Allows handlers to respond to "welcome" bot commands.
+/// </summary>
+public class WelcomeAttribute : MessageFilterAttribute
+{
+    /// <summary>
+    /// Creates new instance of <see cref="WelcomeAttribute"/>
+    /// </summary>
+    /// <param name="onlyFirst"></param>
+    public WelcomeAttribute(bool onlyFirst = false) : base(
+        new MessageChatTypeFilter(ChatType.Private),
+        new CommandAlliasFilter("start"),
+        Filter<Message>.If(ctx => !onlyFirst || ctx.Input.Id == 0))
+    { }
+}

src/Telegrator/Aspects/AfterExecutionAttribute.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Aspects
+namespace Telegrator.Aspects;
-{
+
 /// <summary>
 /// Attribute that specifies a post-execution processor to be executed after the handler.
 /// The processor type must implement <see cref="IPostProcessor"/> interface.
@@ -13,4 +13,3 @@
     /// </summary>
     public Type ProcessorType => typeof(T);
 }
-}

src/Telegrator/Aspects/BeforeExecutionAttribute.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Aspects
+namespace Telegrator.Aspects;
-{
+
 /// <summary>
 /// Attribute that specifies a pre-execution processor to be executed before the handler.
 /// The processor type must implement <see cref="IPreProcessor"/> interface.
@@ -13,4 +13,3 @@
     /// </summary>
     public Type ProcessorType => typeof(T);
 }
-}

src/Telegrator/Aspects/IPostProcessor.cs.cs

@@ -1,7 +1,7 @@
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Aspects
+namespace Telegrator.Aspects;
-{
+
 /// <summary>
 /// Interface for post-execution processors that are executed after handler execution.
 /// Implement this interface to add cross-cutting concerns like logging, cleanup, or metrics collection.
@@ -16,4 +16,3 @@ namespace Telegrator.Aspects
     /// <returns>A <see cref="Result"/> indicating the final execution result.</returns>
     public Task<Result> AfterExecution(IHandlerContainer container, CancellationToken cancellationToken);
 }
-}

src/Telegrator/Aspects/IPreProcessor.cs

@@ -1,7 +1,7 @@
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Aspects
+namespace Telegrator.Aspects;
-{
+
 /// <summary>
 /// Interface for pre-execution processors that are executed before handler execution.
 /// Implement this interface to add cross-cutting concerns like validation, logging, or authorization.
@@ -16,4 +16,3 @@ namespace Telegrator.Aspects
     /// <returns>A <see cref="Result"/> indicating whether execution should continue or be stopped.</returns>
     public Task<Result> BeforeExecution(IHandlerContainer container, CancellationToken cancellationToken = default);
 }
-}

src/Telegrator/Attributes/FilterAnnotation.cs

@@ -3,8 +3,8 @@ using Telegram.Bot.Types.Enums;
 using Telegrator.Core.Filters;
 using Telegrator.Filters;
 
-namespace Telegrator.Attributes
+namespace Telegrator.Attributes;
-{
+
 /// <summary>
 /// Reactive way to implement a new <see cref="UpdateFilterAttribute{T}"/> of type <typeparamref name="T"/>
 /// </summary>
@@ -36,4 +36,3 @@ namespace Telegrator.Attributes
     /// <inheritdoc/>
     public abstract bool CanPass(FilterExecutionContext<T> context);
 }
-}

src/Telegrator/Attributes/FilterModifier.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Attributes
+namespace Telegrator.Attributes;
-{
+
 /// <summary>
 /// Enumeration of filter modifiers that can be applied to update filters.
 /// Defines how filters should be combined and applied in filter chains.
@@ -22,4 +22,3 @@
     /// </summary>
     Not = 4,
 }
-}

src/Telegrator/Attributes/StateKeeperAttribute.cs

@@ -1,86 +0,0 @@
-using Telegram.Bot.Types;
-using Telegrator.Annotations.StateKeeping;
-using Telegrator.Core.Attributes;
-using Telegrator.Core.Filters;
-using Telegrator.Core.StateKeeping;
-
-namespace Telegrator.Attributes
-{
-    /// <summary>
-    /// Abstract attribute for associating a handler or method with a state keeper.
-    /// Provides logic for state-based filtering and state management.
-    /// </summary>
-    /// <typeparam name="TKey">The type of the key used for state keeping (e.g., chat ID).</typeparam>
-    /// <typeparam name="TState">The type of the state value (e.g., string, int).</typeparam>
-    /// <typeparam name="TKeeper">The type of the state keeper implementation.</typeparam>
-    public abstract class StateKeeperAttribute<TKey, TState, TKeeper> : StateKeeperAttributeBase where TKey : notnull where TState : notnull where TKeeper : StateKeeperBase<TKey, TState>, new()
-    {
-        /*
-        private static readonly TKeeper _shared = new TKeeper();
-        private static readonly Dictionary<TKey, TKeeper> _keyed = [];
-        */
-
-        /// <summary>
-        /// Gets or sets the singleton instance of the state keeper for this attribute type.
-        /// </summary>
-        public static TKeeper Shared { get; } = new TKeeper();
-
-        /// <summary>
-        /// Gets the default state value of this statekeeper.
-        /// </summary>
-        public static TState DefaultState => Shared.DefaultState;
-
-        /// <summary>
-        /// Gets the state value associated with this attribute instance.
-        /// </summary>
-        public TState MyState { get; private set; }
-
-        /// <summary>
-        /// Gets the special state mode for this attribute instance.
-        /// </summary>
-        public SpecialState SpecialState { get; private set; }
-
-        /// <summary>
-        /// Initializes the attribute with a specific state and a custom key resolver.
-        /// </summary>
-        /// <param name="myState">The state value to associate</param>
-        /// <param name="keyResolver">The key resolver for state keeping</param>
-        protected StateKeeperAttribute(TState myState, IStateKeyResolver<TKey> keyResolver) : base(typeof(TKeeper))
-        {
-            Shared.KeyResolver = keyResolver;
-            MyState = myState;
-            SpecialState = SpecialState.None;
-        }
-
-        /// <summary>
-        /// Initializes the attribute with a special state and a custom key resolver.
-        /// </summary>
-        /// <param name="specialState">The special state mode</param>
-        /// <param name="keyResolver">The key resolver for state keeping</param>
-        protected StateKeeperAttribute(SpecialState specialState, IStateKeyResolver<TKey> keyResolver) : base(typeof(TKeeper))
-        {
-            Shared.KeyResolver = keyResolver;
-            MyState = Shared.DefaultState;
-            SpecialState = specialState;
-        }
-
-        /// <summary>
-        /// Determines whether the current update context passes the state filter.
-        /// </summary>
-        /// <param name="context">The filter execution context</param>
-        /// <returns>True if the state matches the filter; otherwise, false.</returns>
-        public override bool CanPass(FilterExecutionContext<Update> context)
-        {
-            if (SpecialState == SpecialState.AnyState)
-                return true;
-
-            if (!Shared.TryGetState(context.Input, out TState? state))
-                return SpecialState == SpecialState.NoState;
-
-            if (state == null)
-                return false;
-
-            return MyState.Equals(state);
-        }
-    }
-}

src/Telegrator/Attributes/UpdateFilterAttribute.cs

@@ -3,8 +3,8 @@ using Telegrator.Core.Attributes;
 using Telegrator.Core.Filters;
 using Telegrator.Filters;
 
-namespace Telegrator.Attributes
+namespace Telegrator.Attributes;
-{
+
 /// <summary>
 /// Abstract base attribute for defining update filters for a specific type of update target.
 /// Provides logic for filter composition, modifier processing, and target extraction.
@@ -82,4 +82,3 @@ namespace Telegrator.Attributes
     /// <returns>The target object to filter, or null if not applicable</returns>
     public abstract T? GetFilterringTarget(Update update);
 }
-}

src/Telegrator/Attributes/UpdateHandlerAttribute.cs

@@ -2,8 +2,8 @@
 using Telegrator.Core.Attributes;
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Attributes
+namespace Telegrator.Attributes;
-{
+
 /// <summary>
 /// Abstract base attribute for marking update handler classes.
 /// Provides a type-safe way to associate handler types with specific update types and importance settings.
@@ -43,4 +43,3 @@ namespace Telegrator.Attributes
     protected UpdateHandlerAttribute(Type[] types, UpdateType updateType, int importance)
         : base([.. types, typeof(T)], updateType, importance) { }
 }
-}

src/Telegrator/Core/Attributes/StateKeeperAttributeBase.cs

@@ -1,35 +0,0 @@
-using Telegram.Bot.Types;
-using Telegrator.Core.Filters;
-using Telegrator.Core.Handlers;
-using Telegrator.Core.StateKeeping;
-
-namespace Telegrator.Core.Attributes
-{
-    /// <summary>
-    /// Sets the state in which the <see cref="UpdateHandlerBase"/> can be executed
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
-    public abstract class StateKeeperAttributeBase : Attribute, IFilter<Update>
-    {
-        /// <inheritdoc/>
-        public bool IsCollectible => GetType().HasPublicProperties();
-
-        /// <summary>
-        /// Creates a new instance <see cref="StateKeeperBase{TKey, TState}"/>
-        /// </summary>
-        /// <param name="stateKeeperType"></param>
-        /// <exception cref="ArgumentException"></exception>
-        protected StateKeeperAttributeBase(Type stateKeeperType)
-        {
-            if (!stateKeeperType.IsAssignableToGenericType(typeof(StateKeeperBase<,>)))
-                throw new ArgumentException(stateKeeperType + " is not a StateKeeperBase", nameof(stateKeeperType));
-        }
-
-        /// <summary>
-        /// Realizes a <see cref="IFilter{T}"/> for validation of the current <see cref="StateKeeperBase{TKey, TState}"/> in the polling routing
-        /// </summary>
-        /// <param name="context"></param>
-        /// <returns></returns>
-        public abstract bool CanPass(FilterExecutionContext<Update> context);
-    }
-}

src/Telegrator/Core/Attributes/UpdateFilterAttributeBase.cs

@@ -5,8 +5,8 @@ using Telegrator.Core.Filters;
 using Telegrator.Core.Handlers;
 using Telegrator.Filters;
 
-namespace Telegrator.Core.Attributes
+namespace Telegrator.Core.Attributes;
-{
+
 /// <summary>
 /// Defines the <see cref="IFilter{T}"/> to <see cref="Update"/> validation for entry into execution of the <see cref="UpdateHandlerBase"/>
 /// </summary>
@@ -44,4 +44,3 @@ namespace Telegrator.Core.Attributes
     /// <returns></returns>
     public abstract bool ProcessModifiers(UpdateFilterAttributeBase? previous);
 }
-}

src/Telegrator/Core/Attributes/UpdateHandlerAttributeBase.cs

@@ -4,8 +4,8 @@ using Telegrator.Core.Descriptors;
 using Telegrator.Core.Filters;
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Core.Attributes
+namespace Telegrator.Core.Attributes;
-{
+
 /// <summary>
 /// Defines the <see cref="UpdateType"/>'s and validator (<see cref="IFilter{T}"/>) of the <see cref="Update"/> that <see cref="UpdateHandlerBase"/> will process
 /// </summary>
@@ -79,4 +79,3 @@ namespace Telegrator.Core.Attributes
     /// <returns>True if the update passes validation; otherwise, false.</returns>
     public abstract bool CanPass(FilterExecutionContext<Update> context);
 }
-}

src/Telegrator/Core/Descriptors/DefaultCustomDescriptors.cs

@@ -7,8 +7,8 @@ using Telegrator.Core.Handlers;
 using Telegrator.Handlers;
 using Telegrator.Handlers.Building;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// Descriptor for creating handlers from methods
 /// </summary>
@@ -24,7 +24,7 @@ namespace Telegrator.Core.Descriptors
     public MethodHandlerDescriptor(AbstractHandlerAction<TUpdate> action) : base(DescriptorType.General, typeof(MethodHandler), true)
     {
         UpdateHandlerAttributeBase handlerAttribute = HandlerInspector.GetHandlerAttribute(action.Method);
-            StateKeeperAttributeBase? stateKeeperAttribute = HandlerInspector.GetStateKeeperAttribute(action.Method);
+        IFilter<Update>? stateKeeperAttribute = HandlerInspector.GetStateKeeperAttribute(action.Method);
         IFilter<Update>[] filters = HandlerInspector.GetFilterAttributes(action.Method, handlerAttribute.Type).ToArray();
 
         UpdateType = handlerAttribute.Type;
@@ -67,4 +67,3 @@ namespace Telegrator.Core.Descriptors
         }
     }
 }
-}

src/Telegrator/Core/Descriptors/DescribedHandlerDescriptor.cs

@@ -2,9 +2,10 @@
 using Telegram.Bot.Types;
 using Telegrator.Core.Filters;
 using Telegrator.Core.Handlers;
+using Telegrator.Core.States;
+
+namespace Telegrator.Core.Descriptors;
 
-namespace Telegrator.Core.Descriptors
-{
 /// <summary>
 /// Contains information about a described handler, including its context, client, and execution logic.
 /// </summary>
@@ -27,6 +28,11 @@ namespace Telegrator.Core.Descriptors
     /// </summary>
     public IAwaitingProvider AwaitingProvider { get; }
     
+    /// <summary>
+    /// The state storage to handling state machines
+    /// </summary>
+    public IStateStorage StateStorage { get; }
+
     /// <summary>
     /// The Telegram bot client used for this handler.
     /// </summary>
@@ -73,6 +79,7 @@ namespace Telegrator.Core.Descriptors
     /// <param name="fromDescriptor">The descriptor from which this handler was described.</param>
     /// <param name="updateRouter">The update router.</param>
     /// <param name="awaitingProvider">The awaiting provider.</param>
+    /// <param name="stateStorage">The state storage.</param>
     /// <param name="client">The Telegram bot client.</param>
     /// <param name="handlerInstance">The handler instance.</param>
     /// <param name="filterContext">The filter execution context.</param>
@@ -81,6 +88,7 @@ namespace Telegrator.Core.Descriptors
         HandlerDescriptor fromDescriptor,
         IUpdateRouter updateRouter,
         IAwaitingProvider awaitingProvider,
+        IStateStorage stateStorage,
         ITelegramBotClient client,
         UpdateHandlerBase handlerInstance,
         FilterExecutionContext<Update> filterContext,
@@ -89,6 +97,7 @@ namespace Telegrator.Core.Descriptors
         From = fromDescriptor;
         UpdateRouter = updateRouter;
         AwaitingProvider = awaitingProvider;
+        StateStorage = stateStorage;
         Client = client;
         HandlerInstance = handlerInstance;
         ExtraData = filterContext.Data;
@@ -114,7 +123,7 @@ namespace Telegrator.Core.Descriptors
     /// <param name="result">The execution result.</param>
     public void ReportResult(Result? result)
     {
-            if (result != null)
+        if (Result != null)
             throw new InvalidOperationException("Result already reported");
 
         Result = result;
@@ -125,4 +134,3 @@ namespace Telegrator.Core.Descriptors
     public override string ToString()
         => DisplayString ?? From.HandlerType.Name;
 }
-}

src/Telegrator/Core/Descriptors/DescriptorAspectsSet.cs

@@ -1,8 +1,8 @@
 using Telegrator.Aspects;
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// Manages the execution of pre and post-execution aspects for a handler.
 /// This class coordinates between self-processing (handler implements interfaces) 
@@ -77,4 +77,3 @@ namespace Telegrator.Core.Descriptors
         return Result.Ok();
     }
 }
-}

src/Telegrator/Core/Descriptors/DescriptorFiltersSet.cs

@@ -3,8 +3,8 @@ using Telegrator.Core.Filters;
 using Telegrator.Handlers.Diagnostics;
 using Telegrator.Logging;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// Represents a set of filters for a handler descriptor, including update and state keeper validators.
 /// </summary>
@@ -142,4 +142,3 @@ namespace Telegrator.Core.Descriptors
         }
     }
 }
-}

src/Telegrator/Core/Descriptors/DescriptorIndexer.cs

@@ -1,7 +1,7 @@
 using Telegrator.Core.Attributes;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// Represents an indexer for handler descriptors, containing importance and priority information.
 /// </summary>
@@ -85,4 +85,3 @@ namespace Telegrator.Core.Descriptors
         return string.Format("(Ix: {0,2}, Im: {1,2}, Pr: {2,2})", RouterIndex, Importance, Priority);
     }
 }
-}

src/Telegrator/Core/Descriptors/HandlerDescriptor.cs

@@ -4,8 +4,8 @@ using Telegrator.Core.Attributes;
 using Telegrator.Core.Filters;
 using Telegrator.Core.Handlers;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// Specifies the type of handler descriptor.
 /// </summary>
@@ -167,7 +167,7 @@ namespace Telegrator.Core.Descriptors
         if (handlerAttribute.ExpectingHandlerType != null && !handlerAttribute.ExpectingHandlerType.Contains(handlerType.BaseType))
             throw new ArgumentException(string.Format("This handler attribute cannot be attached to this class. Attribute can be attached on next handlers : {0}", string.Join(", ", handlerAttribute.ExpectingHandlerType.AsEnumerable())));
 
-            StateKeeperAttributeBase? stateKeeperAttribute = HandlerInspector.GetStateKeeperAttribute(handlerType);
+        IFilter<Update>? stateKeeperAttribute = HandlerInspector.GetStateKeeperAttribute(handlerType);
         IFilter<Update>[] filters = HandlerInspector.GetFilterAttributes(handlerType, handlerAttribute.Type).ToArray();
 
         UpdateType = handlerAttribute.Type;
@@ -472,4 +472,3 @@ namespace Telegrator.Core.Descriptors
     public override string ToString()
         => DisplayString ?? HandlerType.Name;
 }
-}

src/Telegrator/Core/Descriptors/HandlerDescriptorList.cs

@@ -2,8 +2,8 @@
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// The collection containing the <see cref="HandlerDescriptor"/>'s. Used to route <see cref="Update"/>'s in <see cref="IHandlersProvider"/>
 /// </summary>
@@ -156,4 +156,3 @@ namespace Telegrator.Core.Descriptors
         return _innerCollection.Values.GetEnumerator();
     }
 }
-}

src/Telegrator/Core/Descriptors/HandlerInspector.cs

@@ -2,12 +2,13 @@
 using System.Reflection;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
+using Telegrator.Annotations;
 using Telegrator.Aspects;
 using Telegrator.Core.Attributes;
 using Telegrator.Core.Filters;
 
-namespace Telegrator.Core.Descriptors
+namespace Telegrator.Core.Descriptors;
-{
+
 /// <summary>
 /// Provides methods for inspecting handler types and retrieving their attributes and filters.
 /// </summary>
@@ -42,13 +43,13 @@ namespace Telegrator.Core.Descriptors
     /// </summary>
     /// <param name="handlerType">The member info representing the handler type.</param>
     /// <returns>The state keeper attribute, or null if not present.</returns>
-        public static StateKeeperAttributeBase? GetStateKeeperAttribute(MemberInfo handlerType)
+    public static IFilter<Update>? GetStateKeeperAttribute(MemberInfo handlerType)
     {
         // Getting polling handler attribute
-            IEnumerable<StateKeeperAttributeBase> handlerAttrs = handlerType.GetCustomAttributes<StateKeeperAttributeBase>();
+        Attribute stateAttr = handlerType.GetCustomAttribute(typeof(StateAttribute<,>));
 
         //
-            return handlerAttrs.Any() ? handlerAttrs.Single() : null;
+        return stateAttr as IFilter<Update>;
     }
 
     /// <summary>
@@ -95,4 +96,3 @@ namespace Telegrator.Core.Descriptors
         return new DescriptorAspectsSet(typedPre, typedPost);
     }
 }
-}

src/Telegrator/Core/Filters/AnonymousCompiledFilter.cs

@@ -2,8 +2,8 @@
 using Telegrator.Filters;
 using Telegrator.Logging;
 
-namespace Telegrator.Core.Filters
+namespace Telegrator.Core.Filters;
-{
+
 /// <summary>
 /// Represents a compiled filter that applies a set of filters to an anonymous target type.
 /// </summary>
@@ -106,4 +106,3 @@ namespace Telegrator.Core.Filters
         }
     }
 }
-}

src/Telegrator/Core/Filters/AnonymousTypeFilter.cs

@@ -2,8 +2,8 @@
 using Telegrator.Filters;
 using Telegrator.Logging;
 
-namespace Telegrator.Core.Filters
+namespace Telegrator.Core.Filters;
-{
+
 /// <summary>
 /// Represents a filter that applies a filter action to an anonymous target type extracted from an update.
 /// </summary>
@@ -107,4 +107,3 @@ namespace Telegrator.Core.Filters
         }
     }
 }
-}

src/Telegrator/Core/Filters/CompiledFilter.cs

@@ -1,8 +1,8 @@
 using Telegrator.Filters;
 using Telegrator.Logging;
 
-namespace Telegrator.Core.Filters
+namespace Telegrator.Core.Filters;
-{
+
 /// <summary>
 /// Represents a filter that composes multiple filters and passes only if all of them pass.
 /// </summary>
@@ -61,4 +61,3 @@ namespace Telegrator.Core.Filters
         return true;
     }
 }
-}

src/Telegrator/Core/Filters/CompletedFiltersList.cs

@@ -1,7 +1,7 @@
 using System.Collections;
 
-namespace Telegrator.Core.Filters
+namespace Telegrator.Core.Filters;
-{
+
 /// <summary>
 /// The list containing filters worked out during Polling to further obtain additional filtering information
 /// </summary>
@@ -83,4 +83,3 @@ namespace Telegrator.Core.Filters
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => CompletedFilters.GetEnumerator();
 }
-}

src/Telegrator/Core/Filters/FilterExecutionContext.cs

@@ -1,14 +1,19 @@
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
 
-namespace Telegrator.Core.Filters
+namespace Telegrator.Core.Filters;
-{
+
 /// <summary>
 /// Represents the context for filter execution, including update, input, and additional data.
 /// </summary>
 /// <typeparam name="T">The type of the input for the filter.</typeparam>
 public class FilterExecutionContext<T> where T : class
 {
+    /// <summary>
+    /// Gets the <see cref="ITelegramBotInfo"/> for the current context.
+    /// </summary>
+    public IUpdateRouter UpdateRouter { get; }
+
     /// <summary>
     /// Gets the <see cref="ITelegramBotInfo"/> for the current context.
     /// </summary>
@@ -42,13 +47,15 @@ namespace Telegrator.Core.Filters
     /// <summary>
     /// Initializes a new instance of the <see cref="FilterExecutionContext{T}"/> class with all parameters.
     /// </summary>
+    /// <param name="router">The router, that invoked filter.</param>
     /// <param name="botInfo">The bot info.</param>
     /// <param name="update">The update.</param>
     /// <param name="input">The input object.</param>
     /// <param name="data">The additional data dictionary.</param>
     /// <param name="completedFilters">The list of completed filters.</param>
-        public FilterExecutionContext(ITelegramBotInfo botInfo, Update update, T input, Dictionary<string, object> data, CompletedFiltersList completedFilters)
+    public FilterExecutionContext(IUpdateRouter router, ITelegramBotInfo botInfo, Update update, T input, Dictionary<string, object> data, CompletedFiltersList completedFilters)
     {
+        UpdateRouter = router;
         BotInfo = botInfo;
         Data = data;
         CompletedFilters = completedFilters;
@@ -60,11 +67,12 @@ namespace Telegrator.Core.Filters
     /// <summary>
     /// Initializes a new instance of the <see cref="FilterExecutionContext{T}"/> class with default data and filters.
     /// </summary>
+    /// <param name="router">The router, that invoked filter.</param>
     /// <param name="botInfo">The bot info.</param>
     /// <param name="update">The update.</param>
     /// <param name="input">The input object.</param>
-        public FilterExecutionContext(ITelegramBotInfo botInfo, Update update, T input)
+    public FilterExecutionContext(IUpdateRouter router, ITelegramBotInfo botInfo, Update update, T input)
-            : this(botInfo, update, input, [], []) { }
+        : this(router, botInfo, update, input, [], []) { }
 
     /// <summary>
     /// Creates a child context for a different input type, sharing the same data and completed filters.
@@ -73,6 +81,5 @@ namespace Telegrator.Core.Filters
     /// <param name="input">The new input object.</param>
     /// <returns>A new <see cref="FilterExecutionContext{C}"/> instance.</returns>
     public FilterExecutionContext<C> CreateChild<C>(C input) where C : class
-            => new FilterExecutionContext<C>(BotInfo, Update, input, Data, CompletedFilters);
+        => new FilterExecutionContext<C>(UpdateRouter, BotInfo, Update, input, Data, CompletedFilters);
-    }
 }

src/Telegrator/Core/Filters/IFilter.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Core.Filters
+namespace Telegrator.Core.Filters;
-{
+
 /// <summary>
 /// Interface for filters that have a name for identification and debugging purposes.
 /// </summary>
@@ -36,4 +36,15 @@
     /// <returns>True if the filter passes; otherwise, false.</returns>
     public bool CanPass(FilterExecutionContext<T> info);
 }
+
+/// <summary>
+/// Represents a filter that joins multiple filters together.
+/// </summary>
+/// <typeparam name="T">The type of the input for the filter.</typeparam>
+public interface IJoinedFilter<T> : IFilter<T> where T : class
+{
+    /// <summary>
+    /// Gets the array of joined filters.
+    /// </summary>
+    public IFilter<T>[] Filters { get; }
 }

src/Telegrator/Core/Filters/IJoinedFilter.cs

@@ -1,14 +0,0 @@
-namespace Telegrator.Core.Filters
-{
-    /// <summary>
-    /// Represents a filter that joins multiple filters together.
-    /// </summary>
-    /// <typeparam name="T">The type of the input for the filter.</typeparam>
-    public interface IJoinedFilter<T> : IFilter<T> where T : class
-    {
-        /// <summary>
-        /// Gets the array of joined filters.
-        /// </summary>
-        public IFilter<T>[] Filters { get; }
-    }
-}

src/Telegrator/Core/Handlers/AbstractUpdateHandler.cs

@@ -3,10 +3,11 @@ using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
 using Telegrator.Core.Descriptors;
 using Telegrator.Core.Filters;
+using Telegrator.Core.States;
 using Telegrator.Handlers;
 
-namespace Telegrator.Core.Handlers
+namespace Telegrator.Core.Handlers;
-{
+
 /// <summary>
 /// Abstract handler for Telegram updates of type <typeparamref name="TUpdate"/>.
 /// </summary>
@@ -47,6 +48,11 @@ namespace Telegrator.Core.Handlers
     /// </summary>
     protected IAwaitingProvider AwaitingProvider => Container.AwaitingProvider;
 
+    /// <summary>
+    /// Storage of bot states.
+    /// </summary>
+    protected IStateStorage StateStorage => Container.StateStorage;
+
     /// <summary>
     /// Initializes a new instance and checks that the update type matches <typeparamref name="TUpdate"/>.
     /// </summary>
@@ -87,4 +93,3 @@ namespace Telegrator.Core.Handlers
     /// <returns>A task representing the asynchronous operation.</returns>
     public abstract Task<Result> Execute(IHandlerContainer<TUpdate> container, CancellationToken cancellation);
 }
-}

src/Telegrator/Core/Handlers/BranchingUpdateHandler.cs

@@ -6,8 +6,8 @@ using Telegrator.Core.Descriptors;
 using Telegrator.Core.Filters;
 using Telegrator.Handlers;
 
-namespace Telegrator.Core.Handlers
+namespace Telegrator.Core.Handlers;
-{
+
 /// <summary>
 /// Abstract base class for handlers that support branching execution based on different methods.
 /// Allows multiple handler methods to be defined in a single class, each with its own filters.
@@ -162,4 +162,3 @@ namespace Telegrator.Core.Handlers
         }
     }
 }
-}

src/Telegrator/Core/Handlers/Building/HandlerBuilderBase.cs

@@ -1,12 +1,12 @@
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.Enums;
-using Telegrator.Annotations.StateKeeping;
 using Telegrator.Core.Descriptors;
 using Telegrator.Core.Filters;
-using Telegrator.Core.StateKeeping;
+using Telegrator.Core.States;
+using Telegrator.Filters;
+
+namespace Telegrator.Core.Handlers.Building;
 
-namespace Telegrator.Core.Handlers.Building
-{
 /// <summary>
 /// Base class for building handler descriptors and managing handler filters.
 /// </summary>
@@ -140,35 +140,15 @@ namespace Telegrator.Core.Handlers.Building
     /// <summary>
     /// Sets a state keeper for the handler using a specific state and key resolver.
     /// </summary>
-        /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TKey">The key resolver.</typeparam>
-        /// <typeparam name="TState">The type of the state.</typeparam>
+    /// <typeparam name="TValue">The state value.</typeparam>
-        /// <typeparam name="TKeeper">The type of the state keeper.</typeparam>
+    /// <param name="state">The state value.</param>
-        /// <param name="myState">The state value.</param>
-        /// <param name="keyResolver">The key resolver.</param>
     /// <returns>The builder instance.</returns>
-        public void SetStateKeeper<TKey, TState, TKeeper>(TState myState, IStateKeyResolver<TKey> keyResolver)
+    public void SetState<TKey, TValue>(TValue? state)
-            where TKey : notnull
+        where TKey : IStateKeyResolver, new()
-            where TState : IEquatable<TState>
+        where TValue : IEquatable<TValue>
-            where TKeeper : StateKeeperBase<TKey, TState>, new()
     {
-            StateKeeper = new StateKeepFilter<TKey, TState, TKeeper>(myState, keyResolver);
+        StateKeeper = new StateKeyFilter<TKey, TValue>(state);
-        }
-
-        /// <summary>
-        /// Sets a state keeper for the handler using a special state and key resolver.
-        /// </summary>
-        /// <typeparam name="TKey">The type of the key.</typeparam>
-        /// <typeparam name="TState">The type of the state.</typeparam>
-        /// <typeparam name="TKeeper">The type of the state keeper.</typeparam>
-        /// <param name="specialState">The special state value.</param>
-        /// <param name="keyResolver">The key resolver.</param>
-        /// <returns>The builder instance.</returns>
-        public void SetStateKeeper<TKey, TState, TKeeper>(SpecialState specialState, IStateKeyResolver<TKey> keyResolver)
-            where TKey : notnull
-            where TState : IEquatable<TState>
-            where TKeeper : StateKeeperBase<TKey, TState>, new()
-        {
-            StateKeeper = new StateKeepFilter<TKey, TState, TKeeper>(specialState, keyResolver);
     }
 
     /// <summary>
@@ -197,4 +177,3 @@ namespace Telegrator.Core.Handlers.Building
         Filters.Add(compiledPollingFilter);
     }
 }
-}

src/Telegrator/Core/Handlers/Building/IAwaiterHandlerBuilder.cs

@@ -1,7 +1,7 @@
-using Telegrator.Core.StateKeeping;
+using Telegrator.Core.States;
+
+namespace Telegrator.Core.Handlers.Building;
 
-namespace Telegrator.Core.Handlers.Building
-{
 /// <summary>
 /// Defines a builder for awaiting handler logic for a specific update type.
 /// </summary>
@@ -11,9 +11,8 @@ namespace Telegrator.Core.Handlers.Building
     /// <summary>
     /// Awaits an update using the specified key resolver and cancellation token.
     /// </summary>
-        /// <param name="keyResolver">The <see cref="IStateKeyResolver{TKey}"/> to resolve the key.</param>
+    /// <param name="keyResolver">The <see cref="IStateKeyResolver"/> to resolve the key.</param>
     /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>A <see cref="Task{TUpdate}"/> representing the awaited update.</returns>
-        public Task<TUpdate> Await(IStateKeyResolver<long> keyResolver, CancellationToken cancellationToken = default);
+    public Task<TUpdate> Await(IStateKeyResolver keyResolver, CancellationToken cancellationToken = default);
-    }
 }

src/Telegrator/Core/Handlers/Building/IHandlerBuilder.cs

@@ -1,10 +1,9 @@
 using Telegram.Bot.Types;
-using Telegrator.Annotations.StateKeeping;
 using Telegrator.Core.Filters;
-using Telegrator.Core.StateKeeping;
+using Telegrator.Core.States;
+
+namespace Telegrator.Core.Handlers.Building;
 
-namespace Telegrator.Core.Handlers.Building
-{
 /// <summary>
 /// Defines builder actions for configuring handler builders.
 /// </summary>
@@ -56,30 +55,13 @@ namespace Telegrator.Core.Handlers.Building
     /// <summary>
     /// Sets a state keeper for the handler using a specific state and key resolver.
     /// </summary>
-        /// <typeparam name="TKey">The type of the key.</typeparam>
+    /// <typeparam name="TKey">The key resolver.</typeparam>
-        /// <typeparam name="TState">The type of the state.</typeparam>
+    /// <typeparam name="TValue">The state value.</typeparam>
-        /// <typeparam name="TKeeper">The type of the state keeper.</typeparam>
+    /// <param name="state">The state value.</param>
-        /// <param name="myState">The state value.</param>
-        /// <param name="keyResolver">The key resolver.</param>
     /// <returns>The builder instance.</returns>
-        public void SetStateKeeper<TKey, TState, TKeeper>(TState myState, IStateKeyResolver<TKey> keyResolver)
+    public void SetState<TKey, TValue>(TValue? state)
-            where TKey : notnull
+        where TKey : IStateKeyResolver, new()
-            where TState : IEquatable<TState>
+        where TValue : IEquatable<TValue>;
-            where TKeeper : StateKeeperBase<TKey, TState>, new();
-
-        /// <summary>
-        /// Sets a state keeper for the handler using a special state and key resolver.
-        /// </summary>
-        /// <typeparam name="TKey">The type of the key.</typeparam>
-        /// <typeparam name="TState">The type of the state.</typeparam>
-        /// <typeparam name="TKeeper">The type of the state keeper.</typeparam>
-        /// <param name="specialState">The special state value.</param>
-        /// <param name="keyResolver">The key resolver.</param>
-        /// <returns>The builder instance.</returns>
-        public void SetStateKeeper<TKey, TState, TKeeper>(SpecialState specialState, IStateKeyResolver<TKey> keyResolver)
-            where TKey : notnull
-            where TState : IEquatable<TState>
-            where TKeeper : StateKeeperBase<TKey, TState>, new();
 
     /// <summary>
     /// Adds a targeted filter for a specific filter target type.
@@ -101,4 +83,3 @@ namespace Telegrator.Core.Handlers.Building
     public void AddTargetedFilters<TFilterTarget>(Func<Update, TFilterTarget?> getFilterringTarget, params IFilter<TFilterTarget>[] filters)
         where TFilterTarget : class;
 }
-}

src/Telegrator/Core/Handlers/Building/IRegularHandlerBuilder.cs

@@ -1,7 +1,7 @@
 using Telegrator.Handlers.Building;
 
-namespace Telegrator.Core.Handlers.Building
+namespace Telegrator.Core.Handlers.Building;
-{
+
 /// <summary>
 /// Defines a builder for regular handler logic for a specific update type.
 /// </summary>
@@ -14,4 +14,3 @@ namespace Telegrator.Core.Handlers.Building
     /// <param name="executeHandler">The delegate to execute the handler logic.</param>
     public IHandlersCollection Build(AbstractHandlerAction<TUpdate> executeHandler);
 }
-}

src/Telegrator/Core/Handlers/Building/StateKeepFilter.cs

@@ -1,80 +0,0 @@
-using Telegram.Bot.Types;
-using Telegrator.Annotations.StateKeeping;
-using Telegrator.Core.Filters;
-using Telegrator.Core.StateKeeping;
-using Telegrator.Filters;
-
-namespace Telegrator.Core.Handlers.Building
-{
-    /// <summary>
-    /// Filter for state keeping logic, allowing filtering based on state and special state conditions.
-    /// </summary>
-    /// <typeparam name="TKey">The type of the key for state resolution.</typeparam>
-    /// <typeparam name="TState">The type of the state.</typeparam>
-    /// <typeparam name="TKeeper">The type of the state keeper.</typeparam>
-    public class StateKeepFilter<TKey, TState, TKeeper> : Filter<Update>
-        where TKey : notnull
-        where TState : IEquatable<TState>
-        where TKeeper : StateKeeperBase<TKey, TState>, new()
-    {
-        /// <summary>
-        /// Gets or sets the state keeper instance.
-        /// </summary>
-        public static TKeeper StateKeeper { get; internal set; } = null!;
-
-        /// <summary>
-        /// Gets the state value for this filter.
-        /// </summary>
-        public TState MyState { get; private set; }
-
-        /// <summary>
-        /// Gets the special state value for this filter.
-        /// </summary>
-        public SpecialState SpecialState { get; private set; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="StateKeepFilter{TKey, TState, TKeeper}"/> class with a specific state.
-        /// </summary>
-        /// <param name="myState">The state value.</param>
-        /// <param name="keyResolver">The key resolver.</param>
-        public StateKeepFilter(TState myState, IStateKeyResolver<TKey> keyResolver)
-        {
-            StateKeeper ??= new TKeeper();
-            StateKeeper.KeyResolver = keyResolver;
-            MyState = myState;
-            SpecialState = SpecialState.None;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="StateKeepFilter{TKey, TState, TKeeper}"/> class with a special state.
-        /// </summary>
-        /// <param name="specialState">The special state value.</param>
-        /// <param name="keyResolver">The key resolver.</param>
-        public StateKeepFilter(SpecialState specialState, IStateKeyResolver<TKey> keyResolver)
-        {
-            StateKeeper ??= new TKeeper();
-            StateKeeper.KeyResolver = keyResolver;
-            MyState = StateKeeper.DefaultState;
-            SpecialState = specialState;
-        }
-
-        /// <summary>
-        /// Determines whether the filter can pass for the given context based on state logic.
-        /// </summary>
-        /// <param name="context">The filter execution context.</param>
-        /// <returns>True if the filter passes; otherwise, false.</returns>
-        public override bool CanPass(FilterExecutionContext<Update> context)
-        {
-            if (SpecialState == SpecialState.AnyState)
-                return true;
-
-            if (!StateKeeper.TryGetState(context.Input, out TState? state))
-                return SpecialState == SpecialState.NoState;
-
-            if (state == null)
-                return false;
-
-            return MyState.Equals(state);
-        }
-    }
-}

src/Telegrator/Core/Handlers/Building/UpdateValidateFilter.cs

@@ -1,8 +1,8 @@
 using Telegram.Bot.Types;
 using Telegrator.Core.Filters;
 
-namespace Telegrator.Core.Handlers.Building
+namespace Telegrator.Core.Handlers.Building;
-{
+
 /// <summary>
 /// Delegate for validating an update in a filter context.
 /// </summary>
@@ -38,4 +38,3 @@ namespace Telegrator.Core.Handlers.Building
     public bool CanPass(FilterExecutionContext<Update> info)
         => UpdateValidateAction.Invoke(info);
 }
-}

src/Telegrator/Core/Handlers/EmptyHandlerContainer.cs

@@ -1,9 +1,10 @@
 using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegrator.Core.Filters;
+using Telegrator.Core.States;
+
+namespace Telegrator.Core.Handlers;
 
-namespace Telegrator.Core.Handlers
-{
 /// <summary>
 /// Represents an empty handler container that throws <see cref="NotImplementedException"/> for all members.
 /// </summary>
@@ -23,5 +24,7 @@ namespace Telegrator.Core.Handlers
 
     /// <inheritdoc/>
     public IAwaitingProvider AwaitingProvider => throw new NotImplementedException();
-    }
+
+    /// <inheritdoc/>
+    public IStateStorage StateStorage => throw new NotImplementedException();
 }

src/Telegrator/Core/Handlers/HandlerLifetimeToken.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Core.Handlers
+namespace Telegrator.Core.Handlers;
-{
+
 /// <summary>
 /// Represents a token that tracks the lifetime of a handler instance.
 /// </summary>
@@ -24,4 +24,3 @@
         OnLifetimeEnded?.Invoke(this);
     }
 }
-}

src/Telegrator/Core/Handlers/IHandlerContainer.cs

@@ -1,9 +1,10 @@
 using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegrator.Core.Filters;
+using Telegrator.Core.States;
+
+namespace Telegrator.Core.Handlers;
 
-namespace Telegrator.Core.Handlers
-{
 /// <summary>
 /// Interface for handler containers that provide context and resources for update handlers.
 /// Contains all necessary information and services that handlers need during execution.
@@ -34,5 +35,9 @@ namespace Telegrator.Core.Handlers
     /// Gets the <see cref="IAwaitingProvider"/> for awaiting operations.
     /// </summary>
     public IAwaitingProvider AwaitingProvider { get; }
-    }
+
+    /// <summary>
+    /// Gets the <see cref="IStateStorage"/> for state managment.
+    /// </summary>
+    public IStateStorage StateStorage { get; }
 }

src/Telegrator/Core/Handlers/IHandlerContainerFactory.cs

@@ -1,7 +1,7 @@
 using Telegrator.Core.Descriptors;
 
-namespace Telegrator.Core.Handlers
+namespace Telegrator.Core.Handlers;
-{
+
 /// <summary>
 /// Factory interface for creating handler containers.
 /// Provides a way to create handler containers with specific providers and handler information.
@@ -15,4 +15,3 @@ namespace Telegrator.Core.Handlers
     /// <returns>A new <see cref="IHandlerContainer"/> instance.</returns>
     public IHandlerContainer CreateContainer(DescribedHandlerDescriptor handlerInfo);
 }
-}

src/Telegrator/Core/Handlers/UpdateHandlerBase.cs

@@ -4,8 +4,8 @@ using Telegram.Bot.Types.Enums;
 using Telegrator.Core.Descriptors;
 using Telegrator.Handlers.Diagnostics;
 
-namespace Telegrator.Core.Handlers
+namespace Telegrator.Core.Handlers;
-{
+
 /// <summary>
 /// Base class for update handlers, providing execution and lifetime management for Telegram updates.
 /// </summary>
@@ -125,7 +125,7 @@ namespace Telegrator.Core.Handlers
         }
     }
 
-        internal IHandlerContainer GetContainer(DescribedHandlerDescriptor handlerInfo)
+    private IHandlerContainer GetContainer(DescribedHandlerDescriptor handlerInfo)
     {
         if (this is IHandlerContainerFactory handlerDefainedContainerFactory)
             return handlerDefainedContainerFactory.CreateContainer(handlerInfo);
@@ -179,4 +179,3 @@ namespace Telegrator.Core.Handlers
             GC.SuppressFinalize(this);
     }
 }
-}

src/Telegrator/Core/IAwaitingProvider.cs

@@ -1,7 +1,7 @@
 using Telegrator.Core.Descriptors;
 
-namespace Telegrator.Core
+namespace Telegrator.Core;
-{
+
 /// <summary>
 /// Provider for managing awaiting handlers that can wait for specific update types.
 /// </summary>
@@ -14,4 +14,3 @@ namespace Telegrator.Core
     /// <returns>An <see cref="IDisposable"/> that manages the handler's usage lifetime.</returns>
     public IDisposable UseHandler(HandlerDescriptor handlerDescriptor);
 }
-}

src/Telegrator/Core/ICollectingProvider.cs

@@ -1,5 +1,5 @@
-namespace Telegrator.Core
+namespace Telegrator.Core;
-{
+
 /// <summary>
 /// Interface for providers that collect and manage handler collections.
 /// Provides access to a collection of handlers for various processing operations.
@@ -11,4 +11,3 @@
     /// </summary>
     public IHandlersCollection Handlers { get; }
 }
-}