diff --git a/.ai-memory-bank/.gitkeep b/.ai-memory-bank/.gitkeep
new file mode 100644
index 000000000000..689752efa566
--- /dev/null
+++ b/.ai-memory-bank/.gitkeep
@@ -0,0 +1,2 @@
+# This file is used to keep the memory-bank directory in the repository.
+# It can be safely deleted if the directory contains other files.
\ No newline at end of file
diff --git a/.ai-memory-bank/comprehensive-file-index.md b/.ai-memory-bank/comprehensive-file-index.md
new file mode 100644
index 000000000000..c5009320bf70
--- /dev/null
+++ b/.ai-memory-bank/comprehensive-file-index.md
@@ -0,0 +1,350 @@
+# Comprehensive File Index
+
+## Root Directory
+- .ai_system_prompt - AI system prompt configuration file
+- .clang-format - Code formatting configuration for C++ code
+- .clang-tidy - Static analysis configuration for C++ code
+- .cmake-format.py - Configuration for formatting CMake files
+- .editorconfig - Editor configuration for consistent coding styles across editors
+- .gitattributes - Git attributes configuration for file handling
+- .gitignore - Git ignore patterns for excluding files from version control
+- .mapping.json - JSON mapping configuration file
+- .piglet-meta.json - Metadata configuration for Piglet tooling
+- 🛡️ .roorules - Project-specific rules and guidelines for AI agents
+- AUTHORS - List of contributors and authors of the project
+- CMakeLists.txt - Root CMake build configuration file
+- CODE_OF_CONDUCT.md - Guidelines for community conduct and interactions
+- CODEOWNERS - File defining code ownership for different parts of the project
+- conanfile.py - Conan package manager configuration file
+- CONTRIBUTING.md - Guidelines for contributing to the project
+- LICENSE - License information for the project
+- Makefile - Make build system configuration
+- pyproject.toml - Python project configuration file
+- pytest.ini - Configuration file for pytest testing framework
+- README.md - Main project documentation and introduction
+- SECURITY.md - Security policies and reporting procedures
+- THIRD_PARTY.md - Information about third-party dependencies and licenses
+
+### GitHub Configuration (.github/)
+- dependabot.yml - Configuration for automated dependency updates
+- docker-compose.yml - Docker Compose configuration for development environment
+- pull_request_template.md - Template for pull request descriptions
+- ISSUE_TEMPLATE/ - Templates for different types of issues
+- workflows/ - GitHub Actions workflow definitions
+
+## Core Framework (core/)
+The core framework provides the foundation components for building high-performance C++ services with asynchronous I/O and coroutine support.
+
+### Core Components
+- benchmarks/ - Performance benchmarking tools and tests
+- build_config.hpp.in - Build configuration template file
+- CMakeLists.txt - CMake build configuration for core framework
+- dynamic_configs/ - Dynamic configuration management system
+- functional_tests/ - Functional tests for core framework components
+- include/ - Public header files for core framework components
+- internal/ - Internal implementation details not exposed in public API
+- library.yaml - Library configuration file
+- libc_include_fixes/ - Fixes for standard library includes
+- README.md - Core framework documentation
+- src/ - Source code implementation of core framework components
+- static_configs/ - Static configuration files
+- sys_coro/ - System coroutine implementation
+- uboost_coro/ - Boost coroutine integration
+- utest/ - Unit testing framework and utilities
+
+### Core Subdirectories
+#### alerts/
+Framework for handling alert notifications and monitoring
+- source.hpp - Alert source interface
+
+#### baggage/
+Distributed tracing baggage propagation implementation
+- baggage_manager.hpp - Baggage manager implementation
+- baggage.hpp - Baggage data structure
+- fwd.hpp - Forward declarations for baggage components
+
+#### cache/
+Caching framework for in-memory and external cache solutions
+- cache_config.hpp - Cache configuration structures
+- cache_statistics.hpp - Cache statistics tracking
+- caching_component_base.hpp - Base class for caching components
+- expirable_lru_cache.hpp - LRU cache with expiration support
+- lru_cache_component_base.hpp - Base class for LRU cache components
+- lru_cache_config.hpp - LRU cache configuration
+- lru_cache_statistics.hpp - LRU cache statistics
+- nway_lru_cache.hpp - N-way LRU cache implementation
+- update_type.hpp - Cache update type definitions
+
+#### clients/
+HTTP and other client implementations for external service communication
+
+##### clients/dns/
+DNS client implementation
+- component.hpp - DNS client component
+- resolver.hpp - DNS resolver implementation
+
+##### clients/http/
+HTTP client implementation
+- client.hpp - HTTP client interface
+- component.hpp - HTTP client component
+- request.hpp - HTTP request representation
+- response.hpp - HTTP response representation
+- plugins/ - HTTP client plugins for additional functionality
+
+#### components/
+Component system for modular service architecture with lifecycle management
+- component_base.hpp - Base class for all components
+- component_list.hpp - Component list management
+- run.hpp - Service startup and shutdown functions
+
+#### concurrent/
+Concurrency primitives and utilities for thread-safe operations
+
+#### congestion_control/
+Network congestion control mechanisms
+- component.hpp - Congestion control component
+- controller.hpp - Congestion controller interface
+- limiter.hpp - Request rate limiter
+- sensor.hpp - Congestion monitoring sensor
+
+#### dist_lock/
+Distributed locking implementation for coordination between services
+
+#### dump/
+Data dump and restore functionality for caching components
+- config.hpp - Dump configuration structures
+- dumper.hpp - Data dumper interface
+- operations.hpp - Dump operations
+
+#### dynamic_config/
+Dynamic configuration system for runtime configuration changes
+- snapshot.hpp - Configuration snapshot
+- source.hpp - Configuration source
+- value.hpp - Typed configuration value wrapper
+
+#### engine/
+Coroutine-based engine for asynchronous I/O operations
+- async.hpp - Asynchronous task execution
+- task.hpp - Task management
+- mutex.hpp - Coroutine-aware mutex
+- condition_variable.hpp - Coroutine-aware condition variable
+
+#### fs/
+File system operations and utilities
+
+#### logging/
+Structured logging framework with multiple output options
+
+#### middlewares/
+Middleware components for request/response processing
+- pipeline.hpp - Middleware pipeline implementation
+- runner.hpp - Middleware execution runner
+
+#### net/
+Networking utilities and implementations
+
+#### os_signals/
+Operating system signal handling
+- component.hpp - OS signals handling component
+- processor.hpp - Signal processor implementation
+
+#### rcu/
+Read-Copy-Update (RCU) synchronization mechanism
+- rcu.hpp - RCU implementation
+- rcu_map.hpp - RCU-protected map data structure
+
+#### server/
+HTTP server implementation and related components
+
+#### storages/
+Storage abstractions for various database systems
+
+#### tracing/
+Distributed tracing implementation
+
+#### utils/
+General utility functions and classes
+
+## Code Generation Components
+
+### Chaotic (chaotic/)
+Code generation framework for data structures and serialization
+
+#### Chaotic Directories
+- bin/ - Executable scripts for code generation
+- bin-dynamic-configs/ - Dynamic configuration generation scripts
+- chaotic/ - Core chaotic implementation
+- golden_tests/ - Reference tests for generated code
+- include/ - Public header files for chaotic components
+- integration_tests/ - Integration tests for chaotic components
+- mypy/ - Python type checking configuration
+- src/ - Source code implementation
+- tests/ - Unit tests for chaotic components
+
+### Chaotic OpenAPI (chaotic-openapi/)
+OpenAPI-based code generation for client and server implementations
+
+#### Chaotic OpenAPI Directories
+- bin/ - Executable scripts for OpenAPI code generation
+- chaotic_openapi/ - Core OpenAPI implementation
+- golden_tests/ - Reference tests for generated OpenAPI code
+- include/ - Public header files for OpenAPI components
+- integration_tests/ - Integration tests for OpenAPI components
+- mypy/ - Python type checking configuration
+- src/ - Source code implementation
+- tests/ - Unit tests for OpenAPI components
+
+## Database Components
+
+### ClickHouse (clickhouse/)
+ClickHouse database driver and components for analytics workloads
+
+### MongoDB (mongo/)
+MongoDB database driver and components for document-based storage
+
+### MySQL (mysql/)
+MySQL database driver and components for relational data storage
+
+### PostgreSQL (postgresql/)
+PostgreSQL database driver and components for relational data storage
+
+### Redis/Valkey (redis/)
+Redis/Valkey database driver and components for in-memory data storage
+
+### RocksDB (rocks/)
+RocksDB key-value storage driver and components
+- CMakeLists.txt - CMake build configuration for RocksDB component
+- library.yaml - Library configuration file
+- include/ - Public header files for RocksDB components
+- src/ - Source code implementation for RocksDB components
+
+### SQLite (sqlite/)
+SQLite database driver and components for embedded relational storage
+
+### YDB (ydb/)
+YDB (Yandex Database) driver and components for distributed storage
+
+## Communication Components
+
+### gRPC (grpc/)
+gRPC communication framework for high-performance RPC calls
+
+### Kafka (kafka/)
+Kafka messaging system integration for event streaming
+
+### RabbitMQ (rabbitmq/)
+RabbitMQ messaging system integration for message queuing
+
+## Messaging Theme Rules (ai-development-settings/extreme/.roo/rules/20-themes/messaging/)
+Comprehensive messaging patterns and best practices for building robust messaging systems
+
+### Messaging Theme Rule Files
+- async-messaging.md - Asynchronous messaging patterns and processing strategies
+- event-driven.md - Event-driven architecture and event sourcing patterns
+- kafka.md - Kafka integration patterns and implementation guidelines
+- message-patterns.md - General message queue patterns and best practices
+- rabbitmq.md - RabbitMQ patterns and message queue management
+
+## Other Components
+
+### ODBC (odbc/)
+ODBC database connectivity layer
+
+### OpenTelemetry (otlp/)
+OpenTelemetry protocol implementation for distributed tracing and metrics
+
+## Development Support
+
+### CMake (cmake/)
+CMake build system files and configurations for building userver applications
+
+### Libraries (libraries/)
+Additional libraries and dependencies
+
+### Scripts (scripts/)
+Development scripts and tools for various tasks
+
+### Testsuite (testsuite/)
+Testing framework and utilities for functional and integration testing
+
+### Third Party (third_party/)
+Third-party dependencies and libraries
+
+### Universal (universal/)
+Universal components that work across different systems
+
+## Sample Services (samples/)
+Example services demonstrating how to use various components of the userver framework
+
+### Sample Services List
+- chaotic_openapi_service/ - Service using OpenAPI code generation
+- chaotic_service/ - Service using chaotic code generation
+- clickhouse_service/ - Service using ClickHouse database
+- config_service/ - Service demonstrating configuration management
+- digest_auth_service/ - Service with digest authentication
+- dns-resolver/ - Service demonstrating DNS resolution
+- embedded_files/ - Service with embedded files
+- flatbuf_service/ - Service using FlatBuffers serialization
+- grpc_middleware_service/ - Service with gRPC middleware
+- grpc_service/ - Service using gRPC communication
+- grpc-generic-proxy/ - Generic gRPC proxy service
+- hello_service/ - Basic hello world service example
+- http_caching/ - Service demonstrating HTTP caching
+- http_middleware_service/ - Service with HTTP middleware
+- http-client-perf/ - HTTP client performance testing service
+- https_service/ - Service with HTTPS support
+- json2yaml/ - Service for converting JSON to YAML
+- kafka_service/ - Service using Kafka messaging
+- mongo_service/ - Service using MongoDB database
+- mongo-support/ - MongoDB support utilities
+- multipart_service/ - Service handling multipart requests
+- mysql_service/ - Service using MySQL database
+- netcat/ - Network utility service
+- otlp_service/ - Service using OpenTelemetry protocol
+- postgres_auth/ - Service with PostgreSQL authentication
+- postgres_cache_order_by/ - Service with PostgreSQL caching
+- postgres_service/ - Service using PostgreSQL database
+- postgres-support/ - PostgreSQL support utilities
+- production_service/ - Example production-ready service
+- rabbitmq_service/ - Service using RabbitMQ messaging
+- redis_service/ - Service using Redis database
+- s3api/ - Service with S3 API integration
+- static_service/ - Service serving static files
+- tcp_full_duplex_service/ - Full-duplex TCP service
+- tcp_service/ - TCP-based service
+- testsuite-support/ - Testsuite support utilities
+- websocket_service/ - Service with WebSocket support
+- ydb_service/ - Service using YDB database
+
+## Service Template (service_template/)
+Template for creating new services with standard structure and configuration
+
+### Service Template Components
+- .clang-format - Code formatting configuration
+- .gitignore - Git ignore patterns
+- CMakeLists.txt - CMake build configuration
+- CMakePresets.json - CMake presets configuration
+- Makefile - Make build system configuration
+- README.md - Service documentation
+- requirements.txt - Python requirements
+- run_as_user.sh - Script for running service as specific user
+- .devcontainer/ - Development container configuration
+- .github/ - GitHub workflow configurations
+- cmake/ - CMake modules and configurations
+- configs/ - Configuration files
+- postgresql/ - PostgreSQL schema files
+- proto/ - Protocol buffer definitions
+- src/ - Source code implementation
+- tests/ - Test files
+
+## Memory Bank (memory-bank/)
+Project-specific documentation and context files for AI agents
+
+### Memory Bank Files
+- projectbrief.md - Foundation document defining core requirements and goals
+- productContext.md - Product context including problems solved and user experience goals
+- systemPatterns.md - System architecture and technical decisions
+- techContext.md - Technology context including development setup and dependencies
+- activeContext.md - Current work focus, recent changes, and next steps
+- progress.md - Current status, completed work, and known issues
+- comprehensive-file-index.md - Detailed file index with descriptions (this document)
\ No newline at end of file
diff --git a/.ai_system_prompt b/.ai_system_prompt
new file mode 100644
index 000000000000..d6cdeebb25f2
--- /dev/null
+++ b/.ai_system_prompt
@@ -0,0 +1,84 @@
+# AI System Prompt for userver Service Development
+
+I am an expert C++ software engineer specializing in developing services using the userver framework. My purpose is to help create high-performance, scalable services that leverage the userver framework's component-based architecture and asynchronous capabilities.
+
+## Core Principles
+
+### Service Development Focus
+- I develop services that use the userver framework, not the framework itself
+- I focus on implementing business logic in handlers and components
+- I use existing framework components rather than creating new ones
+- I follow service development patterns and best practices
+
+### Component-Based Architecture
+- Services are composed of components registered in main.cpp
+- Components have well-defined lifecycles (Constructor → Start → Stop → Destructor)
+- Components are configured through static_config.yaml
+- Dependencies between components are declared explicitly
+
+### Asynchronous Programming Model
+- All I/O operations use userver's asynchronous drivers
+- Operations are non-blocking and coroutine-safe
+- Deadline propagation ensures responsive service behavior
+- Cancellation support handles long-running operations gracefully
+
+## Available Resources
+
+### Examples and Templates
+- `samples/` directory contains working examples of various userver features
+- `service_template/` provides a base template for creating new services
+- `.ai-memory-bank/comprehensive-file-index.md` contains project file overview
+
+### Key Directories
+- `samples/hello_service/` - Simple HTTP service example
+- `samples/postgres_service/` - Service with PostgreSQL integration
+- `samples/redis_service/` - Service with Redis integration
+- `samples/grpc_service/` - gRPC service example
+
+## Development Workflow
+
+### 1. Service Creation
+- Start with the service_template/ as a base
+- Copy template: `cp -r service_template/ my_new_service/`
+- Customize CMakeLists.txt for project-specific dependencies
+- Implement handlers in src/ directory following established patterns
+- Configure components in configs/static_config.yaml
+
+### 2. Building and Running
+- Create build directory: `mkdir build && cd build`
+- Configure: `cmake ..`
+- Build: `make -j$(nproc)`
+- Run: `./my_service --config ../configs/static_config.yaml`
+
+### 3. Testing
+- Unit tests: `make test`
+- Functional tests: `cd tests && python3 -m pytest`
+
+## Best Practices
+
+### Performance Optimization
+- Use asynchronous operations to minimize context switches
+- Implement connection pooling for database and HTTP clients
+- Apply deadline propagation to all downstream requests
+- Use caching for frequently accessed data
+
+### Development Practices
+- Follow component lifecycle guidelines for initialization and cleanup
+- Use framework-provided synchronization primitives
+- Implement structured logging with contextual information
+- Write tests at multiple levels (unit, functional, integration)
+
+## Quality Standards
+
+### Code Quality
+- Follow userver coding guidelines and patterns
+- Use RAII and exception-safe coding practices
+- Implement proper memory management with smart pointers
+- Maintain consistent code formatting
+
+### Testing Requirements
+- Unit tests for core business logic
+- Functional tests for service endpoints
+- Integration tests for database and external service interactions
+
+This system prompt provides the foundation for developing high-quality services on the userver framework while maintaining consistency with established patterns and best practices. For detailed implementation guidance, refer to the .roorules file and examples in the samples/ directory.
diff --git a/.clang-tidy b/.clang-tidy
index 2c46a3b74dd3..bd9896841315 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -112,3 +112,67 @@ CheckOptions:
     value: '1'
   - key: modernize-loop-convert.UseCxx20ReverseRanges
     value: 'false'
+
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+    # Allow DISABLED_CamelCase to skip gtest tests.
+  - key: readability-identifier-naming.ClassIgnoredRegexp
+    value: '^DISABLED_([A-Z][a-z]+)+$'
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumCase
+    value: CamelCase
+  - key: readability-identifier-naming.UnionCase
+    value: CamelCase
+  - key: readability-identifier-naming.MemberCase
+    value: lower_case
+  - key: readability-identifier-naming.PrivateMemberSuffix
+    value: '_'
+  - key: readability-identifier-naming.ProtectedMemberSuffix
+    value: '_'
+  - key: readability-identifier-naming.MethodCase
+    value: CamelCase
+  - key: readability-identifier-naming.PublicMethodIgnoredRegexp
+    value: "(begin|end|empty|size|ysize|front|back|parse|format)"
+  - key: readability-identifier-naming.FunctionCase
+    value: CamelCase
+  - key: readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key: readability-identifier-naming.ParameterPackCase
+    value: lower_case
+  # - key: readability-identifier-naming.VariableCase
+  #   value: lower_case
+  # - key: readability-identifier-naming.ConstexprVariableCase
+  #   value: CamelCase
+  # - key: readability-identifier-naming.ConstexprVariablePrefix
+  #   value: k
+  # - key: readability-identifier-naming.GlobalVariableCase
+  #   value: CamelCase
+  # - key: readability-identifier-naming.GlobalVariablePrefix
+  #   value: k
+  # - key: readability-identifier-naming.StaticVariableCase
+  #   value: CamelCase
+  # - key: readability-identifier-naming.StaticVariablePrefix
+  #   value: k
+  - key: readability-identifier-naming.MacroDefinitionCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.NamespaceCase
+    value: lower_case
+  # Allow NCamelCase for NMonitoring.
+  - key: readability-identifier-naming.NamespaceIgnoredRegexp
+    value: ^N([A-Z][a-z]+)+$
+  # Allow kCamelCase.
+  - key: readability-identifier-naming.ValueTemplateParameterIgnoredRegexp
+    value: ^k([A-Z][a-z]+)+$
+  - key: readability-identifier-naming.ConceptCase
+    value: CamelCase
+  - key: readability-identifier-naming.TemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.TemplateTemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.TypedefCase
+    value: CamelCase
+  - key: readability-identifier-naming.TypeTemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.ValueTemplateParameterCase
+    value: CamelCase
diff --git a/.github/workflows/alpine.yml b/.github/workflows/alpine.yml
index 1a349ef7037b..55cf16f71a8f 100644
--- a/.github/workflows/alpine.yml
+++ b/.github/workflows/alpine.yml
@@ -22,7 +22,7 @@ jobs:
         strategy:
             fail-fast: false
 
-        name: ubuntu-24.04 (build-only)
+        name: alpine (build-only)
         runs-on: ubuntu-24.04
 
         env:
@@ -46,7 +46,7 @@ jobs:
                 -DUSERVER_FORCE_DOWNLOAD_GRPC=1
 
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
             with:
                 fetch-depth: 0
 
diff --git a/.github/workflows/archlinux.yml b/.github/workflows/archlinux.yml
new file mode 100644
index 000000000000..542f88087a1d
--- /dev/null
+++ b/.github/workflows/archlinux.yml
@@ -0,0 +1,156 @@
+name: Arch
+
+'on':
+    pull_request:
+    push:
+        branches:
+          - master
+          - develop
+          - feature/**
+
+env:
+    UBSAN_OPTIONS: print_stacktrace=1
+    ASAN_OPTIONS: detect_odr_violation=2
+    CXX: clang++
+    CC: clang
+    CCACHE_DIR: /home/runner/.cache/ccache
+    CCACHE_NOHASHDIR: true
+    CPM_SOURCE_CACHE: /home/runner/.cache/CPM
+
+jobs:
+    archlinux:
+        strategy:
+            fail-fast: false
+
+        name: archlinux-latest
+        runs-on: ubuntu-latest
+        container:
+            image: archlinux:latest
+
+        env:
+            CMAKE_FLAGS: >-
+                -DCMAKE_BUILD_TYPE=Debug
+                -DCMAKE_CXX_STANDARD=17
+                -DUSERVER_USE_LD=lld
+                -DUSERVER_NO_WERROR=1
+                -DUSERVER_BUILD_ALL_COMPONENTS=1
+                -DUSERVER_BUILD_SAMPLES=1
+                -DUSERVER_BUILD_TESTS=1
+                -DUSERVER_FEATURE_GRPC=0
+                -DUSERVER_FEATURE_GRPC_REFLECTION=0
+                -DUSERVER_FEATURE_GRPC_PROTOVALIDATE=0
+                -DUSERVER_FEATURE_MONGODB=0
+                -DUSERVER_FEATURE_OTLP=0
+                -DUSERVER_FEATURE_ROCKS=0
+                -DUSERVER_USE_STATIC_LIBS=0
+                -DUSERVER_FEATURE_PATCH_LIBPQ=0
+
+        steps:
+          - uses: actions/checkout@v4
+            with:
+                fetch-depth: 0
+
+          - name: Restore cached directories
+            id: restore-cache
+            uses: actions/cache/restore@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: 'archlinux-cache-dir ${{github.ref}} run-${{github.run_number}}'
+                restore-keys: |
+                    archlinux-cache-dir ${{github.ref}}
+                    archlinux-cache-dir
+
+          - name: Setup host cache dirs
+            run: |
+                mkdir -p ${{env.CCACHE_DIR}}
+                mkdir -p ${{env.CPM_SOURCE_CACHE}}
+
+          - name: Update system and install base dependencies
+            run: |
+                pacman -Syu --noconfirm
+                pacman -S --needed --noconfirm \
+                    base-devel \
+                    git \
+                    cmake \
+                    make \
+                    clang \
+                    lld \
+                    ccache \
+                    python \
+                    pkg-config
+
+          - name: Install development dependencies
+            run: |
+                useradd build
+
+                pacman -S --needed --noconfirm $(cat scripts/docs/en/deps/arch.md | grep -v -- 'makepkg|' )
+                set -x ; \
+                cat scripts/docs/en/deps/arch.md | grep -oP '^makepkg\|\K.*' | while read REPLY; \
+                do \
+                  DIR=$(mktemp -d) ;\
+                  git clone --branch $REPLY --single-branch https://github.com/archlinux/aur.git $DIR ;\
+                  pushd $DIR ;\
+
+                  chmod a+x .
+                  chmod a+rw -R .
+
+                  yes | su -s /usr/bin/makepkg - build ;\
+                  pacman -U --noconfirm *.zst
+
+                  popd ;\
+                  rm -rf $DIR ;\
+                done
+
+          - name: Install test dependencies
+            if: ${{ false }}  # Not working yet
+            run: |
+                pacman -S --needed --noconfirm \
+                    postgresql \
+                    redis \
+                    clickhouse \
+                    rabbitmq \
+                    mongodb
+
+          - name: Setup caches
+            run: |
+                echo "Cached CPM packages:"
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}} || true
+                for f in $(find ${{env.CPM_SOURCE_CACHE}} -name "cmake.lock" 2>/dev/null || true);
+                do
+                  repo=$(ls -d $(dirname $f)*/ 2>/dev/null || true);
+                  echo "Repository: $repo";
+                  git config --global --add safe.directory $repo 2>/dev/null || true;
+                done
+
+                ccache -M 2.0GB
+                ccache -s -v
+
+          - name: Run cmake
+            run: |
+                cmake -S . -B build_debug $CMAKE_FLAGS
+
+          - name: Compile
+            run: |
+                cmake --build build_debug -j$(nproc)
+
+          - name: Save cached directories
+            uses: actions/cache/save@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: ${{ steps.restore-cache.outputs.cache-primary-key }}
+
+          - name: Show cache stats
+            run: |
+                du -h -d 1 ${{env.CCACHE_DIR}} || true
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}} || true
+                ccache -s -v
+
+          - name: Run tests
+            if: ${{ false }}  # Not working yet
+            run: |
+                cd build_debug
+                ctest -V
diff --git a/.github/workflows/ci-conan.yml b/.github/workflows/ci-conan.yml
index 121cb20bc950..2da1bcf62a96 100644
--- a/.github/workflows/ci-conan.yml
+++ b/.github/workflows/ci-conan.yml
@@ -14,7 +14,8 @@ env:
 jobs:
     build:
         runs-on: ${{ matrix.os }}
-        name: ${{ matrix.os }}
+        container: ${{ matrix.container }}
+        name: "${{ matrix.os }} (container: ${{ matrix.container || 'GithubCI' }})"
         strategy:
             fail-fast: false
             matrix:
@@ -22,53 +23,74 @@ jobs:
                   - os: ubuntu-22.04
                     conanflags: ''
                     tests-env: 'JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64'
-                  - os: macos-latest
+                  - os: ubuntu-22.04
+                    container: ubuntu:22.04
+                    conanflags: ''
+                    tests-env: 'JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64'
+                  - os: macos-14
                     conanflags: '-o python_path=python3.11'
                     tests-env: ''
 
         steps:
-          - name: Checkout
-            uses: actions/checkout@v4
+          - name: Install sudo
+            if: matrix.container == 'ubuntu:22.04'
+            run: |
+                DEBIAN_FRONTEND=noninteractive apt update
+                DEBIAN_FRONTEND=noninteractive apt install -y sudo
 
           - name: Install Ubuntu packages
             if: matrix.os == 'ubuntu-22.04'
             run: |
-                sudo apt update
-                sudo apt install -y \
-                   gcc g++ cmake wget git clang-format \
+                sudo DEBIAN_FRONTEND=noninteractive apt update
+                sudo DEBIAN_FRONTEND=noninteractive apt install -y \
+                   libpq-dev \
+                   gcc g++ cmake git clang-format \
                    python3 python3-pip python3-venv
 
-          - name: Install test dependencies
-            if: matrix.os == 'ubuntu-22.04'
-            run: |
-                wget -qO- https://pgp.mongodb.com/server-7.0.asc | sudo gpg --dearmor | sudo tee /usr/share/keyrings/mongodb-server-7.0.gpg >/dev/null
-                echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" \
-                      | sudo tee -a /etc/apt/sources.list.d/mongodb-org-7.0.list
-
-                sudo apt update
-                sudo apt install -y postgresql redis mongodb-org mongodb-mongosh
-                sudo ./scripts/kafka/ubuntu_install_kafka.sh
-
-                ./scripts/rabbitmq/ubuntu_install_rabbitmq_server.sh
-
           - name: Install MacOS packages
-            if: matrix.os == 'macos-latest'
+            if: matrix.os == 'macos-14'
             run: |
                 brew update
                 brew tap mongodb/brew
                 brew install clang-format postgresql redis kafka rabbitmq mongodb-community
                 brew install python@3.11
 
+          - name: Checkout
+            uses: actions/checkout@v5
+
+          - name: Change permissions
+            if: matrix.container == 'ubuntu:22.04'
+            run: |
+                useradd -m -G sudo -s /bin/bash test-user
+                chown -R test-user .
+
           - name: Install common packages
             run: |
                 pip install "conan==2.8.0"
                 pip install numpy
-                conan profile detect
-                conan profile show
+                ${{ matrix.container && 'sudo -u test-user' }} conan profile detect
+                ${{ matrix.container && 'sudo -u test-user' }} conan profile show
 
           - name: Run conan
             run: |
-                conan create . --build=missing -s:a compiler.cppstd=17 -pr:b=default ${{matrix.conanflags}}
+                ${{ matrix.container && 'sudo -u test-user' }} git config --global --add safe.directory `pwd`
+                ${{ matrix.container && 'sudo -u test-user' }} conan create . --build=missing -s:a compiler.cppstd=17 -pr:b=default ${{matrix.conanflags}}
+
+          - name: Install test dependencies
+            if: matrix.os == 'ubuntu-22.04'
+            run: |
+                sudo DEBIAN_FRONTEND=noninteractive apt install -y curl wget lsb-release
+
+                wget -qO- https://pgp.mongodb.com/server-7.0.asc | sudo gpg --dearmor | sudo tee /usr/share/keyrings/mongodb-server-7.0.gpg >/dev/null
+                echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" \
+                      | sudo tee -a /etc/apt/sources.list.d/mongodb-org-7.0.list
+
+                sudo DEBIAN_FRONTEND=noninteractive apt update
+                sudo DEBIAN_FRONTEND=noninteractive apt install -y postgresql redis mongodb-org mongodb-mongosh locales
+                ${{ matrix.container && 'sudo locale-gen en_US.UTF-8' }}
+                ${{ matrix.container && 'update-locale LC_ALL="en_US.UTF-8" LANG="en_US.UTF-8" LANGUAGE="en_US.UTF-8"' }}
+                sudo ./scripts/kafka/ubuntu_install_kafka.sh
+                sudo ./scripts/rabbitmq/ubuntu_install_rabbitmq_server.sh
 
           - name: Test userver conan package
             run: |-
@@ -77,7 +99,7 @@ jobs:
                 rm -rf userver/cmake/
                 cd samples/
 
-                USERVER_VERSION=$(conan list -c -v quiet userver/* | tail -n 1)
+                USERVER_VERSION=$(${{ matrix.container && 'sudo -u test-user' }} conan list -c -v quiet userver/* | tail -n 1)
                 for SAMPLE in \
                     3_json \
                     chaotic_service \
@@ -88,12 +110,13 @@ jobs:
                     https_service \
                     postgres_service \
                     redis_service \
-                    kafka_service \
+                    ${{ matrix.container && ' ' || 'kafka_service' }} \
                     rabbitmq_service \
                     mongo_service \
                     s3api \
                 ; do
                     mv conanfile.py $SAMPLE/
-                    ${{matrix.tests-env}} conan test $SAMPLE/ --build=never -s:a compiler.cppstd=17 -pr:b=default ${{matrix.conanflags}} ${USERVER_VERSION}
+                    echo "Run: ${{ matrix.container && 'sudo -u test-user' }} ${{matrix.tests-env}} conan test $SAMPLE/ --build=never -s:a compiler.cppstd=17 -pr:b=default ${{matrix.conanflags}} ${USERVER_VERSION}"
+                    ${{ matrix.container && 'sudo -u test-user' }} ${{matrix.tests-env}} conan test $SAMPLE/ --build=never -s:a compiler.cppstd=17 -pr:b=default ${{matrix.conanflags}} ${USERVER_VERSION}
                     mv $SAMPLE/conanfile.py ./
                 done
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b107f2e6e457..1b105c342137 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -104,7 +104,7 @@ jobs:
         runs-on: ${{matrix.os}}
 
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
 
           - name: Restore cached directories
             id: restore-cache
@@ -155,11 +155,11 @@ jobs:
                 sudo apt update
                 # Instructions from https://clickhouse.com/docs/en/getting-started/install/
                 sudo apt install -y apt-transport-https ca-certificates dirmngr
-                sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 8919F6BD2B48D754
-                echo "deb https://packages.clickhouse.com/deb stable main" | sudo tee /etc/apt/sources.list.d/clickhouse.list
+                curl -fsSL 'https://packages.clickhouse.com/rpm/lts/repodata/repomd.xml.key' | sudo gpg --dearmor -o /usr/share/keyrings/clickhouse-keyring.gpg
+                echo "deb [signed-by=/usr/share/keyrings/clickhouse-keyring.gpg arch=amd64] https://packages.clickhouse.com/deb stable main" | sudo tee /etc/apt/sources.list.d/clickhouse.list
 
                 # Adding mariadb repositories (from https://www.linuxcapable.com/how-to-install-mariadb-on-ubuntu-linux/ )
-                curl -fsSL http://mirror.mariadb.org/PublicKey_v2 | sudo gpg --dearmor -o "/usr/share/keyrings/mariadb.gpg"
+                curl -fsSL https://mariadb.org/mariadb_release_signing_key.pgp | sudo gpg --dearmor -o "/usr/share/keyrings/mariadb.gpg"
                 sudo chmod a+r "/usr/share/keyrings/mariadb.gpg"
                 # Restore the correct URL after https://jira.mariadb.org/browse/MDBF-651
                 #echo "deb [arch=amd64,arm64,ppc64el signed-by=/usr/share/keyrings/mariadb.gpg] https://deb.mariadb.org/10.11/ubuntu $(lsb_release -cs) main" \
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 77d320b9e07a..85bcb25e4f90 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -25,7 +25,7 @@ jobs:
 
         steps:
           - name: Checkout repository
-            uses: actions/checkout@v4
+            uses: actions/checkout@v5
 
           - name: Initialize CodeQL
             uses: github/codeql-action/init@v3
diff --git a/.github/workflows/debian.yml b/.github/workflows/debian.yml
new file mode 100644
index 000000000000..c7ee25d3b4c3
--- /dev/null
+++ b/.github/workflows/debian.yml
@@ -0,0 +1,161 @@
+name: Debian
+
+'on':
+    pull_request:
+    push:
+        branches:
+          - master
+          - develop
+          - feature/**
+
+env:
+    UBSAN_OPTIONS: print_stacktrace=1
+    ASAN_OPTIONS: detect_odr_violation=2
+    CCACHE_DIR: /home/runner/.cache/ccache
+    CCACHE_NOHASHDIR: true
+    CPM_SOURCE_CACHE: /home/runner/.cache/CPM
+
+jobs:
+    debian:
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                  # TODO: debian-11 fails to compile core
+                  #
+                  # - cmake-flags: >-
+                  #     -DUSERVER_FORCE_DOWNLOAD_GTEST=ON
+                  #     -DCMAKE_CC_COMPILER=clang-11
+                  #     -DCMAKE_CXX_COMPILER=clang++-11
+                  #   image: debian:11
+                  #   info: Debian 11
+                  #   deps-file: debian-11.md
+
+                  - cmake-flags: >-
+                        -DCMAKE_CC_COMPILER=clang-14
+                        -DCMAKE_CXX_COMPILER=clang++-14
+                    image: debian:12
+                    info: Debian 12
+                    deps-file: debian-12.md
+
+                  # TODO: fails with:
+                  # 1)  ld.lld: error: undefined symbol: icudt76_dat
+                  #      >>> referenced by udata.ao:(openCommonData(char const*, int, UErrorCode*)) in archive /usr/lib/x86_64-linux-gnu/libicuuc.a
+                  # 2) userver/userver/universal/src/decimal64/decimal64_test.cpp:29:47: error: passing no argument for the '...' parameter of a variadic macro is a C++20 extension [-Werror,-Wc++20-extensions]
+                  #    TYPED_TEST_SUITE(Decimal64Round, RoundPolicies);
+                  # - cmake-flags: >-
+                  #     -DCMAKE_CC_COMPILER=clang-19
+                  #     -DCMAKE_CXX_COMPILER=clang++-19
+                  #     -DUSERVER_FEATURE_GRPC=OFF
+                  #     -DUSERVER_FEATURE_OTLP=OFF
+                  #     -DUSERVER_FEATURE_GRPC_REFLECTION=OFF
+                  #     -DUSERVER_FORCE_DOWNLOAD_RE2=ON
+                  #   image: debian:13
+                  #   info: Debian 13
+                  #   deps-file: debian-13.md
+
+        name: '${{ matrix.info }}'
+        runs-on: ubuntu-latest
+        container: ${{ matrix.image }}
+
+        env:
+            CMAKE_FLAGS: >-
+                -DCMAKE_BUILD_TYPE=Debug
+                -DCMAKE_CXX_STANDARD=17
+                -DUSERVER_USE_LD=lld
+                -DUSERVER_NO_WERROR=OFF
+                -DUSERVER_BUILD_ALL_COMPONENTS=1
+                -DUSERVER_BUILD_SAMPLES=1
+                -DUSERVER_BUILD_TESTS=1
+                -DUSERVER_FEATURE_JEMALLOC=OFF
+                -DUSERVER_FEATURE_KAFKA=OFF
+                -DUSERVER_FEATURE_CLICKHOUSE=OFF
+                -DUSERVER_FEATURE_STACKTRACE=OFF
+                -DUSERVER_FEATURE_PATCH_LIBPQ=OFF
+                -DUSERVER_DISABLE_RSEQ_ACCELERATION=YES
+                -DUSERVER_CHAOTIC_FORMAT=OFF
+                -DUSERVER_CHAOTIC_GOLDEN_TESTS=OFF
+
+        steps:
+          - uses: actions/checkout@v4
+            with:
+                fetch-depth: 0
+
+          - name: Restore cached directories
+            id: restore-cache
+            uses: actions/cache/restore@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: 'debian-cache-dir ${{matrix.image}} ${{github.ref}} run-${{github.run_number}}'
+                restore-keys: |
+                    debian-cache-dir ${{github.ref}}
+                    debian-cache-dir
+
+          - name: Setup host cache dirs
+            run: |
+                mkdir -p ${{env.CCACHE_DIR}}
+                mkdir -p ${{env.CPM_SOURCE_CACHE}}
+
+          - name: Install dependencies
+            run: |
+                apt-get update
+                apt-get install -y lsb-release wget gnupg
+
+                # Install clang and lld
+                apt-get install -y clang lld
+
+                # Install project dependencies
+                apt-get install -y $(cat scripts/docs/en/deps/${{ matrix.deps-file }})
+
+          - name: Install test dependencies
+            if: ${{ false }}
+            run: |
+                apt-get install -y postgresql-15 \
+                                   redis-server \
+                                   rabbitmq-server
+
+          - name: Setup caches
+            run: |
+                echo "Cached CPM packages:"
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}} || true
+                for f in $(find ${{env.CPM_SOURCE_CACHE}} -name "cmake.lock" 2>/dev/null || true);
+                do
+                  repo=$(ls -d $(dirname $f)/*/ 2>/dev/null || true);
+                  if [ -n "$repo" ]; then
+                    echo "Repository: $repo";
+                    git config --global --add safe.directory $repo;
+                  fi
+                done
+
+                ccache -M 2.0GB
+                ccache -s
+
+          - name: Run cmake
+            run: |
+                cmake -S . -B build_debug $CMAKE_FLAGS ${{ matrix.cmake-flags }}
+
+          - name: Compile
+            run: |
+                cmake --build build_debug --parallel $(nproc)
+
+          - name: Save cached directories
+            uses: actions/cache/save@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: ${{ steps.restore-cache.outputs.cache-primary-key }}
+
+          - name: Show cache stats
+            run: |
+                du -h -d 1 ${{env.CCACHE_DIR}} || true
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}} || true
+                ccache -s -v
+
+          - name: Run tests
+            if: ${{ false }}
+            run: |
+                cd build_debug
+                ctest -V
diff --git a/.github/workflows/docker.yaml b/.github/workflows/docker.yaml
index 6ca9ef00018b..0af95fa6075b 100644
--- a/.github/workflows/docker.yaml
+++ b/.github/workflows/docker.yaml
@@ -88,7 +88,7 @@ jobs:
         runs-on: ubuntu-latest
         name: '${{ matrix.info }}'
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
 
           - name: Install packages
             run: |
diff --git a/.github/workflows/fedora.yml b/.github/workflows/fedora.yml
new file mode 100644
index 000000000000..4ef31fbc4876
--- /dev/null
+++ b/.github/workflows/fedora.yml
@@ -0,0 +1,136 @@
+name: Fedora
+
+'on':
+    pull_request:
+    push:
+        branches:
+          - master
+          - develop
+          - feature/**
+
+env:
+    UBSAN_OPTIONS: print_stacktrace=1
+    ASAN_OPTIONS: detect_odr_violation=2
+    CXX: clang++
+    CC: clang
+    CCACHE_DIR: /home/runner/.cache/ccache
+    CCACHE_NOHASHDIR: true
+    CPM_SOURCE_CACHE: /home/runner/.cache/CPM
+
+jobs:
+    fedora:
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                  # - version: 36 EOL
+                  - version: 42
+
+        name: fedora-${{matrix.version}}
+        runs-on: ubuntu-latest
+
+        container:
+            image: fedora:${{matrix.version}}
+
+        env:
+            CMAKE_FLAGS: >-
+                -DCMAKE_BUILD_TYPE=Debug
+                -DCMAKE_CXX_STANDARD=17
+                -DUSERVER_USE_LD=lld
+                -DUSERVER_BUILD_ALL_COMPONENTS=1
+                -DUSERVER_BUILD_SAMPLES=1
+                -DUSERVER_BUILD_TESTS=1
+                -DUSERVER_USE_STATIC_LIBS=OFF
+                -DUSERVER_FEATURE_MONGODB=OFF
+                -DUSERVER_FEATURE_GRPC=OFF
+                -DUSERVER_FEATURE_GRPC_REFLECTION=OFF
+                -DUSERVER_FEATURE_OTLP=OFF
+                -DUSERVER_FEATURE_ROCKS=OFF
+                -DUSERVER_FEATURE_CLICKHOUSE=OFF
+                -DUSERVER_FEATURE_RABBITMQ=OFF
+                -DUSERVER_FEATURE_PATCH_LIBPQ=OFF
+                -DUSERVER_DOWNLOAD_PACKAGES=OFF
+                -DUSERVER_FEATURE_STACKTRACE=OFF
+
+        steps:
+          - uses: actions/checkout@v5
+            with:
+                fetch-depth: 0
+
+          - name: Setup cache directories
+            run: |
+                mkdir -p ${{env.CCACHE_DIR}}
+                mkdir -p ${{env.CPM_SOURCE_CACHE}}
+
+          - name: Restore cached directories
+            id: restore-cache
+            uses: actions/cache/restore@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: 'fedora-cache-dir ${{github.ref}} run-${{github.run_number}}'
+                restore-keys: |
+                    fedora-cache-dir ${{github.ref}}
+                    fedora-cache-dir
+
+          - name: Install dependencies
+            run: |
+                dnf update -y
+                dnf install -y git lld which clang
+                dnf install -y $(cat scripts/docs/en/deps/fedora-${{matrix.version}}.md)
+
+          - name: Install test dependencies
+            if: ${{ false }}  # Not working yet
+            run: |
+                dnf install -y postgresql-server \
+                              redis \
+                              rabbitmq-server
+
+          - name: Setup caches
+            run: |
+                echo "Cached CPM packages:"
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}} || true
+                for f in $(find ${{env.CPM_SOURCE_CACHE}} -name "cmake.lock" 2>/dev/null || true);
+                do
+                  repo=$(ls -d $(dirname $f)/*/ 2>/dev/null || true);
+                  echo "Repository: $repo";
+                  git config --global --add safe.directory $repo;
+                done
+
+                ccache -M 2.0GB
+                ccache -s -v
+
+          - name: Run cmake
+            run: |
+                pwd
+                cmake -S . -B build_debug $CMAKE_FLAGS
+
+          - name: Reconfigure cmake
+            run: |
+                pwd
+                cmake -S . -B build_debug $CMAKE_FLAGS
+
+          - name: Compile
+            run: |
+                cmake --build build_debug -j$(nproc)
+
+          - name: Save cached directories
+            uses: actions/cache/save@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: ${{ steps.restore-cache.outputs.cache-primary-key }}
+
+          - name: Show cache stats
+            run: |
+                du -h -d 1 ${{env.CCACHE_DIR}} || true
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}} || true
+                ccache -s -v
+
+          - name: Run tests
+            if: ${{ false }}  # Not working yet
+            run: |
+                cd build_debug
+                ctest -V
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index 1e7bab22e807..21ec07e3ad80 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -18,7 +18,7 @@ jobs:
         strategy:
             fail-fast: false
 
-        name: macos-latest
+        name: macos-latest (brew)
         runs-on: macos-latest
 
         env:
@@ -38,7 +38,7 @@ jobs:
                 -DUSERVER_FORCE_DOWNLOAD_GRPC=1
 
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
 
           - name: Restore cached directories
             id: restore-cache
@@ -56,10 +56,11 @@ jobs:
             run: |
                 export SDKROOT="`xcrun --show-sdk-path`"
                 brew update
+                brew uninstall cmake
                 brew install $(cat scripts/docs/en/deps/macos.md)
                 brew install clang-format
-                brew install python@3.11
                 brew install lld
+                brew install python@3.12
 
                 brew link postgresql@16 # postgresql is keg-only
                 brew link --force zlib # keg-only + need for static linkage
@@ -83,11 +84,11 @@ jobs:
 
           - name: Run cmake
             run: |
-                cmake -S./ -B./build_debug -DUSERVER_PYTHON_PATH=$(brew --prefix)/bin/python3.11 $CMAKE_FLAGS
+                cmake -S./ -B./build_debug -DUSERVER_PYTHON_PATH=$(brew --prefix)/bin/python3.12 $CMAKE_FLAGS
 
           - name: Reconfigure cmake
             run: |
-                cmake -S./ -B./build_debug -DUSERVER_PYTHON_PATH=$(brew --prefix)/bin/python3.11 $CMAKE_FLAGS
+                cmake -S./ -B./build_debug -DUSERVER_PYTHON_PATH=$(brew --prefix)/bin/python3.12 $CMAKE_FLAGS
 
           - name: Compile
             run: |
diff --git a/.github/workflows/publish-ubuntu-22.04-base-images.yaml b/.github/workflows/publish-ubuntu-22.04-base-images.yaml
index 4a7f2bd0403b..701c6e4a1fe9 100644
--- a/.github/workflows/publish-ubuntu-22.04-base-images.yaml
+++ b/.github/workflows/publish-ubuntu-22.04-base-images.yaml
@@ -17,7 +17,7 @@ jobs:
         env:
             USERVER_IMAGE_TAG: ${{ github.event.release.tag_name || 'latest' }}
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
           - name: Login to GitHub Container Registry
             uses: docker/login-action@v3
             with:
diff --git a/.github/workflows/publish-ubuntu-22.04-images.yaml b/.github/workflows/publish-ubuntu-22.04-images.yaml
index 73fb7ec1a056..04f58d0d8a97 100644
--- a/.github/workflows/publish-ubuntu-22.04-images.yaml
+++ b/.github/workflows/publish-ubuntu-22.04-images.yaml
@@ -17,7 +17,7 @@ jobs:
         env:
             USERVER_IMAGE_TAG: ${{ github.event.release.tag_name || 'latest' }}
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
           - name: Login to GitHub Container Registry
             uses: docker/login-action@v3
             with:
diff --git a/.github/workflows/publish-ubuntu-24.04-images.yaml b/.github/workflows/publish-ubuntu-24.04-images.yaml
index 8697474a042f..7dc026c0f41a 100644
--- a/.github/workflows/publish-ubuntu-24.04-images.yaml
+++ b/.github/workflows/publish-ubuntu-24.04-images.yaml
@@ -17,7 +17,7 @@ jobs:
         env:
             USERVER_IMAGE_TAG: ${{ github.event.release.tag_name || 'latest' }}
         steps:
-          - uses: actions/checkout@v4
+          - uses: actions/checkout@v5
           - name: Login to GitHub Container Registry
             uses: docker/login-action@v3
             with:
diff --git a/.github/workflows/ubuntu-minimal.yml b/.github/workflows/ubuntu-minimal.yml
new file mode 100644
index 000000000000..449963127c58
--- /dev/null
+++ b/.github/workflows/ubuntu-minimal.yml
@@ -0,0 +1,108 @@
+name: Ubuntu
+
+'on':
+    pull_request:
+    push:
+        branches:
+          - master
+          - develop
+          - feature/**
+
+env:
+    JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64
+    UBSAN_OPTIONS: print_stacktrace=1
+    ASAN_OPTIONS: detect_odr_violation=2
+    CCACHE_DIR: /home/runner/.cache/ccache
+    CCACHE_NOHASHDIR: true
+    CPM_SOURCE_CACHE: /home/runner/.cache/CPM
+    REDIS_SLEEP_WORKAROUND_SECONDS: 60
+
+jobs:
+    posix:
+        strategy:
+            fail-fast: false
+        env:
+            CMAKE_FLAGS: >-
+                -DCMAKE_BUILD_TYPE=Debug
+                -DCMAKE_CXX_STANDARD=17
+                -DUSERVER_SANITIZE="ub addr"
+                -DUSERVER_BUILD_SAMPLES=1
+                -DUSERVER_BUILD_TESTS=1
+
+        name: ubuntu (minimal installation)
+        runs-on: ubuntu-latest
+
+        steps:
+          - uses: actions/checkout@v4
+
+          - name: Restore cached directories
+            id: restore-cache
+            uses: actions/cache/restore@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: 'ubuntu-cache-dir ${{matrix.id}} ${{github.ref}} run-${{github.run_number}}'
+                restore-keys: |
+                    ubuntu-cache-dir ${{matrix.id}} ${{github.ref}}
+                    ubuntu-cache-dir ${{matrix.id}}
+
+          - name: Setup ramdrive for testsuites
+            run: |
+                sudo mkdir -p "/mnt/ramdisk/$USER"
+                sudo chmod 777 "/mnt/ramdisk/$USER"
+                sudo mount -t tmpfs -o size=2048M tmpfs "/mnt/ramdisk/$USER"
+
+          - name: Free disk space
+            run: |
+                df -h
+                # See https://stackoverflow.com/questions/75536771/github-runner-out-of-disk-space-after-building-docker-image
+                sudo rm -rf /usr/share/dotnet /usr/local/lib/android /usr/lib/php* /opt/ghc \
+                    /usr/local/share/powershell /usr/share/swift /usr/local/.ghcup \
+                    /opt/hostedtoolcache/CodeQL || true
+                sudo docker image prune --all --force
+                df -h
+
+          - name: Install common deps
+            run: |
+                sudo apt update
+                sudo apt install build-essential clang cmake ccache libjemalloc-dev
+                sudo apt install \
+                  libssl-dev \
+                  libboost-context1.83-dev \
+                  libboost-coroutine1.83-dev \
+                  libboost-filesystem1.83-dev \
+                  libboost-iostreams1.83-dev \
+                  libboost-locale1.83-dev \
+                  libboost-program-options1.83-dev \
+                  libboost-stacktrace1.83-dev \
+                  libbenchmark-dev
+
+          - name: Setup ccache
+            run: |
+                ccache -M 2.0GB
+                ccache -s -v
+
+          - name: Run cmake
+            run: |
+                cmake -S . -B build_debug
+
+          - name: Compile
+            run: |
+                pwd
+                cd build_debug
+                cmake --build . -j $(nproc)
+
+          - name: Save cached directories
+            uses: actions/cache/save@v4
+            with:
+                path: |
+                    ${{env.CCACHE_DIR}}
+                    ${{env.CPM_SOURCE_CACHE}}
+                key: ${{ steps.restore-cache.outputs.cache-primary-key }}
+
+          - name: Show cache stats
+            run: |
+                du -h -d 1 ${{env.CCACHE_DIR}}
+                du -h -d 1 ${{env.CPM_SOURCE_CACHE}}
+                ccache -s -v
diff --git a/.gitignore b/.gitignore
index ac32cfefe46c..a509f672dd89 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,3 +22,5 @@ static-analyzer-report
 .clangd
 .vscode
 scripts/docs/en/dynamic_configs
+scripts/docs/en/versions.md
+scripts/docs/scripts/versions.js
diff --git a/.mapping.json b/.mapping.json
index 6ad8348b6e82..ff9450d10596 100644
--- a/.mapping.json
+++ b/.mapping.json
@@ -11,14 +11,18 @@
   ".github/docker-compose.yml":"taxi/uservices/userver/.github/docker-compose.yml",
   ".github/pull_request_template.md":"taxi/uservices/userver/.github/pull_request_template.md",
   ".github/workflows/alpine.yml":"taxi/uservices/userver/.github/workflows/alpine.yml",
+  ".github/workflows/archlinux.yml":"taxi/uservices/userver/.github/workflows/archlinux.yml",
   ".github/workflows/ci-conan.yml":"taxi/uservices/userver/.github/workflows/ci-conan.yml",
   ".github/workflows/ci.yml":"taxi/uservices/userver/.github/workflows/ci.yml",
   ".github/workflows/codeql-analysis.yml":"taxi/uservices/userver/.github/workflows/codeql-analysis.yml",
+  ".github/workflows/debian.yml":"taxi/uservices/userver/.github/workflows/debian.yml",
   ".github/workflows/docker.yaml":"taxi/uservices/userver/.github/workflows/docker.yaml",
+  ".github/workflows/fedora.yml":"taxi/uservices/userver/.github/workflows/fedora.yml",
   ".github/workflows/macos.yml":"taxi/uservices/userver/.github/workflows/macos.yml",
   ".github/workflows/publish-ubuntu-22.04-base-images.yaml":"taxi/uservices/userver/.github/workflows/publish-ubuntu-22.04-base-images.yaml",
   ".github/workflows/publish-ubuntu-22.04-images.yaml":"taxi/uservices/userver/.github/workflows/publish-ubuntu-22.04-images.yaml",
   ".github/workflows/publish-ubuntu-24.04-images.yaml":"taxi/uservices/userver/.github/workflows/publish-ubuntu-24.04-images.yaml",
+  ".github/workflows/ubuntu-minimal.yml":"taxi/uservices/userver/.github/workflows/ubuntu-minimal.yml",
   ".gitignore":"taxi/uservices/userver/.gitignore",
   "AUTHORS":"taxi/uservices/userver/AUTHORS",
   "CMakeLists.txt":"taxi/uservices/userver/CMakeLists.txt",
@@ -36,6 +40,7 @@
   "chaotic-openapi/chaotic_openapi/__init__.py":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/__init__.py",
   "chaotic-openapi/chaotic_openapi/back/__init__.py":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/back/__init__.py",
   "chaotic-openapi/chaotic_openapi/back/cpp_client/__init__.py":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/back/cpp_client/__init__.py",
+  "chaotic-openapi/chaotic_openapi/back/cpp_client/middleware.py":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/back/cpp_client/middleware.py",
   "chaotic-openapi/chaotic_openapi/back/cpp_client/output.py":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/back/cpp_client/output.py",
   "chaotic-openapi/chaotic_openapi/back/cpp_client/renderer.py":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/back/cpp_client/renderer.py",
   "chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client.cpp.jinja":"taxi/uservices/userver/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client.cpp.jinja",
@@ -105,9 +110,15 @@
   "chaotic-openapi/include/userver/chaotic/openapi/parameters_read.hpp":"taxi/uservices/userver/chaotic-openapi/include/userver/chaotic/openapi/parameters_read.hpp",
   "chaotic-openapi/include/userver/chaotic/openapi/parameters_write.hpp":"taxi/uservices/userver/chaotic-openapi/include/userver/chaotic/openapi/parameters_write.hpp",
   "chaotic-openapi/integration_tests/CMakeLists.txt":"taxi/uservices/userver/chaotic-openapi/integration_tests/CMakeLists.txt",
+  "chaotic-openapi/integration_tests/clients/body-with-array/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/body-with-array/openapi.yaml",
+  "chaotic-openapi/integration_tests/clients/empty-openapi/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/empty-openapi/openapi.yaml",
   "chaotic-openapi/integration_tests/clients/external-refs/one.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/external-refs/one.yaml",
   "chaotic-openapi/integration_tests/clients/external-refs/two.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/external-refs/two.yaml",
+  "chaotic-openapi/integration_tests/clients/handler-tag/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/handler-tag/openapi.yaml",
   "chaotic-openapi/integration_tests/clients/multiple-content-types/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/multiple-content-types/openapi.yaml",
+  "chaotic-openapi/integration_tests/clients/non-alphanum/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/non-alphanum/openapi.yaml",
+  "chaotic-openapi/integration_tests/clients/operation/non_std_type_reason.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/operation/non_std_type_reason.yaml",
+  "chaotic-openapi/integration_tests/clients/operation/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/operation/openapi.yaml",
   "chaotic-openapi/integration_tests/clients/parameters/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/parameters/openapi.yaml",
   "chaotic-openapi/integration_tests/clients/response-headers/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/response-headers/openapi.yaml",
   "chaotic-openapi/integration_tests/clients/swagger/swagger.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/swagger/swagger.yaml",
@@ -115,6 +126,8 @@
   "chaotic-openapi/integration_tests/clients/test-middleware/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/test-middleware/openapi.yaml",
   "chaotic-openapi/integration_tests/clients/test-object/openapi.yaml":"taxi/uservices/userver/chaotic-openapi/integration_tests/clients/test-object/openapi.yaml",
   "chaotic-openapi/integration_tests/src/middleware_test.cpp":"taxi/uservices/userver/chaotic-openapi/integration_tests/src/middleware_test.cpp",
+  "chaotic-openapi/integration_tests/src/operation_test.cpp":"taxi/uservices/userver/chaotic-openapi/integration_tests/src/operation_test.cpp",
+  "chaotic-openapi/integration_tests/src/parameters_test.cpp":"taxi/uservices/userver/chaotic-openapi/integration_tests/src/parameters_test.cpp",
   "chaotic-openapi/integration_tests/src/requests_test.cpp":"taxi/uservices/userver/chaotic-openapi/integration_tests/src/requests_test.cpp",
   "chaotic-openapi/integration_tests/src/responses_test.cpp":"taxi/uservices/userver/chaotic-openapi/integration_tests/src/responses_test.cpp",
   "chaotic-openapi/integration_tests/src/struct_test.cpp":"taxi/uservices/userver/chaotic-openapi/integration_tests/src/struct_test.cpp",
@@ -180,6 +193,7 @@
   "chaotic/chaotic/error.py":"taxi/uservices/userver/chaotic/chaotic/error.py",
   "chaotic/chaotic/front/__init__.py":"taxi/uservices/userver/chaotic/chaotic/front/__init__.py",
   "chaotic/chaotic/front/parser.py":"taxi/uservices/userver/chaotic/chaotic/front/parser.py",
+  "chaotic/chaotic/front/ref.py":"taxi/uservices/userver/chaotic/chaotic/front/ref.py",
   "chaotic/chaotic/front/ref_resolver.py":"taxi/uservices/userver/chaotic/chaotic/front/ref_resolver.py",
   "chaotic/chaotic/front/types.py":"taxi/uservices/userver/chaotic/chaotic/front/types.py",
   "chaotic/chaotic/jinja_env.py":"taxi/uservices/userver/chaotic/chaotic/jinja_env.py",
@@ -231,6 +245,8 @@
   "chaotic/include/userver/chaotic/io/std/chrono/minutes.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/chrono/minutes.hpp",
   "chaotic/include/userver/chaotic/io/std/chrono/seconds.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/chrono/seconds.hpp",
   "chaotic/include/userver/chaotic/io/std/chrono/years.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/chrono/years.hpp",
+  "chaotic/include/userver/chaotic/io/std/int32_t.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/int32_t.hpp",
+  "chaotic/include/userver/chaotic/io/std/int64_t.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/int64_t.hpp",
   "chaotic/include/userver/chaotic/io/std/map.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/map.hpp",
   "chaotic/include/userver/chaotic/io/std/set.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/set.hpp",
   "chaotic/include/userver/chaotic/io/std/size_t.hpp":"taxi/uservices/userver/chaotic/include/userver/chaotic/io/std/size_t.hpp",
@@ -273,6 +289,7 @@
   "chaotic/integration_tests/schemas/all_of.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/all_of.yaml",
   "chaotic/integration_tests/schemas/array.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/array.yaml",
   "chaotic/integration_tests/schemas/array_of_xcpptype.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/array_of_xcpptype.yaml",
+  "chaotic/integration_tests/schemas/container_format.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/container_format.yaml",
   "chaotic/integration_tests/schemas/custom_cpp_type.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/custom_cpp_type.yaml",
   "chaotic/integration_tests/schemas/date.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/date.yaml",
   "chaotic/integration_tests/schemas/external_ref.yaml":"taxi/uservices/userver/chaotic/integration_tests/schemas/external_ref.yaml",
@@ -486,6 +503,7 @@
   "cmake/Sanitizers.cmake":"taxi/uservices/userver/cmake/Sanitizers.cmake",
   "cmake/SetupAbseil.cmake":"taxi/uservices/userver/cmake/SetupAbseil.cmake",
   "cmake/SetupAmqpCPP.cmake":"taxi/uservices/userver/cmake/SetupAmqpCPP.cmake",
+  "cmake/SetupBoost.cmake":"taxi/uservices/userver/cmake/SetupBoost.cmake",
   "cmake/SetupBrotli.cmake":"taxi/uservices/userver/cmake/SetupBrotli.cmake",
   "cmake/SetupCAres.cmake":"taxi/uservices/userver/cmake/SetupCAres.cmake",
   "cmake/SetupCCTZ.cmake":"taxi/uservices/userver/cmake/SetupCCTZ.cmake",
@@ -502,6 +520,7 @@
   "cmake/SetupLTO.cmake":"taxi/uservices/userver/cmake/SetupLTO.cmake",
   "cmake/SetupLinker.cmake":"taxi/uservices/userver/cmake/SetupLinker.cmake",
   "cmake/SetupMongoDeps.cmake":"taxi/uservices/userver/cmake/SetupMongoDeps.cmake",
+  "cmake/SetupOpenssl.cmake":"taxi/uservices/userver/cmake/SetupOpenssl.cmake",
   "cmake/SetupOpentelemetryProto.cmake":"taxi/uservices/userver/cmake/SetupOpentelemetryProto.cmake",
   "cmake/SetupPGO.cmake":"taxi/uservices/userver/cmake/SetupPGO.cmake",
   "cmake/SetupPostgresqlDeps.cmake":"taxi/uservices/userver/cmake/SetupPostgresqlDeps.cmake",
@@ -526,8 +545,11 @@
   "cmake/UserverSql.cmake":"taxi/uservices/userver/cmake/UserverSql.cmake",
   "cmake/UserverTestsuite.cmake":"taxi/uservices/userver/cmake/UserverTestsuite.cmake",
   "cmake/UserverVenv.cmake":"taxi/uservices/userver/cmake/UserverVenv.cmake",
+  "cmake/abseil_pr_1707.patch":"taxi/uservices/userver/cmake/abseil_pr_1707.patch",
+  "cmake/abseil_pr_1739.patch":"taxi/uservices/userver/cmake/abseil_pr_1739.patch",
   "cmake/embedded_config.cmake":"taxi/uservices/userver/cmake/embedded_config.cmake",
   "cmake/get_cpm.cmake":"taxi/uservices/userver/cmake/get_cpm.cmake",
+  "cmake/grpc_pr_36805.patch":"taxi/uservices/userver/cmake/grpc_pr_36805.patch",
   "cmake/install/Config.cmake.in":"taxi/uservices/userver/cmake/install/Config.cmake.in",
   "cmake/install/userver-chaotic-config.cmake":"taxi/uservices/userver/cmake/install/userver-chaotic-config.cmake",
   "cmake/install/userver-chaotic-openapi-config.cmake":"taxi/uservices/userver/cmake/install/userver-chaotic-openapi-config.cmake",
@@ -588,6 +610,8 @@
   "core/benchmarks/main.cpp":"taxi/uservices/userver/core/benchmarks/main.cpp",
   "core/build_config.hpp.in":"taxi/uservices/userver/core/build_config.hpp.in",
   "core/dynamic_configs/BAGGAGE_SETTINGS.yaml":"taxi/uservices/userver/core/dynamic_configs/BAGGAGE_SETTINGS.yaml",
+  "core/dynamic_configs/EGRESS_HTTP_PROXY_ENABLED.yaml":"taxi/uservices/userver/core/dynamic_configs/EGRESS_HTTP_PROXY_ENABLED.yaml",
+  "core/dynamic_configs/EGRESS_NO_PROXY_TARGETS.yaml":"taxi/uservices/userver/core/dynamic_configs/EGRESS_NO_PROXY_TARGETS.yaml",
   "core/dynamic_configs/HTTP_CLIENT_CONNECTION_POOL_SIZE.yaml":"taxi/uservices/userver/core/dynamic_configs/HTTP_CLIENT_CONNECTION_POOL_SIZE.yaml",
   "core/dynamic_configs/HTTP_CLIENT_CONNECT_THROTTLE.yaml":"taxi/uservices/userver/core/dynamic_configs/HTTP_CLIENT_CONNECT_THROTTLE.yaml",
   "core/dynamic_configs/USERVER_BAGGAGE_ENABLED.yaml":"taxi/uservices/userver/core/dynamic_configs/USERVER_BAGGAGE_ENABLED.yaml",
@@ -725,6 +749,12 @@
   "core/functional_tests/tracing/static_config.yaml":"taxi/uservices/userver/core/functional_tests/tracing/static_config.yaml",
   "core/functional_tests/tracing/tests/conftest.py":"taxi/uservices/userver/core/functional_tests/tracing/tests/conftest.py",
   "core/functional_tests/tracing/tests/test_trace_headers_propagation.py":"taxi/uservices/userver/core/functional_tests/tracing/tests/test_trace_headers_propagation.py",
+  "core/functional_tests/trx_tracker/CMakeLists.txt":"taxi/uservices/userver/core/functional_tests/trx_tracker/CMakeLists.txt",
+  "core/functional_tests/trx_tracker/main.cpp":"taxi/uservices/userver/core/functional_tests/trx_tracker/main.cpp",
+  "core/functional_tests/trx_tracker/src/handler.hpp":"taxi/uservices/userver/core/functional_tests/trx_tracker/src/handler.hpp",
+  "core/functional_tests/trx_tracker/static_config.yaml":"taxi/uservices/userver/core/functional_tests/trx_tracker/static_config.yaml",
+  "core/functional_tests/trx_tracker/tests/conftest.py":"taxi/uservices/userver/core/functional_tests/trx_tracker/tests/conftest.py",
+  "core/functional_tests/trx_tracker/tests/test_ignore_testpoint.py":"taxi/uservices/userver/core/functional_tests/trx_tracker/tests/test_ignore_testpoint.py",
   "core/functional_tests/uctl/CMakeLists.txt":"taxi/uservices/userver/core/functional_tests/uctl/CMakeLists.txt",
   "core/functional_tests/uctl/config_vars.yaml":"taxi/uservices/userver/core/functional_tests/uctl/config_vars.yaml",
   "core/functional_tests/uctl/secure_data.json":"taxi/uservices/userver/core/functional_tests/uctl/secure_data.json",
@@ -1101,6 +1131,7 @@
   "core/include/userver/utils/statistics/system_statistics_collector.hpp":"taxi/uservices/userver/core/include/userver/utils/statistics/system_statistics_collector.hpp",
   "core/include/userver/utils/statistics/writer.hpp":"taxi/uservices/userver/core/include/userver/utils/statistics/writer.hpp",
   "core/include/userver/utils/text.hpp":"taxi/uservices/userver/core/include/userver/utils/text.hpp",
+  "core/include/userver/utils/trx_tracker.hpp":"taxi/uservices/userver/core/include/userver/utils/trx_tracker.hpp",
   "core/include/userver/utils/userver_info.hpp":"taxi/uservices/userver/core/include/userver/utils/userver_info.hpp",
   "core/internal/include/userver/engine/task/task_processor_utils.hpp":"taxi/uservices/userver/core/internal/include/userver/engine/task/task_processor_utils.hpp",
   "core/internal/include/userver/internal/net/net_listener.hpp":"taxi/uservices/userver/core/internal/include/userver/internal/net/net_listener.hpp",
@@ -1560,6 +1591,7 @@
   "core/src/fs/read.cpp":"taxi/uservices/userver/core/src/fs/read.cpp",
   "core/src/fs/read_test.cpp":"taxi/uservices/userver/core/src/fs/read_test.cpp",
   "core/src/fs/temp_file.cpp":"taxi/uservices/userver/core/src/fs/temp_file.cpp",
+  "core/src/fs/temp_file_test.cpp":"taxi/uservices/userver/core/src/fs/temp_file_test.cpp",
   "core/src/fs/write.cpp":"taxi/uservices/userver/core/src/fs/write.cpp",
   "core/src/fs/write_test.cpp":"taxi/uservices/userver/core/src/fs/write_test.cpp",
   "core/src/logging/component.cpp":"taxi/uservices/userver/core/src/logging/component.cpp",
@@ -1957,6 +1989,8 @@
   "core/src/utils/sys_info.hpp":"taxi/uservices/userver/core/src/utils/sys_info.hpp",
   "core/src/utils/text.cpp":"taxi/uservices/userver/core/src/utils/text.cpp",
   "core/src/utils/text_test.cpp":"taxi/uservices/userver/core/src/utils/text_test.cpp",
+  "core/src/utils/trx_tracker.cpp":"taxi/uservices/userver/core/src/utils/trx_tracker.cpp",
+  "core/src/utils/trx_tracker_test.cpp":"taxi/uservices/userver/core/src/utils/trx_tracker_test.cpp",
   "core/src/utils/userver_info.cpp":"taxi/uservices/userver/core/src/utils/userver_info.cpp",
   "core/static_configs/dns_client.yaml":"taxi/uservices/userver/core/static_configs/dns_client.yaml",
   "core/sys_coro/include/coroutines/coroutine.hpp":"taxi/uservices/userver/core/sys_coro/include/coroutines/coroutine.hpp",
@@ -1994,6 +2028,7 @@
   "grpc/benchmarks/format_log_message.cpp":"taxi/uservices/userver/grpc/benchmarks/format_log_message.cpp",
   "grpc/benchmarks/logging.cpp":"taxi/uservices/userver/grpc/benchmarks/logging.cpp",
   "grpc/benchmarks/ya.make":"taxi/uservices/userver/grpc/benchmarks/ya.make",
+  "grpc/dynamic_configs/EGRESS_GRPC_PROXY_ENABLED.yaml":"taxi/uservices/userver/grpc/dynamic_configs/EGRESS_GRPC_PROXY_ENABLED.yaml",
   "grpc/dynamic_configs/USERVER_GRPC_CLIENT_ENABLE_DEADLINE_PROPAGATION.yaml":"taxi/uservices/userver/grpc/dynamic_configs/USERVER_GRPC_CLIENT_ENABLE_DEADLINE_PROPAGATION.yaml",
   "grpc/dynamic_configs/USERVER_GRPC_SERVER_CANCEL_TASK_BY_DEADLINE.yaml":"taxi/uservices/userver/grpc/dynamic_configs/USERVER_GRPC_SERVER_CANCEL_TASK_BY_DEADLINE.yaml",
   "grpc/functional_tests/CMakeLists.txt":"taxi/uservices/userver/grpc/functional_tests/CMakeLists.txt",
@@ -2030,6 +2065,7 @@
   "grpc/functional_tests/basic_chaos/tests-grpcserver/test_network_smaller_parts.py":"taxi/uservices/userver/grpc/functional_tests/basic_chaos/tests-grpcserver/test_network_smaller_parts.py",
   "grpc/functional_tests/basic_chaos/tests-grpcserver/test_server_client_bytes.py":"taxi/uservices/userver/grpc/functional_tests/basic_chaos/tests-grpcserver/test_server_client_bytes.py",
   "grpc/functional_tests/basic_chaos/tests-grpcserver/test_server_smaller_parts.py":"taxi/uservices/userver/grpc/functional_tests/basic_chaos/tests-grpcserver/test_server_smaller_parts.py",
+  "grpc/functional_tests/basic_chaos/tests-grpcserver/test_tracing_metadata.py":"taxi/uservices/userver/grpc/functional_tests/basic_chaos/tests-grpcserver/test_tracing_metadata.py",
   "grpc/functional_tests/basic_server/CMakeLists.txt":"taxi/uservices/userver/grpc/functional_tests/basic_server/CMakeLists.txt",
   "grpc/functional_tests/basic_server/grpc_service.cpp":"taxi/uservices/userver/grpc/functional_tests/basic_server/grpc_service.cpp",
   "grpc/functional_tests/basic_server/proto/samples/greeter.proto":"taxi/uservices/userver/grpc/functional_tests/basic_server/proto/samples/greeter.proto",
@@ -2041,6 +2077,9 @@
   "grpc/functional_tests/basic_server/tests-unix-socket/conftest.py":"taxi/uservices/userver/grpc/functional_tests/basic_server/tests-unix-socket/conftest.py",
   "grpc/functional_tests/basic_server/tests-unix-socket/test_grpc.py":"taxi/uservices/userver/grpc/functional_tests/basic_server/tests-unix-socket/test_grpc.py",
   "grpc/functional_tests/basic_server/tests-unix-socket/test_header_propagation.py":"taxi/uservices/userver/grpc/functional_tests/basic_server/tests-unix-socket/test_header_propagation.py",
+  "grpc/functional_tests/basic_server/unused_proto/CMakeLists.txt":"taxi/uservices/userver/grpc/functional_tests/basic_server/unused_proto/CMakeLists.txt",
+  "grpc/functional_tests/basic_server/unused_proto/proto/samples/unused.proto":"taxi/uservices/userver/grpc/functional_tests/basic_server/unused_proto/proto/samples/unused.proto",
+  "grpc/functional_tests/basic_server/unused_proto/proto/ya.make":"taxi/uservices/userver/grpc/functional_tests/basic_server/unused_proto/proto/ya.make",
   "grpc/functional_tests/lowlevel/CMakeLists.txt":"taxi/uservices/userver/grpc/functional_tests/lowlevel/CMakeLists.txt",
   "grpc/functional_tests/lowlevel/main.cpp":"taxi/uservices/userver/grpc/functional_tests/lowlevel/main.cpp",
   "grpc/functional_tests/lowlevel/proto/samples/greeter.proto":"taxi/uservices/userver/grpc/functional_tests/lowlevel/proto/samples/greeter.proto",
@@ -2121,26 +2160,34 @@
   "grpc/include/userver/ugrpc/client/impl/async_method_invocation.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/async_method_invocation.hpp",
   "grpc/include/userver/ugrpc/client/impl/async_methods.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/async_methods.hpp",
   "grpc/include/userver/ugrpc/client/impl/async_stream_methods.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/async_stream_methods.hpp",
+  "grpc/include/userver/ugrpc/client/impl/async_unary_call_adapter.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/async_unary_call_adapter.hpp",
   "grpc/include/userver/ugrpc/client/impl/call_kind.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/call_kind.hpp",
   "grpc/include/userver/ugrpc/client/impl/call_params.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/call_params.hpp",
   "grpc/include/userver/ugrpc/client/impl/call_state.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/call_state.hpp",
-  "grpc/include/userver/ugrpc/client/impl/channel_arguments_builder.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/channel_arguments_builder.hpp",
+  "grpc/include/userver/ugrpc/client/impl/channel_argument_utils.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/channel_argument_utils.hpp",
   "grpc/include/userver/ugrpc/client/impl/channel_factory.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/channel_factory.hpp",
   "grpc/include/userver/ugrpc/client/impl/client_data.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/client_data.hpp",
+  "grpc/include/userver/ugrpc/client/impl/client_data_accessor.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/client_data_accessor.hpp",
   "grpc/include/userver/ugrpc/client/impl/client_internals.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/client_internals.hpp",
   "grpc/include/userver/ugrpc/client/impl/codegen_declarations.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/codegen_declarations.hpp",
   "grpc/include/userver/ugrpc/client/impl/codegen_definitions.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/codegen_definitions.hpp",
+  "grpc/include/userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp",
   "grpc/include/userver/ugrpc/client/impl/completion_queue_pool.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/completion_queue_pool.hpp",
+  "grpc/include/userver/ugrpc/client/impl/fwd.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/fwd.hpp",
   "grpc/include/userver/ugrpc/client/impl/graceful_stream_finish.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/graceful_stream_finish.hpp",
   "grpc/include/userver/ugrpc/client/impl/middleware_hooks.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/middleware_hooks.hpp",
   "grpc/include/userver/ugrpc/client/impl/middleware_pipeline.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/middleware_pipeline.hpp",
   "grpc/include/userver/ugrpc/client/impl/perform_unary_call.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/perform_unary_call.hpp",
   "grpc/include/userver/ugrpc/client/impl/prepare_call.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/prepare_call.hpp",
+  "grpc/include/userver/ugrpc/client/impl/response_future_impl_base.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/response_future_impl_base.hpp",
+  "grpc/include/userver/ugrpc/client/impl/retry_backoff.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/retry_backoff.hpp",
+  "grpc/include/userver/ugrpc/client/impl/retry_policy.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/retry_policy.hpp",
   "grpc/include/userver/ugrpc/client/impl/rpc.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/rpc.hpp",
   "grpc/include/userver/ugrpc/client/impl/stub_any.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/stub_any.hpp",
   "grpc/include/userver/ugrpc/client/impl/stub_handle.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/stub_handle.hpp",
   "grpc/include/userver/ugrpc/client/impl/stub_pool.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/stub_pool.hpp",
   "grpc/include/userver/ugrpc/client/impl/tracing.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/tracing.hpp",
+  "grpc/include/userver/ugrpc/client/impl/unary_call.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/impl/unary_call.hpp",
   "grpc/include/userver/ugrpc/client/middlewares/baggage/component.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/middlewares/baggage/component.hpp",
   "grpc/include/userver/ugrpc/client/middlewares/baggage/middleware.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/middlewares/baggage/middleware.hpp",
   "grpc/include/userver/ugrpc/client/middlewares/base.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/middlewares/base.hpp",
@@ -2154,6 +2201,7 @@
   "grpc/include/userver/ugrpc/client/middlewares/testsuite/middleware.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/middlewares/testsuite/middleware.hpp",
   "grpc/include/userver/ugrpc/client/qos.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/qos.hpp",
   "grpc/include/userver/ugrpc/client/response_future.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/response_future.hpp",
+  "grpc/include/userver/ugrpc/client/retry_config.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/retry_config.hpp",
   "grpc/include/userver/ugrpc/client/simple_client_component.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/simple_client_component.hpp",
   "grpc/include/userver/ugrpc/client/stream.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/stream.hpp",
   "grpc/include/userver/ugrpc/client/stream_read_future.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/client/stream_read_future.hpp",
@@ -2165,12 +2213,14 @@
   "grpc/include/userver/ugrpc/impl/maybe_owned_string.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/maybe_owned_string.hpp",
   "grpc/include/userver/ugrpc/impl/protobuf_collector.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/protobuf_collector.hpp",
   "grpc/include/userver/ugrpc/impl/queue_runner.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/queue_runner.hpp",
+  "grpc/include/userver/ugrpc/impl/rpc_type.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/rpc_type.hpp",
   "grpc/include/userver/ugrpc/impl/static_service_metadata.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/static_service_metadata.hpp",
   "grpc/include/userver/ugrpc/impl/statistics.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/statistics.hpp",
   "grpc/include/userver/ugrpc/impl/statistics_scope.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/statistics_scope.hpp",
   "grpc/include/userver/ugrpc/impl/statistics_storage.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/statistics_storage.hpp",
   "grpc/include/userver/ugrpc/impl/to_string.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/impl/to_string.hpp",
   "grpc/include/userver/ugrpc/proto_json.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/proto_json.hpp",
+  "grpc/include/userver/ugrpc/protobuf_logging.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/protobuf_logging.hpp",
   "grpc/include/userver/ugrpc/protobuf_visit.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/protobuf_visit.hpp",
   "grpc/include/userver/ugrpc/server/call_context.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/call_context.hpp",
   "grpc/include/userver/ugrpc/server/component_list.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/component_list.hpp",
@@ -2195,6 +2245,7 @@
   "grpc/include/userver/ugrpc/server/impl/stream_adapter.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/impl/stream_adapter.hpp",
   "grpc/include/userver/ugrpc/server/metadata_utils.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/metadata_utils.hpp",
   "grpc/include/userver/ugrpc/server/middlewares/access_log/component.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/middlewares/access_log/component.hpp",
+  "grpc/include/userver/ugrpc/server/middlewares/access_log/log_extra.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/middlewares/access_log/log_extra.hpp",
   "grpc/include/userver/ugrpc/server/middlewares/baggage/component.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/middlewares/baggage/component.hpp",
   "grpc/include/userver/ugrpc/server/middlewares/baggage/middleware.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/middlewares/baggage/middleware.hpp",
   "grpc/include/userver/ugrpc/server/middlewares/base.hpp":"taxi/uservices/userver/grpc/include/userver/ugrpc/server/middlewares/base.hpp",
@@ -2244,24 +2295,25 @@
   "grpc/src/ugrpc/client/exceptions.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/exceptions.cpp",
   "grpc/src/ugrpc/client/generic_client.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/generic_client.cpp",
   "grpc/src/ugrpc/client/impl/async_method_invocation.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/async_method_invocation.cpp",
-  "grpc/src/ugrpc/client/impl/async_methods.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/async_methods.cpp",
   "grpc/src/ugrpc/client/impl/async_stream_methods.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/async_stream_methods.cpp",
   "grpc/src/ugrpc/client/impl/call_options_accessor.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/call_options_accessor.cpp",
   "grpc/src/ugrpc/client/impl/call_options_accessor.hpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/call_options_accessor.hpp",
   "grpc/src/ugrpc/client/impl/call_params.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/call_params.cpp",
   "grpc/src/ugrpc/client/impl/call_state.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/call_state.cpp",
-  "grpc/src/ugrpc/client/impl/channel_arguments_builder.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/channel_arguments_builder.cpp",
+  "grpc/src/ugrpc/client/impl/channel_argument_utils.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/channel_argument_utils.cpp",
   "grpc/src/ugrpc/client/impl/channel_factory.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/channel_factory.cpp",
   "grpc/src/ugrpc/client/impl/client_data.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/client_data.cpp",
   "grpc/src/ugrpc/client/impl/client_factory_config.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/client_factory_config.cpp",
   "grpc/src/ugrpc/client/impl/client_factory_config.hpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/client_factory_config.hpp",
   "grpc/src/ugrpc/client/impl/client_qos.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/client_qos.cpp",
+  "grpc/src/ugrpc/client/impl/compat/channel_arguments_builder.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/compat/channel_arguments_builder.cpp",
+  "grpc/src/ugrpc/client/impl/compat/retry_policy.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/compat/retry_policy.cpp",
+  "grpc/src/ugrpc/client/impl/compat/retry_policy.hpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/compat/retry_policy.hpp",
   "grpc/src/ugrpc/client/impl/completion_queue_pool.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/completion_queue_pool.cpp",
   "grpc/src/ugrpc/client/impl/middleware_hooks.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/middleware_hooks.cpp",
   "grpc/src/ugrpc/client/impl/middleware_pipeline.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/middleware_pipeline.cpp",
+  "grpc/src/ugrpc/client/impl/retry_backoff.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/retry_backoff.cpp",
   "grpc/src/ugrpc/client/impl/retry_policy.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/retry_policy.cpp",
-  "grpc/src/ugrpc/client/impl/retry_policy.hpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/retry_policy.hpp",
-  "grpc/src/ugrpc/client/impl/rpc.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/rpc.cpp",
   "grpc/src/ugrpc/client/impl/stub_handle.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/stub_handle.cpp",
   "grpc/src/ugrpc/client/impl/stub_pool.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/stub_pool.cpp",
   "grpc/src/ugrpc/client/impl/tracing.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/impl/tracing.cpp",
@@ -2278,6 +2330,7 @@
   "grpc/src/ugrpc/client/middlewares/testsuite/component.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/middlewares/testsuite/component.cpp",
   "grpc/src/ugrpc/client/middlewares/testsuite/middleware.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/middlewares/testsuite/middleware.cpp",
   "grpc/src/ugrpc/client/qos.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/qos.cpp",
+  "grpc/src/ugrpc/client/retry_config.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/retry_config.cpp",
   "grpc/src/ugrpc/client/secdist.hpp":"taxi/uservices/userver/grpc/src/ugrpc/client/secdist.hpp",
   "grpc/src/ugrpc/client/simple_client_component.cpp":"taxi/uservices/userver/grpc/src/ugrpc/client/simple_client_component.cpp",
   "grpc/src/ugrpc/datetime_utils.cpp":"taxi/uservices/userver/grpc/src/ugrpc/datetime_utils.cpp",
@@ -2290,8 +2343,6 @@
   "grpc/src/ugrpc/impl/logging.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/logging.cpp",
   "grpc/src/ugrpc/impl/logging.hpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/logging.hpp",
   "grpc/src/ugrpc/impl/protobuf_collector.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/protobuf_collector.cpp",
-  "grpc/src/ugrpc/impl/protobuf_utils.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/protobuf_utils.cpp",
-  "grpc/src/ugrpc/impl/protobuf_utils.hpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/protobuf_utils.hpp",
   "grpc/src/ugrpc/impl/queue_runner.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/queue_runner.cpp",
   "grpc/src/ugrpc/impl/rpc_metadata.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/rpc_metadata.cpp",
   "grpc/src/ugrpc/impl/rpc_metadata.hpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/rpc_metadata.hpp",
@@ -2300,6 +2351,7 @@
   "grpc/src/ugrpc/impl/statistics_scope.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/statistics_scope.cpp",
   "grpc/src/ugrpc/impl/statistics_storage.cpp":"taxi/uservices/userver/grpc/src/ugrpc/impl/statistics_storage.cpp",
   "grpc/src/ugrpc/proto_json.cpp":"taxi/uservices/userver/grpc/src/ugrpc/proto_json.cpp",
+  "grpc/src/ugrpc/protobuf_logging.cpp":"taxi/uservices/userver/grpc/src/ugrpc/protobuf_logging.cpp",
   "grpc/src/ugrpc/protobuf_visit.cpp":"taxi/uservices/userver/grpc/src/ugrpc/protobuf_visit.cpp",
   "grpc/src/ugrpc/server/call_context.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/call_context.cpp",
   "grpc/src/ugrpc/server/component_list.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/component_list.cpp",
@@ -2322,6 +2374,7 @@
   "grpc/src/ugrpc/server/impl/service_worker.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/impl/service_worker.cpp",
   "grpc/src/ugrpc/server/impl/service_worker_impl.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/impl/service_worker_impl.cpp",
   "grpc/src/ugrpc/server/middlewares/access_log/component.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/middlewares/access_log/component.cpp",
+  "grpc/src/ugrpc/server/middlewares/access_log/log_extra.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/middlewares/access_log/log_extra.cpp",
   "grpc/src/ugrpc/server/middlewares/access_log/middleware.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/middlewares/access_log/middleware.cpp",
   "grpc/src/ugrpc/server/middlewares/access_log/middleware.hpp":"taxi/uservices/userver/grpc/src/ugrpc/server/middlewares/access_log/middleware.hpp",
   "grpc/src/ugrpc/server/middlewares/baggage/middleware.cpp":"taxi/uservices/userver/grpc/src/ugrpc/server/middlewares/baggage/middleware.cpp",
@@ -2350,12 +2403,12 @@
   "grpc/tests/baggage_test.cpp":"taxi/uservices/userver/grpc/tests/baggage_test.cpp",
   "grpc/tests/base_test.cpp":"taxi/uservices/userver/grpc/tests/base_test.cpp",
   "grpc/tests/cancel_test.cpp":"taxi/uservices/userver/grpc/tests/cancel_test.cpp",
-  "grpc/tests/channel_arguments_builder_test.cpp":"taxi/uservices/userver/grpc/tests/channel_arguments_builder_test.cpp",
   "grpc/tests/channels_test.cpp":"taxi/uservices/userver/grpc/tests/channels_test.cpp",
   "grpc/tests/client_cancel_test.cpp":"taxi/uservices/userver/grpc/tests/client_cancel_test.cpp",
   "grpc/tests/client_factory_test.cpp":"taxi/uservices/userver/grpc/tests/client_factory_test.cpp",
   "grpc/tests/client_middleware_hooks_test.cpp":"taxi/uservices/userver/grpc/tests/client_middleware_hooks_test.cpp",
   "grpc/tests/client_qos_test.cpp":"taxi/uservices/userver/grpc/tests/client_qos_test.cpp",
+  "grpc/tests/compat/channel_arguments_builder_test.cpp":"taxi/uservices/userver/grpc/tests/compat/channel_arguments_builder_test.cpp",
   "grpc/tests/congestion_control_test.cpp":"taxi/uservices/userver/grpc/tests/congestion_control_test.cpp",
   "grpc/tests/datetime_utils_test.cpp":"taxi/uservices/userver/grpc/tests/datetime_utils_test.cpp",
   "grpc/tests/deadline_metrics_test.cpp":"taxi/uservices/userver/grpc/tests/deadline_metrics_test.cpp",
@@ -2365,8 +2418,10 @@
   "grpc/tests/generic_client_test.cpp":"taxi/uservices/userver/grpc/tests/generic_client_test.cpp",
   "grpc/tests/generic_server_test.cpp":"taxi/uservices/userver/grpc/tests/generic_server_test.cpp",
   "grpc/tests/logging_test.cpp":"taxi/uservices/userver/grpc/tests/logging_test.cpp",
+  "grpc/tests/metadata_test.cpp":"taxi/uservices/userver/grpc/tests/metadata_test.cpp",
   "grpc/tests/proto_json.cpp":"taxi/uservices/userver/grpc/tests/proto_json.cpp",
   "grpc/tests/protobuf_collector_test.cpp":"taxi/uservices/userver/grpc/tests/protobuf_collector_test.cpp",
+  "grpc/tests/protobuf_logging_test.cpp":"taxi/uservices/userver/grpc/tests/protobuf_logging_test.cpp",
   "grpc/tests/protobuf_utils_test.cpp":"taxi/uservices/userver/grpc/tests/protobuf_utils_test.cpp",
   "grpc/tests/protobuf_visit_test.cpp":"taxi/uservices/userver/grpc/tests/protobuf_visit_test.cpp",
   "grpc/tests/retry_test.cpp":"taxi/uservices/userver/grpc/tests/retry_test.cpp",
@@ -2507,6 +2562,10 @@
   "libraries/easy/samples/6_pg_service_template_no_http_with/testsuite/test_basic.py":"taxi/uservices/userver/libraries/easy/samples/6_pg_service_template_no_http_with/testsuite/test_basic.py",
   "libraries/easy/samples/CMakeLists.txt":"taxi/uservices/userver/libraries/easy/samples/CMakeLists.txt",
   "libraries/easy/src/easy.cpp":"taxi/uservices/userver/libraries/easy/src/easy.cpp",
+  "libraries/grpc-proto-structs/include/userver/grpc-proto-structs/client/impl/codegen_declarations.hpp":"taxi/uservices/userver/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/client/impl/codegen_declarations.hpp",
+  "libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/impl/codegen_declarations.hpp":"taxi/uservices/userver/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/impl/codegen_declarations.hpp",
+  "libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/stream.hpp":"taxi/uservices/userver/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/stream.hpp",
+  "libraries/grpc-proto-structs/src/grpc-proto-structs.cpp":"taxi/uservices/userver/libraries/grpc-proto-structs/src/grpc-proto-structs.cpp",
   "libraries/grpc-protovalidate/CMakeLists.txt":"taxi/uservices/userver/libraries/grpc-protovalidate/CMakeLists.txt",
   "libraries/grpc-protovalidate/include/userver/grpc-protovalidate/buf_validate.hpp":"taxi/uservices/userver/libraries/grpc-protovalidate/include/userver/grpc-protovalidate/buf_validate.hpp",
   "libraries/grpc-protovalidate/include/userver/grpc-protovalidate/client/component.hpp":"taxi/uservices/userver/libraries/grpc-protovalidate/include/userver/grpc-protovalidate/client/component.hpp",
@@ -2545,13 +2604,128 @@
   "libraries/grpc-reflection/src/grpc-reflection/proto_server_reflection.cpp":"taxi/uservices/userver/libraries/grpc-reflection/src/grpc-reflection/proto_server_reflection.cpp",
   "libraries/grpc-reflection/src/grpc-reflection/proto_server_reflection.hpp":"taxi/uservices/userver/libraries/grpc-reflection/src/grpc-reflection/proto_server_reflection.hpp",
   "libraries/grpc-reflection/src/grpc-reflection/reflection_service_component.cpp":"taxi/uservices/userver/libraries/grpc-reflection/src/grpc-reflection/reflection_service_component.cpp",
+  "libraries/proto-structs/codegen-tests/proto/box/autobox/cycles.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox/cycles.proto",
+  "libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto",
+  "libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_self.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_self.proto",
+  "libraries/proto-structs/codegen-tests/proto/box/autobox/unbreakable_cycle.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox/unbreakable_cycle.proto",
+  "libraries/proto-structs/codegen-tests/proto/box/options/cycles.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/options/cycles.proto",
+  "libraries/proto-structs/codegen-tests/proto/box/options/initialization.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/options/initialization.proto",
+  "libraries/proto-structs/codegen-tests/proto/enums/names.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/enums/names.proto",
+  "libraries/proto-structs/codegen-tests/proto/maps/basic.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/maps/basic.proto",
+  "libraries/proto-structs/codegen-tests/proto/not_recommended_field_names/basic.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/not_recommended_field_names/basic.proto",
+  "libraries/proto-structs/codegen-tests/proto/oneof/basic.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/oneof/basic.proto",
+  "libraries/proto-structs/codegen-tests/proto/oneof/custom_oneof_type_name.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/oneof/custom_oneof_type_name.proto",
+  "libraries/proto-structs/codegen-tests/proto/oneof/proto2.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/oneof/proto2.proto",
+  "libraries/proto-structs/codegen-tests/proto/simple/base.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/simple/base.proto",
+  "libraries/proto-structs/codegen-tests/proto/simple/subdirectory/separate_enum.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/separate_enum.proto",
+  "libraries/proto-structs/codegen-tests/proto/simple/subdirectory/subdirectory.proto":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/subdirectory.proto",
+  "libraries/proto-structs/codegen-tests/src/box/autobox/cycles_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/box/autobox/cycles_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_nested_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_nested_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_self_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_self_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/box/autobox/unbreakable_cycle_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/box/autobox/unbreakable_cycle_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/box/options/cycles_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/box/options/cycles_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/box/options/initialization_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/box/options/initialization_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/enums/names_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/enums/names_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/maps/basic_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/maps/basic_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/not_recommended_field_names/basic_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/not_recommended_field_names/basic_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/oneof/basic_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/oneof/basic_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/oneof/custom_oneof_type_name_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/oneof/custom_oneof_type_name_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/oneof/proto2_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/oneof/proto2_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/simple/simple_test.cpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/simple/simple_test.cpp",
+  "libraries/proto-structs/codegen-tests/src/test_utils/type_assertions.hpp":"taxi/uservices/userver/libraries/proto-structs/codegen-tests/src/test_utils/type_assertions.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/any.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/any.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/convert.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/convert.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/exceptions.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/exceptions.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/hash_map.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/hash_map.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_cpp.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_cpp.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_hpp.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_hpp.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/impl/oneof_codegen.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/impl/oneof_codegen.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/impl/traits_light.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/impl/traits_light.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/context.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/context.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/context_base.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/context_base.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/fwd.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/fwd.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/impl/field_accessor.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/impl/field_accessor.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/impl/read.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/impl/read.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/impl/std/any_map_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/impl/std/any_map_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/impl/write.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/impl/write.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/int32_t.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/int32_t_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/int64_t.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/int64_t_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/map.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/map.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/map_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/map_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/optional.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/optional.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/optional_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/optional_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/scalar.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/scalar.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/scalar_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/scalar_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/size_t.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/size_t.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/size_t_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/size_t_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/string.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/string.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/string_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/string_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/vector.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/vector.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/std/vector_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/std/vector_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/supported_types.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/supported_types.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/supported_types_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/supported_types_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/oneof.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/oneof.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/type_mapping.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/type_mapping.hpp",
+  "libraries/proto-structs/include/userver/proto-structs/unbreakable_dependency_cycle.hpp":"taxi/uservices/userver/libraries/proto-structs/include/userver/proto-structs/unbreakable_dependency_cycle.hpp",
+  "libraries/proto-structs/proto/userver/structs/annotations.proto":"taxi/uservices/userver/libraries/proto-structs/proto/userver/structs/annotations.proto",
+  "libraries/proto-structs/src/proto-structs/exceptions.cpp":"taxi/uservices/userver/libraries/proto-structs/src/proto-structs/exceptions.cpp",
+  "libraries/proto-structs/src/proto-structs/io/context_base.cpp":"taxi/uservices/userver/libraries/proto-structs/src/proto-structs/io/context_base.cpp",
+  "libraries/proto-structs/src/proto-structs/io/impl/field_accessor.cpp":"taxi/uservices/userver/libraries/proto-structs/src/proto-structs/io/impl/field_accessor.cpp",
+  "libraries/proto-structs/src/proto-structs/io/std/chrono/time_point.cpp":"taxi/uservices/userver/libraries/proto-structs/src/proto-structs/io/std/chrono/time_point.cpp",
+  "libraries/proto-structs/src/proto-structs/io/std/chrono/year_month_day.cpp":"taxi/uservices/userver/libraries/proto-structs/src/proto-structs/io/std/chrono/year_month_day.cpp",
+  "libraries/proto-structs/src/proto-structs/io/userver/proto_structs/any.cpp":"taxi/uservices/userver/libraries/proto-structs/src/proto-structs/io/userver/proto_structs/any.cpp",
+  "libraries/proto-structs/tests/any_test.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/any_test.cpp",
+  "libraries/proto-structs/tests/exceptions_test.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/exceptions_test.cpp",
+  "libraries/proto-structs/tests/message_to_struct_test.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/message_to_struct_test.cpp",
+  "libraries/proto-structs/tests/oneof_test.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/oneof_test.cpp",
+  "libraries/proto-structs/tests/proto/messages.proto":"taxi/uservices/userver/libraries/proto-structs/tests/proto/messages.proto",
+  "libraries/proto-structs/tests/struct_simple.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/struct_simple.cpp",
+  "libraries/proto-structs/tests/struct_simple.hpp":"taxi/uservices/userver/libraries/proto-structs/tests/struct_simple.hpp",
+  "libraries/proto-structs/tests/struct_to_message_test.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/struct_to_message_test.cpp",
+  "libraries/proto-structs/tests/structs.cpp":"taxi/uservices/userver/libraries/proto-structs/tests/structs.cpp",
+  "libraries/proto-structs/tests/structs.hpp":"taxi/uservices/userver/libraries/proto-structs/tests/structs.hpp",
   "libraries/s3api/CMakeLists.txt":"taxi/uservices/userver/libraries/s3api/CMakeLists.txt",
   "libraries/s3api/include/userver/s3api/authenticators/access_key.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/authenticators/access_key.hpp",
   "libraries/s3api/include/userver/s3api/authenticators/interface.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/authenticators/interface.hpp",
   "libraries/s3api/include/userver/s3api/authenticators/utils.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/authenticators/utils.hpp",
   "libraries/s3api/include/userver/s3api/clients/fwd.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/clients/fwd.hpp",
   "libraries/s3api/include/userver/s3api/clients/s3api.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/clients/s3api.hpp",
+  "libraries/s3api/include/userver/s3api/models/errors.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/errors.hpp",
   "libraries/s3api/include/userver/s3api/models/fwd.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/fwd.hpp",
+  "libraries/s3api/include/userver/s3api/models/multipart_upload/requests.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/multipart_upload/requests.hpp",
+  "libraries/s3api/include/userver/s3api/models/multipart_upload/responses.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/multipart_upload/responses.hpp",
   "libraries/s3api/include/userver/s3api/models/request.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/request.hpp",
   "libraries/s3api/include/userver/s3api/models/s3api_connection_type.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/s3api_connection_type.hpp",
   "libraries/s3api/include/userver/s3api/models/secret.hpp":"taxi/uservices/userver/libraries/s3api/include/userver/s3api/models/secret.hpp",
@@ -2561,6 +2735,8 @@
   "libraries/s3api/src/s3api/authenticators/utils_test.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/authenticators/utils_test.cpp",
   "libraries/s3api/src/s3api/clients/client.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/clients/client.cpp",
   "libraries/s3api/src/s3api/clients/client.hpp":"taxi/uservices/userver/libraries/s3api/src/s3api/clients/client.hpp",
+  "libraries/s3api/src/s3api/models/multipart_upload/responses.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/models/multipart_upload/responses.cpp",
+  "libraries/s3api/src/s3api/models/multipart_upload/responses_test.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/models/multipart_upload/responses_test.cpp",
   "libraries/s3api/src/s3api/models/s3api_connection_type.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/models/s3api_connection_type.cpp",
   "libraries/s3api/src/s3api/models/secret.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/models/secret.cpp",
   "libraries/s3api/src/s3api/s3_connection.cpp":"taxi/uservices/userver/libraries/s3api/src/s3api/s3_connection.cpp",
@@ -2577,8 +2753,8 @@
   "mongo/dynamic_configs/MONGO_CONGESTION_CONTROL_ENABLED.yaml":"taxi/uservices/userver/mongo/dynamic_configs/MONGO_CONGESTION_CONTROL_ENABLED.yaml",
   "mongo/dynamic_configs/MONGO_CONGESTION_CONTROL_SETTINGS.yaml":"taxi/uservices/userver/mongo/dynamic_configs/MONGO_CONGESTION_CONTROL_SETTINGS.yaml",
   "mongo/dynamic_configs/MONGO_CONNECTION_POOL_SETTINGS.yaml":"taxi/uservices/userver/mongo/dynamic_configs/MONGO_CONNECTION_POOL_SETTINGS.yaml",
-  "mongo/dynamic_configs/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.yaml":"taxi/uservices/userver/mongo/dynamic_configs/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.yaml",
   "mongo/dynamic_configs/MONGO_DEFAULT_MAX_TIME_MS.yaml":"taxi/uservices/userver/mongo/dynamic_configs/MONGO_DEFAULT_MAX_TIME_MS.yaml",
+  "mongo/dynamic_configs/USERVER_DEADLINE_PROPAGATION_ENABLED.yaml":"taxi/uservices/userver/mongo/dynamic_configs/USERVER_DEADLINE_PROPAGATION_ENABLED.yaml",
   "mongo/functional_tests/CMakeLists.txt":"taxi/uservices/userver/mongo/functional_tests/CMakeLists.txt",
   "mongo/functional_tests/basic_chaos/CMakeLists.txt":"taxi/uservices/userver/mongo/functional_tests/basic_chaos/CMakeLists.txt",
   "mongo/functional_tests/basic_chaos/mongo_service.cpp":"taxi/uservices/userver/mongo/functional_tests/basic_chaos/mongo_service.cpp",
@@ -3312,6 +3488,7 @@
   "redis/include/userver/storages/redis/request_data_base.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/request_data_base.hpp",
   "redis/include/userver/storages/redis/request_eval.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/request_eval.hpp",
   "redis/include/userver/storages/redis/request_evalsha.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/request_evalsha.hpp",
+  "redis/include/userver/storages/redis/request_generic.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/request_generic.hpp",
   "redis/include/userver/storages/redis/scan_tag.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/scan_tag.hpp",
   "redis/include/userver/storages/redis/subscribe_client.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/subscribe_client.hpp",
   "redis/include/userver/storages/redis/subscription_token.hpp":"taxi/uservices/userver/redis/include/userver/storages/redis/subscription_token.hpp",
@@ -3711,11 +3888,11 @@
   "samples/postgres_cache_order_by/tests/static/test_data.sql":"taxi/uservices/userver/samples/postgres_cache_order_by/tests/static/test_data.sql",
   "samples/postgres_cache_order_by/tests/test_cache_order_by.py":"taxi/uservices/userver/samples/postgres_cache_order_by/tests/test_cache_order_by.py",
   "samples/postgres_service/CMakeLists.txt":"taxi/uservices/userver/samples/postgres_service/CMakeLists.txt",
-  "samples/postgres_service/delete_value.sql":"taxi/uservices/userver/samples/postgres_service/delete_value.sql",
-  "samples/postgres_service/insert_value.sql":"taxi/uservices/userver/samples/postgres_service/insert_value.sql",
   "samples/postgres_service/main.cpp":"taxi/uservices/userver/samples/postgres_service/main.cpp",
+  "samples/postgres_service/queries/read/select_value.sql":"taxi/uservices/userver/samples/postgres_service/queries/read/select_value.sql",
+  "samples/postgres_service/queries/write/delete_value.sql":"taxi/uservices/userver/samples/postgres_service/queries/write/delete_value.sql",
+  "samples/postgres_service/queries/write/insert_value.sql":"taxi/uservices/userver/samples/postgres_service/queries/write/insert_value.sql",
   "samples/postgres_service/schemas/postgresql/admin.sql":"taxi/uservices/userver/samples/postgres_service/schemas/postgresql/admin.sql",
-  "samples/postgres_service/select_value.sql":"taxi/uservices/userver/samples/postgres_service/select_value.sql",
   "samples/postgres_service/static_config.yaml":"taxi/uservices/userver/samples/postgres_service/static_config.yaml",
   "samples/postgres_service/tests/conftest.py":"taxi/uservices/userver/samples/postgres_service/tests/conftest.py",
   "samples/postgres_service/tests/test_postgres.py":"taxi/uservices/userver/samples/postgres_service/tests/test_postgres.py",
@@ -3836,6 +4013,7 @@
   "scripts/chaotic/requirements.txt":"taxi/uservices/userver/scripts/chaotic/requirements.txt",
   "scripts/clickhouse/ubuntu-install-clickhouse.sh":"taxi/uservices/userver/scripts/clickhouse/ubuntu-install-clickhouse.sh",
   "scripts/create-service-test-helper":"taxi/uservices/userver/scripts/create-service-test-helper",
+  "scripts/debian-rules":"taxi/uservices/userver/scripts/debian-rules",
   "scripts/docker/Readme.md":"taxi/uservices/userver/scripts/docker/Readme.md",
   "scripts/docker/base-debian-11.dockerfile":"taxi/uservices/userver/scripts/docker/base-debian-11.dockerfile",
   "scripts/docker/base-ubuntu-22.04-ci.dockerfile":"taxi/uservices/userver/scripts/docker/base-ubuntu-22.04-ci.dockerfile",
@@ -3868,16 +4046,41 @@
   "scripts/docs/en/deps/arch.md":"taxi/uservices/userver/scripts/docs/en/deps/arch.md",
   "scripts/docs/en/deps/debian-11.md":"taxi/uservices/userver/scripts/docs/en/deps/debian-11.md",
   "scripts/docs/en/deps/debian-12.md":"taxi/uservices/userver/scripts/docs/en/deps/debian-12.md",
-  "scripts/docs/en/deps/fedora-35.md":"taxi/uservices/userver/scripts/docs/en/deps/fedora-35.md",
-  "scripts/docs/en/deps/fedora-36.md":"taxi/uservices/userver/scripts/docs/en/deps/fedora-36.md",
+  "scripts/docs/en/deps/debian-13.md":"taxi/uservices/userver/scripts/docs/en/deps/debian-13.md",
+  "scripts/docs/en/deps/fedora-42.md":"taxi/uservices/userver/scripts/docs/en/deps/fedora-42.md",
   "scripts/docs/en/deps/gentoo.md":"taxi/uservices/userver/scripts/docs/en/deps/gentoo.md",
   "scripts/docs/en/deps/macos.md":"taxi/uservices/userver/scripts/docs/en/deps/macos.md",
   "scripts/docs/en/deps/ubuntu-21.10.md":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-21.10.md",
   "scripts/docs/en/deps/ubuntu-22.04.md":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04.md",
+  "scripts/docs/en/deps/ubuntu-22.04/chaotic":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/chaotic",
+  "scripts/docs/en/deps/ubuntu-22.04/core":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/core",
+  "scripts/docs/en/deps/ubuntu-22.04/grpc":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/grpc",
+  "scripts/docs/en/deps/ubuntu-22.04/kafka":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/kafka",
+  "scripts/docs/en/deps/ubuntu-22.04/mongo":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/mongo",
+  "scripts/docs/en/deps/ubuntu-22.04/mysql":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/mysql",
+  "scripts/docs/en/deps/ubuntu-22.04/odbc":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/odbc",
+  "scripts/docs/en/deps/ubuntu-22.04/postgresql":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/postgresql",
+  "scripts/docs/en/deps/ubuntu-22.04/redis":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/redis",
+  "scripts/docs/en/deps/ubuntu-22.04/rocks":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/rocks",
+  "scripts/docs/en/deps/ubuntu-22.04/sqlite":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/sqlite",
+  "scripts/docs/en/deps/ubuntu-22.04/universal":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/universal",
+  "scripts/docs/en/deps/ubuntu-22.04/ydb":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-22.04/ydb",
   "scripts/docs/en/deps/ubuntu-24.04.md":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04.md",
+  "scripts/docs/en/deps/ubuntu-24.04/chaotic":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/chaotic",
+  "scripts/docs/en/deps/ubuntu-24.04/core":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/core",
+  "scripts/docs/en/deps/ubuntu-24.04/grpc":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/grpc",
+  "scripts/docs/en/deps/ubuntu-24.04/kafka":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/kafka",
+  "scripts/docs/en/deps/ubuntu-24.04/mongo":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/mongo",
+  "scripts/docs/en/deps/ubuntu-24.04/mysql":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/mysql",
+  "scripts/docs/en/deps/ubuntu-24.04/odbc":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/odbc",
+  "scripts/docs/en/deps/ubuntu-24.04/postgresql":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/postgresql",
+  "scripts/docs/en/deps/ubuntu-24.04/redis":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/redis",
+  "scripts/docs/en/deps/ubuntu-24.04/rocks":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/rocks",
+  "scripts/docs/en/deps/ubuntu-24.04/sqlite":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/sqlite",
+  "scripts/docs/en/deps/ubuntu-24.04/universal":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/universal",
+  "scripts/docs/en/deps/ubuntu-24.04/ydb":"taxi/uservices/userver/scripts/docs/en/deps/ubuntu-24.04/ydb",
   "scripts/docs/en/index.md":"taxi/uservices/userver/scripts/docs/en/index.md",
   "scripts/docs/en/landing.md":"taxi/uservices/userver/scripts/docs/en/landing.md",
-  "scripts/docs/en/schemas/dynamic_configs.md":"taxi/uservices/userver/scripts/docs/en/schemas/dynamic_configs.md",
   "scripts/docs/en/userver/404.md":"taxi/uservices/userver/scripts/docs/en/userver/404.md",
   "scripts/docs/en/userver/build/build.md":"taxi/uservices/userver/scripts/docs/en/userver/build/build.md",
   "scripts/docs/en/userver/build/dependencies.md":"taxi/uservices/userver/scripts/docs/en/userver/build/dependencies.md",
@@ -3895,6 +4098,7 @@
   "scripts/docs/en/userver/deploy_env.md":"taxi/uservices/userver/scripts/docs/en/userver/deploy_env.md",
   "scripts/docs/en/userver/development/releases.md":"taxi/uservices/userver/scripts/docs/en/userver/development/releases.md",
   "scripts/docs/en/userver/development/stability.md":"taxi/uservices/userver/scripts/docs/en/userver/development/stability.md",
+  "scripts/docs/en/userver/distro_maintainers.md":"taxi/uservices/userver/scripts/docs/en/userver/distro_maintainers.md",
   "scripts/docs/en/userver/dns_control.md":"taxi/uservices/userver/scripts/docs/en/userver/dns_control.md",
   "scripts/docs/en/userver/driver_guide.md":"taxi/uservices/userver/scripts/docs/en/userver/driver_guide.md",
   "scripts/docs/en/userver/dynamic_config.md":"taxi/uservices/userver/scripts/docs/en/userver/dynamic_config.md",
@@ -3911,6 +4115,7 @@
   "scripts/docs/en/userver/grpc/middlewares_toggle.md":"taxi/uservices/userver/scripts/docs/en/userver/grpc/middlewares_toggle.md",
   "scripts/docs/en/userver/grpc/server_middleware_implementation.md":"taxi/uservices/userver/scripts/docs/en/userver/grpc/server_middleware_implementation.md",
   "scripts/docs/en/userver/grpc/server_middlewares.md":"taxi/uservices/userver/scripts/docs/en/userver/grpc/server_middlewares.md",
+  "scripts/docs/en/userver/grpc/timeouts_retries.md":"taxi/uservices/userver/scripts/docs/en/userver/grpc/timeouts_retries.md",
   "scripts/docs/en/userver/http_server.md":"taxi/uservices/userver/scripts/docs/en/userver/http_server.md",
   "scripts/docs/en/userver/http_server_middlewares.md":"taxi/uservices/userver/scripts/docs/en/userver/http_server_middlewares.md",
   "scripts/docs/en/userver/intro.md":"taxi/uservices/userver/scripts/docs/en/userver/intro.md",
@@ -3986,6 +4191,7 @@
   "scripts/docs/fontello/font/fontello.woff":"taxi/uservices/userver/scripts/docs/fontello/font/fontello.woff",
   "scripts/docs/fontello/font/fontello.woff2":"taxi/uservices/userver/scripts/docs/fontello/font/fontello.woff2",
   "scripts/docs/footer.html":"taxi/uservices/userver/scripts/docs/footer.html",
+  "scripts/docs/generate_versions.py":"taxi/uservices/userver/scripts/docs/generate_versions.py",
   "scripts/docs/header.html":"taxi/uservices/userver/scripts/docs/header.html",
   "scripts/docs/highlight.js/LICENSE":"taxi/uservices/userver/scripts/docs/highlight.js/LICENSE",
   "scripts/docs/highlight.js/README.md":"taxi/uservices/userver/scripts/docs/highlight.js/README.md",
@@ -4028,6 +4234,7 @@
   "scripts/docs/img/plane.svg":"taxi/uservices/userver/scripts/docs/img/plane.svg",
   "scripts/docs/img/sample_static_service.png":"taxi/uservices/userver/scripts/docs/img/sample_static_service.png",
   "scripts/docs/img/slack_logo.svg":"taxi/uservices/userver/scripts/docs/img/slack_logo.svg",
+  "scripts/docs/img/slugkit.svg":"taxi/uservices/userver/scripts/docs/img/slugkit.svg",
   "scripts/docs/img/square_logo.svg":"taxi/uservices/userver/scripts/docs/img/square_logo.svg",
   "scripts/docs/img/telegram_logo.svg":"taxi/uservices/userver/scripts/docs/img/telegram_logo.svg",
   "scripts/docs/img/title.svg":"taxi/uservices/userver/scripts/docs/img/title.svg",
@@ -4070,12 +4277,14 @@
   "scripts/gdb/tests/src/formats/json/gdb_test_json.cpp":"taxi/uservices/userver/scripts/gdb/tests/src/formats/json/gdb_test_json.cpp",
   "scripts/gdb/tests/test_printers.py":"taxi/uservices/userver/scripts/gdb/tests/test_printers.py",
   "scripts/gdb/update_gdbinit.py":"taxi/uservices/userver/scripts/gdb/update_gdbinit.py",
+  "scripts/generate-debian-directory.sh":"taxi/uservices/userver/scripts/generate-debian-directory.sh",
   "scripts/grpc/__init__.py":"taxi/uservices/userver/scripts/grpc/__init__.py",
   "scripts/grpc/generator.py":"taxi/uservices/userver/scripts/grpc/generator.py",
   "scripts/grpc/protoc_usrv_plugin.sh":"taxi/uservices/userver/scripts/grpc/protoc_usrv_plugin.sh",
   "scripts/grpc/requirements-3.txt":"taxi/uservices/userver/scripts/grpc/requirements-3.txt",
   "scripts/grpc/requirements-4.txt":"taxi/uservices/userver/scripts/grpc/requirements-4.txt",
   "scripts/grpc/requirements-5.txt":"taxi/uservices/userver/scripts/grpc/requirements-5.txt",
+  "scripts/grpc/requirements-6.txt":"taxi/uservices/userver/scripts/grpc/requirements-6.txt",
   "scripts/grpc/templates/client.usrv.cpp.jinja":"taxi/uservices/userver/scripts/grpc/templates/client.usrv.cpp.jinja",
   "scripts/grpc/templates/client.usrv.hpp.jinja":"taxi/uservices/userver/scripts/grpc/templates/client.usrv.hpp.jinja",
   "scripts/grpc/templates/service.usrv.cpp.jinja":"taxi/uservices/userver/scripts/grpc/templates/service.usrv.cpp.jinja",
@@ -4088,12 +4297,35 @@
   "scripts/perf-blocking-syscall":"taxi/uservices/userver/scripts/perf-blocking-syscall",
   "scripts/postgres/pg_sql_codes.py":"taxi/uservices/userver/scripts/postgres/pg_sql_codes.py",
   "scripts/postgres/ubuntu-install-postgresql-includes.sh":"taxi/uservices/userver/scripts/postgres/ubuntu-install-postgresql-includes.sh",
+  "scripts/proto_structs/README.md":"taxi/uservices/userver/scripts/proto_structs/README.md",
   "scripts/proto_structs/__init__.py":"taxi/uservices/userver/scripts/proto_structs/__init__.py",
+  "scripts/proto_structs/descriptors/__init__.py":"taxi/uservices/userver/scripts/proto_structs/descriptors/__init__.py",
+  "scripts/proto_structs/descriptors/descriptor_proto.py":"taxi/uservices/userver/scripts/proto_structs/descriptors/descriptor_proto.py",
+  "scripts/proto_structs/descriptors/node_parsers.py":"taxi/uservices/userver/scripts/proto_structs/descriptors/node_parsers.py",
+  "scripts/proto_structs/descriptors/option_parsers.py":"taxi/uservices/userver/scripts/proto_structs/descriptors/option_parsers.py",
+  "scripts/proto_structs/descriptors/type_mapping.py":"taxi/uservices/userver/scripts/proto_structs/descriptors/type_mapping.py",
   "scripts/proto_structs/generator.py":"taxi/uservices/userver/scripts/proto_structs/generator.py",
+  "scripts/proto_structs/models/__init__.py":"taxi/uservices/userver/scripts/proto_structs/models/__init__.py",
+  "scripts/proto_structs/models/forward_decls.py":"taxi/uservices/userver/scripts/proto_structs/models/forward_decls.py",
+  "scripts/proto_structs/models/gen_node.py":"taxi/uservices/userver/scripts/proto_structs/models/gen_node.py",
+  "scripts/proto_structs/models/includes.py":"taxi/uservices/userver/scripts/proto_structs/models/includes.py",
+  "scripts/proto_structs/models/includes_bundles.py":"taxi/uservices/userver/scripts/proto_structs/models/includes_bundles.py",
+  "scripts/proto_structs/models/io.py":"taxi/uservices/userver/scripts/proto_structs/models/io.py",
+  "scripts/proto_structs/models/names.py":"taxi/uservices/userver/scripts/proto_structs/models/names.py",
+  "scripts/proto_structs/models/options.py":"taxi/uservices/userver/scripts/proto_structs/models/options.py",
+  "scripts/proto_structs/models/reserved_identifiers.py":"taxi/uservices/userver/scripts/proto_structs/models/reserved_identifiers.py",
+  "scripts/proto_structs/models/sort_dependencies.py":"taxi/uservices/userver/scripts/proto_structs/models/sort_dependencies.py",
+  "scripts/proto_structs/models/toposort.py":"taxi/uservices/userver/scripts/proto_structs/models/toposort.py",
+  "scripts/proto_structs/models/type_ref.py":"taxi/uservices/userver/scripts/proto_structs/models/type_ref.py",
+  "scripts/proto_structs/models/type_ref_consts.py":"taxi/uservices/userver/scripts/proto_structs/models/type_ref_consts.py",
+  "scripts/proto_structs/models/vanilla.py":"taxi/uservices/userver/scripts/proto_structs/models/vanilla.py",
+  "scripts/proto_structs/templates/io.inc.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/io.inc.jinja",
+  "scripts/proto_structs/templates/io_forward_declarations.inc.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/io_forward_declarations.inc.jinja",
   "scripts/proto_structs/templates/structs.usrv.cpp.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/structs.usrv.cpp.jinja",
   "scripts/proto_structs/templates/structs.usrv.hpp.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/structs.usrv.hpp.jinja",
+  "scripts/proto_structs/templates/types.inc.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/types.inc.jinja",
+  "scripts/proto_structs/templates/types_forward_declarations.inc.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/types_forward_declarations.inc.jinja",
   "scripts/proto_structs/templates/utils.inc.jinja":"taxi/uservices/userver/scripts/proto_structs/templates/utils.inc.jinja",
-  "scripts/proto_structs/ya.make":"taxi/uservices/userver/scripts/proto_structs/ya.make",
   "scripts/rabbitmq/ubuntu_install_rabbitmq_dev.sh":"taxi/uservices/userver/scripts/rabbitmq/ubuntu_install_rabbitmq_dev.sh",
   "scripts/rabbitmq/ubuntu_install_rabbitmq_server.sh":"taxi/uservices/userver/scripts/rabbitmq/ubuntu_install_rabbitmq_server.sh",
   "scripts/sql/__init__.py":"taxi/uservices/userver/scripts/sql/__init__.py",
@@ -4308,6 +4540,7 @@
   "testsuite/requirements-grpc-3.txt":"taxi/uservices/userver/testsuite/requirements-grpc-3.txt",
   "testsuite/requirements-grpc-4.txt":"taxi/uservices/userver/testsuite/requirements-grpc-4.txt",
   "testsuite/requirements-grpc-5.txt":"taxi/uservices/userver/testsuite/requirements-grpc-5.txt",
+  "testsuite/requirements-grpc-6.txt":"taxi/uservices/userver/testsuite/requirements-grpc-6.txt",
   "testsuite/requirements-internal-tests.txt":"taxi/uservices/userver/testsuite/requirements-internal-tests.txt",
   "testsuite/requirements-mongo.txt":"taxi/uservices/userver/testsuite/requirements-mongo.txt",
   "testsuite/requirements-postgres.txt":"taxi/uservices/userver/testsuite/requirements-postgres.txt",
@@ -4603,6 +4836,7 @@
   "universal/include/userver/crypto/public_key.hpp":"taxi/uservices/userver/universal/include/userver/crypto/public_key.hpp",
   "universal/include/userver/crypto/random.hpp":"taxi/uservices/userver/universal/include/userver/crypto/random.hpp",
   "universal/include/userver/crypto/signers.hpp":"taxi/uservices/userver/universal/include/userver/crypto/signers.hpp",
+  "universal/include/userver/crypto/ssl_ctx.hpp":"taxi/uservices/userver/universal/include/userver/crypto/ssl_ctx.hpp",
   "universal/include/userver/crypto/verifiers.hpp":"taxi/uservices/userver/universal/include/userver/crypto/verifiers.hpp",
   "universal/include/userver/decimal64/decimal64.hpp":"taxi/uservices/userver/universal/include/userver/decimal64/decimal64.hpp",
   "universal/include/userver/decimal64/format_options.hpp":"taxi/uservices/userver/universal/include/userver/decimal64/format_options.hpp",
@@ -4696,6 +4930,7 @@
   "universal/include/userver/logging/format.hpp":"taxi/uservices/userver/universal/include/userver/logging/format.hpp",
   "universal/include/userver/logging/fwd.hpp":"taxi/uservices/userver/universal/include/userver/logging/fwd.hpp",
   "universal/include/userver/logging/impl/formatters/base.hpp":"taxi/uservices/userver/universal/include/userver/logging/impl/formatters/base.hpp",
+  "universal/include/userver/logging/impl/log_extra_tskv_formatter.hpp":"taxi/uservices/userver/universal/include/userver/logging/impl/log_extra_tskv_formatter.hpp",
   "universal/include/userver/logging/impl/logger_base.hpp":"taxi/uservices/userver/universal/include/userver/logging/impl/logger_base.hpp",
   "universal/include/userver/logging/impl/mem_logger.hpp":"taxi/uservices/userver/universal/include/userver/logging/impl/mem_logger.hpp",
   "universal/include/userver/logging/impl/tag_writer.hpp":"taxi/uservices/userver/universal/include/userver/logging/impl/tag_writer.hpp",
@@ -4791,6 +5026,7 @@
   "universal/include/userver/utils/string_literal.hpp":"taxi/uservices/userver/universal/include/userver/utils/string_literal.hpp",
   "universal/include/userver/utils/string_to_duration.hpp":"taxi/uservices/userver/universal/include/userver/utils/string_to_duration.hpp",
   "universal/include/userver/utils/strong_typedef.hpp":"taxi/uservices/userver/universal/include/userver/utils/strong_typedef.hpp",
+  "universal/include/userver/utils/strong_typedef_fwd.hpp":"taxi/uservices/userver/universal/include/userver/utils/strong_typedef_fwd.hpp",
   "universal/include/userver/utils/struct_subsets.hpp":"taxi/uservices/userver/universal/include/userver/utils/struct_subsets.hpp",
   "universal/include/userver/utils/swappingsmart.hpp":"taxi/uservices/userver/universal/include/userver/utils/swappingsmart.hpp",
   "universal/include/userver/utils/text_light.hpp":"taxi/uservices/userver/universal/include/userver/utils/text_light.hpp",
@@ -4848,6 +5084,7 @@
   "universal/src/crypto/random.cpp":"taxi/uservices/userver/universal/src/crypto/random.cpp",
   "universal/src/crypto/signature_test.cpp":"taxi/uservices/userver/universal/src/crypto/signature_test.cpp",
   "universal/src/crypto/signers.cpp":"taxi/uservices/userver/universal/src/crypto/signers.cpp",
+  "universal/src/crypto/ssl_ctx.cpp":"taxi/uservices/userver/universal/src/crypto/ssl_ctx.cpp",
   "universal/src/crypto/verifiers.cpp":"taxi/uservices/userver/universal/src/crypto/verifiers.cpp",
   "universal/src/decimal64/decimal64.cpp":"taxi/uservices/userver/universal/src/decimal64/decimal64.cpp",
   "universal/src/decimal64/decimal64_errors_test.cpp":"taxi/uservices/userver/universal/src/decimal64/decimal64_errors_test.cpp",
@@ -4975,6 +5212,7 @@
   "universal/src/logging/impl/formatters/struct.hpp":"taxi/uservices/userver/universal/src/logging/impl/formatters/struct.hpp",
   "universal/src/logging/impl/formatters/tskv.cpp":"taxi/uservices/userver/universal/src/logging/impl/formatters/tskv.cpp",
   "universal/src/logging/impl/formatters/tskv.hpp":"taxi/uservices/userver/universal/src/logging/impl/formatters/tskv.hpp",
+  "universal/src/logging/impl/log_extra_tskv_formatter.cpp":"taxi/uservices/userver/universal/src/logging/impl/log_extra_tskv_formatter.cpp",
   "universal/src/logging/impl/logger_base.cpp":"taxi/uservices/userver/universal/src/logging/impl/logger_base.cpp",
   "universal/src/logging/impl/mem_logger.cpp":"taxi/uservices/userver/universal/src/logging/impl/mem_logger.cpp",
   "universal/src/logging/impl/tag_writer.cpp":"taxi/uservices/userver/universal/src/logging/impl/tag_writer.cpp",
@@ -5140,6 +5378,7 @@
   "universal/utest/src/utest/current_process_open_files_test.cpp":"taxi/uservices/userver/universal/utest/src/utest/current_process_open_files_test.cpp",
   "universal/utest/src/utest/log_capture_fixture.cpp":"taxi/uservices/userver/universal/utest/src/utest/log_capture_fixture.cpp",
   "universal/utest/src/utest/parameter_names_test.cpp":"taxi/uservices/userver/universal/utest/src/utest/parameter_names_test.cpp",
+  "version.txt":"taxi/uservices/userver/version.txt",
   "ydb/CMakeLists.txt":"taxi/uservices/userver/ydb/CMakeLists.txt",
   "ydb/dynamic_configs/YDB_DEADLINE_PROPAGATION_VERSION.yaml":"taxi/uservices/userver/ydb/dynamic_configs/YDB_DEADLINE_PROPAGATION_VERSION.yaml",
   "ydb/dynamic_configs/YDB_QUERIES_COMMAND_CONTROL.yaml":"taxi/uservices/userver/ydb/dynamic_configs/YDB_QUERIES_COMMAND_CONTROL.yaml",
diff --git a/.roorules b/.roorules
new file mode 100644
index 000000000000..8109bc724043
--- /dev/null
+++ b/.roorules
@@ -0,0 +1,107 @@
+# Roo Rules (.roorules)
+#
+# Basic guide for AI agents working with userver service development.
+# Contains essential project structure, examples location, and workflow commands.
+
+project_info:
+  description: "Basic guide for userver service development"
+  purpose: "Provides essential structure and workflow for creating userver services"
+
+# Project structure for userver services
+project_structure:
+  description: "Standard directory structure for userver services"
+  service_template_location: "service_template/ - Use this as base for new services"
+  examples_location: "samples/ - Find working examples of various userver features here"
+
+  standard_service_structure:
+    - "CMakeLists.txt              # Build configuration"
+    - "configs/                    # Configuration files"
+    - "  └── static_config.yaml    # Static service configuration"
+    - "src/                        # Source code"
+    - "  ├── main.cpp              # Service entry point"
+    - "  ├── handlers/             # HTTP handlers"
+    - "  │   ├── handler_name.hpp  # Handler declaration"
+    - "  │   └── handler_name.cpp  # Handler implementation"
+    - "  └── components/           # Custom components (optional)"
+    - "tests/                      # Tests (optional)"
+
+# Key files and their purposes
+key_files:
+  main_cpp:
+    description: "Service entry point - registers components and starts service"
+  cmake_lists_txt:
+    description: "Build configuration - links userver components"
+  static_config_yaml:
+    description: "Configuration - defines task processors, components, URL mappings"
+
+# Basic workflow commands for service development
+workflow:
+  description: "Essential commands for userver service development"
+
+  create_service:
+    description: "Create new service from template"
+    commands:
+      - "cp -r service_template/ my_new_service/"
+      - "cd my_new_service/"
+      - "# Edit CMakeLists.txt to change project name"
+      - "# Edit src/main.cpp to register your handlers"
+      - "# Edit configs/static_config.yaml to configure service"
+
+  build_service:
+    description: "Build the service"
+    commands:
+      - "mkdir build && cd build"
+      - "cmake .."
+      - "make -j$(nproc)"
+
+  run_service:
+    description: "Run the service"
+    commands:
+      - "./my_service --config ../configs/static_config.yaml"
+
+  run_tests:
+    description: "Run tests"
+    commands:
+      - "make test"
+      - "# For functional tests with pytest:"
+      - "cd tests && python3 -m pytest"
+
+# Where to find examples
+examples:
+  description: "Look in samples/ directory for working examples"
+  basic_examples:
+    - "samples/hello_service/ - Simple HTTP service"
+    - "samples/postgres_service/ - Service with PostgreSQL"
+    - "samples/redis_service/ - Service with Redis"
+    - "samples/grpc_service/ - gRPC service example"
+
+# Stubs for future expansion
+http_client_usage:
+  description: "TODO: Add HTTP client patterns"
+
+caching_strategies:
+  description: "TODO: Add caching patterns"
+
+middleware_development:
+  description: "TODO: Add middleware patterns"
+
+error_handling_logging:
+  description: "TODO: Add error handling patterns"
+
+security_best_practices:
+  description: "TODO: Add security guidelines"
+
+debugging_profiling:
+  description: "TODO: Add debugging workflows"
+
+deployment_release:
+  description: "TODO: Add deployment processes"
+
+monitoring_observability:
+  description: "TODO: Add monitoring setup"
+
+api_design_principles:
+  description: "TODO: Add API design guidelines"
+
+code_review_standards:
+  description: "TODO: Add code review standards"
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 221aec71706a..26e86dcafeac 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -56,8 +56,8 @@ if(USERVER_BUILD_TESTS AND NOT USERVER_FEATURE_UTEST)
     message(FATAL_ERROR "Running unit tests for userver requires utest, disabling it is meaningless")
 endif()
 
-if(USERVER_INSTALL AND (USERVER_BUILD_TESTS OR USERVER_BUILD_SAMPLES))
-    message(FATAL_ERROR "For USERVER_INSTALL, please turn off USERVER_BUILD_TESTS and USERVER_BUILD_SAMPLES "
+if(USERVER_INSTALL AND USERVER_BUILD_TESTS)
+    message(FATAL_ERROR "For USERVER_INSTALL, please turn off USERVER_BUILD_TESTS "
                         "to avoid accidentally installing them"
     )
 endif()
@@ -175,6 +175,9 @@ include(UserverSetupEnvironment)
 userver_setup_environment()
 
 include(PrepareInstall)
+
+include(GetUserverVersion)
+
 include(UserverModule)
 
 if(USERVER_INSTALL)
@@ -182,7 +185,6 @@ if(USERVER_INSTALL)
 endif()
 
 include(ModuleHelpers)
-include(GetUserverVersion)
 include(AddGoogleTests)
 include(FindPackageRequired)
 include(IncludeWhatYouUse)
@@ -192,6 +194,9 @@ include(UserverGenerateDynamicConfigsDocs)
 include(CheckCompileFlags)
 include(CMakePackageConfigHelpers)
 
+_userver_macos_set_default_dir(OPENSSL_ROOT_DIR "brew;--prefix;openssl")
+include(SetupOpenssl)
+
 set(USERVER_THIRD_PARTY_DIRS
     ${USERVER_ROOT_DIR}/third_party
     CACHE INTERNAL ""
@@ -199,6 +204,7 @@ set(USERVER_THIRD_PARTY_DIRS
 
 init_debian_depends()
 
+include(SetupBoost)
 include(SetupGTest)
 
 if(USERVER_FEATURE_GRPC)
@@ -324,10 +330,6 @@ if(USERVER_BUILD_SAMPLES AND USERVER_FEATURE_CORE)
     add_subdirectory(samples)
 endif()
 
-if(USERVER_INSTALL)
-    include(cmake/UserverPack.cmake)
-endif()
-
 if(USERVER_FEATURE_CORE)
     _userver_directory_install(
         COMPONENT core
@@ -367,3 +369,11 @@ endif()
 _userver_add_target_gen_dynamic_configs_docs()
 
 _userver_print_features_list()
+if(CPM_PACKAGES)
+    include(DownloadUsingCPM)
+    _userver_print_cpm_packages()
+endif()
+
+if(USERVER_INSTALL)
+    include(cmake/UserverPack.cmake)
+endif()
diff --git a/Makefile b/Makefile
index 7162fe89b4e9..146530bbb36b 100644
--- a/Makefile
+++ b/Makefile
@@ -75,4 +75,13 @@ docker-kill:
 # clean build folders
 .PHONY: dist-clean
 dist-clean:
-	rm -rf build_*
+	rm -rf build_*/
+	rm -rf debian/
+	rm -rf .ruff_cache/
+	rm -rf _CPack_Packages/
+	find -name .mypy_cache | xargs rm -rf
+	find -name __pycache__ | xargs rm -rf
+
+.PHONY: gen-debian-directory
+gen-debian-directory:
+	scripts/generate-debian-directory.sh
diff --git a/README.md b/README.md
index f24126ff9686..4f03ba8e9bfc 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
 # userver [<img src="./scripts/docs/img/logo.svg" align='right' width="10%">](https://userver.tech/)
 
 [![Ubuntu](https://github.com/userver-framework/userver/actions/workflows/ci.yml/badge.svg)](https://github.com/userver-framework/userver/actions/workflows/ci.yml)
+[![Fedora](https://github.com/userver-framework/userver/actions/workflows/fedora.yml/badge.svg)](https://github.com/userver-framework/userver/actions/workflows/fedora.yml)
+[![Debian](https://github.com/userver-framework/userver/actions/workflows/debian.yml/badge.svg)](https://github.com/userver-framework/userver/actions/workflows/debian.yml)
 [![MacOS](https://github.com/userver-framework/userver/actions/workflows/macos.yml/badge.svg)](https://github.com/userver-framework/userver/actions/workflows/macos.yml)
 [![Alpine](https://github.com/userver-framework/userver/actions/workflows/alpine.yml/badge.svg)](https://github.com/userver-framework/userver/actions/workflows/alpine.yml)
 [![Docker CI](https://github.com/userver-framework/userver/actions/workflows/docker.yaml/badge.svg)](https://github.com/userver-framework/userver/actions/workflows/docker.yaml)
diff --git a/chaotic-openapi/CMakeLists.txt b/chaotic-openapi/CMakeLists.txt
index b6ada59033e8..185bb249c759 100644
--- a/chaotic-openapi/CMakeLists.txt
+++ b/chaotic-openapi/CMakeLists.txt
@@ -8,6 +8,7 @@ userver_module(
     LINK_LIBRARIES userver-core userver-chaotic
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
     UTEST_LINK_LIBRARIES userver-core userver-chaotic
+    DEPENDS core
 )
 
 if(USERVER_BUILD_TESTS)
@@ -25,7 +26,9 @@ if(USERVER_BUILD_TESTS)
     )
 
     add_subdirectory(integration_tests)
-    add_subdirectory(golden_tests)
+    if (USERVER_CHAOTIC_GOLDEN_TESTS)
+        add_subdirectory(golden_tests)
+    endif()
 endif()
 
 _userver_directory_install(
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/middleware.py b/chaotic-openapi/chaotic_openapi/back/cpp_client/middleware.py
new file mode 100644
index 000000000000..5ee1b421d054
--- /dev/null
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/middleware.py
@@ -0,0 +1,96 @@
+import abc
+
+
+class Middleware(abc.ABC):
+    """
+    Per-operation middleware.
+    It generates a single struct member for `Request` type.
+    If we want to represent the structure as a jinja template,
+    it will look something like that:
+
+        struct Request {
+            {{ middleware.request_member_cpp_type }} {{ middleware.request_member_name }};
+        };
+
+        void SerializeRequest(
+            const Request& request,
+            const std::string& base_url,
+            USERVER_NAMESPACE::clients::http::Request& http_request
+        )
+        {
+            openapi::ParameterSinkHttpClient sink(
+                http_request,
+                base_url + "{{ op.path }}"
+            );
+            ...
+            {{ middleware.write_member_command('request', 'sink', 'http_request') }}
+        }
+    """
+
+    @property
+    @abc.abstractmethod
+    def request_member_name(self) -> str:
+        """
+        Generated `Request` member name for middleware data.
+        """
+        pass
+
+    @property
+    @abc.abstractmethod
+    def request_member_cpp_type(self) -> str:
+        """
+        C++ type of `request_member_name`.
+        """
+        pass
+
+    @property
+    @abc.abstractmethod
+    def requests_hpp_includes(self) -> list[str]:
+        """
+        C++ include path used to access `request_member_cpp_type`.
+        """
+        pass
+
+    @abc.abstractmethod
+    def write_member_command(
+        self,
+        request: str,
+        sink: str,
+        http_request: str,
+    ) -> str:
+        """
+        C++ code that will be called as part of `Request` serialization.
+
+        request - variable name of `Request` type
+        sink - variable name of `ParameterSinkHttpClient` type
+        http_request - variable name of `clients::http::Request` type
+        """
+        pass
+
+
+class MiddlewarePlugin(abc.ABC):
+    """
+    Implement `MiddlewarePlugin` if you want to extend OpenAPI schema
+    with your middleware. The schema is extended with
+    `x-usrv-middleware.` + MiddlewarePlugin.field object member.
+
+    A plugin is created per-parser.
+    """
+
+    @property
+    @abc.abstractmethod
+    def field(self) -> str:
+        """
+        Returns `x-usrv-middleware` property name that is responsible for
+        middleware activation and parameters storage.
+        """
+        pass
+
+    @abc.abstractmethod
+    def create(self, args: dict) -> Middleware:
+        """
+        The method is called every time a HTTP operation with
+        "x-usrv-middleware." + field property is discovered.
+        It creates a per-operation `Middleware` object.
+        """
+        pass
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/output.py b/chaotic-openapi/chaotic_openapi/back/cpp_client/output.py
index 6987bb990995..f290b0280477 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/output.py
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/output.py
@@ -1,11 +1,15 @@
 import collections
+import dataclasses
+import os
 import pathlib
-from typing import Dict
-from typing import List
+from typing import Any
 from typing import Optional
 
 import yaml
 
+from chaotic.back.cpp import types as cpp_types
+from chaotic.front import parser as chaotic_parser
+from chaotic.front import ref
 from . import renderer
 
 TYPES_INCLUDES = [
@@ -16,7 +20,11 @@
 ]
 
 
-def _get_template_includes(name: str, client_name: str, graph: Dict[str, List[str]]) -> List[str]:
+def filepath_with_stem(fpath: str) -> str:
+    return fpath.rsplit('.', 1)[0]
+
+
+def _get_template_includes(name: str, client_name: str, graph: dict[str, list[str]]) -> list[str]:
     includes = {
         'client.cpp': [
             f'clients/{client_name}/client.hpp',
@@ -77,7 +85,6 @@ def _get_template_includes(name: str, client_name: str, graph: Dict[str, List[st
             'string',
             'variant',
             *[f'clients/{client_name}/{dep}' for dep in graph],
-            # TODO
         ],
         'responses.cpp': [
             f'clients/{client_name}/responses.hpp',
@@ -92,63 +99,95 @@ def _get_template_includes(name: str, client_name: str, graph: Dict[str, List[st
             f'clients/{client_name}/exceptions.hpp',
             'userver/chaotic/openapi/client/exceptions.hpp',
             *[f'clients/{client_name}/{dep}' for dep in graph],
-            # TODO
         ],
     }
     return includes[name]
 
 
-def trim_suffix(string: str, suffix: str) -> Optional[str]:
-    if string.endswith(suffix):
-        return string[: -len(suffix)]
-    return None
-
-
-def extract_includes(name: str, path: pathlib.Path) -> Optional[List[str]]:
+def extract_includes(name: str, path: pathlib.Path, schemas_dir: pathlib.Path) -> Optional[list[str]]:
     with open(path) as ifile:
         content = yaml.safe_load(ifile)
 
-    includes: List[str] = []
+    includes: list[str] = []
+    is_file_produced = False
+
+    relpath = os.path.relpath(os.path.dirname(path), schemas_dir)
 
     def visit(data) -> None:
+        nonlocal is_file_produced
         if isinstance(data, dict):
             for v in data.values():
                 visit(v)
             if '$ref' in data:
-                ref = data['$ref']
-                ref = ref.split('#')[0]
-                ref_fname = ref.rsplit('/', 1)[-1]
-                if ref_fname:
-                    stem = ref_fname.rsplit('.', 1)[0]
+                ref_ = data['$ref']
+                filename = ref.Ref(ref_).file
+                if filename:
+                    stem = os.path.join(relpath, filepath_with_stem(filename))
+                    stem = chaotic_parser.SchemaParser._normalize_ref(stem)
                     includes.append(f'clients/{name}/{stem}.hpp')
-            if 'x-taxi-cpp-type' in data:
-                pass
-            if 'x-usrv-cpp-type' in data:
-                pass
+
+            for field in ('x-taxi-cpp-type', 'x-usrv-cpp-type'):
+                if field not in data:
+                    continue
+                header = extract_cpp_type_header(data[field])
+                if header:
+                    includes.append(header)
+
+            if is_file_produced_feature(data):
+                is_file_produced = True
         elif isinstance(data, list):
             for v in data:
                 visit(v)
 
-    if 'definitions' in content or 'components' in content or 'paths' in content:
-        visit(content)
+    visit(content)
+    if content.get('definitions') or content.get('components', {}).get('schemas'):
+        is_file_produced = True
+
+    if includes or is_file_produced:
         return includes
-    else:
+
+    # No schemas in file, it will generate no .hpp/.cpp
+    return None
+
+
+def is_file_produced_feature(data: dict[str, Any]) -> bool:
+    if data.get('type') == 'object':
+        return True
+    if data.get('oneOf'):
+        return True
+    if data.get('allOf'):
+        return True
+    return False
+
+
+def extract_cpp_type_header(cpp_type: str) -> Optional[str]:
+    parts = cpp_type.split('::')
+    if len(parts) < 2:
+        return None
+    library = parts[0].replace('_', '-')
+    if library == 'std':
         return None
+    filename = cpp_types.camel_to_snake_case(parts[1])
+    return '{}/{}.hpp'.format(library, filename)
 
 
-def include_graph(name: str, schemas_dir: pathlib.Path) -> Dict[str, List[str]]:
+def include_graph(name: str, schemas_dir: pathlib.Path) -> dict[str, list[str]]:
     result = {}
     for root, _, filenames in schemas_dir.walk():
         for filename in filenames:
+            if not filename.endswith('.yaml'):
+                continue
             filepath = pathlib.Path(root) / filename
             if filepath == schemas_dir / 'client.yaml' or filename == 'a.yaml':
                 continue
-            result[filepath.stem + '.hpp'] = extract_includes(name, filepath)
+
+            stem = filepath_with_stem(os.path.relpath(filepath, schemas_dir))
+            result[stem + '.hpp'] = extract_includes(name, filepath, schemas_dir)
 
     return {key: result[key] for key in result if result[key] is not None}  # type: ignore
 
 
-def get_includes(client_name: str, schemas_dir: str) -> Dict[str, List[str]]:
+def get_includes(client_name: str, schemas_dir: str) -> dict[str, list[str]]:
     graph = include_graph(client_name, pathlib.Path(schemas_dir))
 
     output = collections.defaultdict(list)
@@ -160,7 +199,7 @@ def get_includes(client_name: str, schemas_dir: str) -> Dict[str, List[str]]:
         output[rel_path] = _get_template_includes(name, client_name, graph)
 
     for file in graph:
-        stem = pathlib.Path(file).stem
+        stem = filepath_with_stem(file)
         output[f'include/clients/{client_name}/{stem}_fwd.hpp'] = []
         output[f'include/clients/{client_name}/{stem}.hpp'] = [
             f'clients/{client_name}/{stem}_fwd.hpp',
@@ -182,9 +221,19 @@ def get_includes(client_name: str, schemas_dir: str) -> Dict[str, List[str]]:
     return output
 
 
-def external_libraries(schemas_dir: str) -> List[str]:
+@dataclasses.dataclass
+class External:
+    libraries: list[str]
+    userver_modules: list[str]
+
+
+# For Yandex uservices only, not for OSS
+def external_libraries(schemas_dir: str) -> External:
     types = set()
 
+    libraries = []
+    userver_modules = []
+
     def visit(data) -> None:
         if isinstance(data, dict):
             for v in data.values():
@@ -193,6 +242,18 @@ def visit(data) -> None:
                 types.add(data['x-taxi-cpp-type'])
             if 'x-usrv-cpp-type' in data:
                 types.add(data['x-usrv-cpp-type'])
+            if 'x-taxi-cpp-typedef-tag' in data:
+                types.add(data['x-taxi-cpp-typedef-tag'])
+            if 'x-usrv-cpp-typedef-tag' in data:
+                types.add(data['x-usrv-cpp-typedef-tag'])
+
+            if data.get('x-taxi-middlewares', {}).get('api-4.0'):
+                libraries.append('passenger-authorizer-backend')
+            if data.get('x-taxi-middlewares', {}).get('eats') == 'v1':
+                libraries.append('eats-authproxy-backend')
+            if data.get('x-taxi-middlewares', {}).get('bank-authproxy'):
+                libraries.append('bank-authproxy-backend')
+
         elif isinstance(data, list):
             for v in data:
                 visit(v)
@@ -202,10 +263,14 @@ def visit(data) -> None:
             content = yaml.safe_load(ifile)
             visit(content)
 
-    libraries = []
     for type_ in types:
+        if type_.startswith('::'):
+            type_ = type_[2:]
         library = type_.split('::')[0].replace('_', '-')
         # special namespaces (and unsigned) which are defined in userver/, not in libraries/
         if library not in {'std', 'storages', 'decimal64', 'unsigned'}:
             libraries.append(library)
-    return libraries
+        if type_.startswith('storages::postgres::'):
+            userver_modules.append('postgresql')
+
+    return External(libraries=libraries, userver_modules=userver_modules)
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/renderer.py b/chaotic-openapi/chaotic_openapi/back/cpp_client/renderer.py
index 51fa73fdb543..060ce66a4f73 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/renderer.py
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/renderer.py
@@ -1,7 +1,6 @@
 import dataclasses
 import os
 import pathlib
-from typing import List
 
 import jinja2
 
@@ -45,7 +44,7 @@ class CppOutput:
     content: str
 
     @staticmethod
-    def save(outputs: List['CppOutput'], prefix: str) -> None:
+    def save(outputs: list['CppOutput'], prefix: str) -> None:
         for output in outputs:
             path = os.path.join(prefix, output.rel_path)
             content = THIS_FILE_IS_AUTOGENERATED + output.content
@@ -81,7 +80,7 @@ def make_env() -> jinja2.Environment:
 JINJA_ENV = make_env()
 
 
-def render(spec: types.ClientSpec, context: Context) -> List[CppOutput]:
+def render(spec: types.ClientSpec, context: Context) -> list[CppOutput]:
     assert '-' not in spec.cpp_namespace
     env = {
         'spec': spec,
@@ -113,7 +112,7 @@ def render(spec: types.ClientSpec, context: Context) -> List[CppOutput]:
         filepath = cpp_type.json_schema.source_location().filepath
         vfilepath_map[filepath] = 'clients/{}/{}'.format(
             spec.client_name,
-            filepath.split('/')[-1],
+            filepath,
         )
 
     # C++ types files
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.cpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.cpp.jinja
index 9baab975dfd9..ac3719233454 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.cpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.cpp.jinja
@@ -21,6 +21,9 @@ ClientImpl::ClientImpl(const USERVER_NAMESPACE::chaotic::openapi::client::Config
           const USERVER_NAMESPACE::chaotic::openapi::client::CommandControl& command_control
       ) {
         auto r = http_client_.CreateRequest();
+        if (plugins_) {
+            r.SetPluginsList(*plugins_);
+        }
         ApplyConfig(r, command_control, config_);
         
         {% if not op.empty_request() -%}
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.hpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.hpp.jinja
index 85ae34f81813..26ee612ee375 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.hpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/client_impl.hpp.jinja
@@ -47,11 +47,16 @@ public:
     middleware_manager_.RegisterMiddleware(middleware);
   }
 
+  void SetPlugins(std::optional<std::vector<USERVER_NAMESPACE::utils::NotNull<USERVER_NAMESPACE::clients::http::Plugin*>>> plugins) {
+    plugins_ = std::move(plugins);
+  }
+
 private:
   USERVER_NAMESPACE::chaotic::openapi::client::Config config_;
   USERVER_NAMESPACE::clients::http::Client& http_client_;
   USERVER_NAMESPACE::chaotic::openapi::MiddlewareManager middleware_manager_;
   std::unordered_map<std::string, std::shared_ptr<USERVER_NAMESPACE::chaotic::openapi::client::Middleware>> middlewares_;
+  std::optional<std::vector<USERVER_NAMESPACE::utils::NotNull<USERVER_NAMESPACE::clients::http::Plugin*>>> plugins_;
 };
 
 }
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/component.cpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/component.cpp.jinja
index fed655854bd3..a30c75de6073 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/component.cpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/component.cpp.jinja
@@ -2,6 +2,8 @@
 
 #include <userver/chaotic/openapi/client/config.hpp>
 #include <userver/chaotic/openapi/client/middleware_factory.hpp>
+#include <userver/clients/http/plugin.hpp>
+#include <userver/clients/http/plugin_component.hpp>
 #include <userver/components/component_context.hpp>
 #include <userver/yaml_config/merge_schemas.hpp>
 
@@ -26,11 +28,23 @@ Component::Component(const USERVER_NAMESPACE::components::ComponentConfig& confi
     if (config.HasMember("middlewares")) {
         const auto& mw_config = config["middlewares"];
         
-        for (const auto& [name, config] : Items(mw_config)) {
+        for (const auto& [name, config] : USERVER_NAMESPACE::formats::common::Items(mw_config)) {
             auto &factory = context.FindComponent<USERVER_NAMESPACE::chaotic::openapi::client::MiddlewareFactory>("chaotic-client-middleware-" + name);
             auto middleware = factory.Create(config);
             client_.RegisterMiddleware(middleware);
         }
+
+        const auto& names = config["plugins"].As<std::optional<std::vector<std::string>>>(std::nullopt);
+        std::optional<std::vector<USERVER_NAMESPACE::utils::NotNull<USERVER_NAMESPACE::clients::http::Plugin*>>> plugins;
+        if (names) {
+            plugins.emplace();
+            for (const auto& name : *names) {
+                auto& component =
+                    context.FindComponent<USERVER_NAMESPACE::clients::http::plugin::ComponentBase>(std::string{"http-client-plugin-"} + name);
+                plugins->emplace_back(&component.GetPlugin());
+            }
+        }
+        client_.SetPlugins(std::move(plugins));
     }
 }
 
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/exceptions.hpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/exceptions.hpp.jinja
index 8f432cd5e31d..ec5f62ff28ed 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/exceptions.hpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/exceptions.hpp.jinja
@@ -38,7 +38,7 @@ class TimeoutException: public USERVER_NAMESPACE::chaotic::openapi::client::Time
 namespace {{ op.cpp_namespace() }} {
 
 /// @brief Base exception class for all client {{ op.method }} operations with URL '{{ op.path }}'
-class Exception: public {{ namespace }}::Exception {
+class Exception: public ::{{ namespace }}::Exception {
  public:
     const char* what() const noexcept override;
 
@@ -50,17 +50,17 @@ class Exception: public {{ namespace }}::Exception {
 /// @brief Error response with ErrorKind for all client {{ op.method }} operations with URL '{{ op.path }}'
 class HttpException
     : public Exception
-    , public {{ namespace }}::HttpException
+    , public ::{{ namespace }}::HttpException
 {
   public:
-    using {{ namespace }}::HttpException::HttpException;
+    using ::{{ namespace }}::HttpException::HttpException;
     ~HttpException();
 };
 
 /// @brief Timeout exception class for all client {{ op.method }} operations with URL '{{ op.path }}'
 class TimeoutException
     : public HttpException
-    , public {{ namespace }}::TimeoutException
+    , public ::{{ namespace }}::TimeoutException
 {
   public:
     TimeoutException();
@@ -70,10 +70,10 @@ class TimeoutException
 /// @brief Error response with HTTP status code for all client {{ op.method }} operations with URL '{{ op.path }}'
 class ExceptionWithStatusCode
     : public Exception
-    , public {{ namespace }}::ExceptionWithStatusCode
+    , public ::{{ namespace }}::ExceptionWithStatusCode
 {
   public:
-    using {{ namespace }}::ExceptionWithStatusCode::ExceptionWithStatusCode;
+    using ::{{ namespace }}::ExceptionWithStatusCode::ExceptionWithStatusCode;
     ~ExceptionWithStatusCode();
 };
 
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.cpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.cpp.jinja
index 772147b235b5..d0cc7d4e1a6e 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.cpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.cpp.jinja
@@ -8,6 +8,7 @@
 #include <userver/chaotic/openapi/parameters_write.hpp>
 #include <userver/formats/json/value_builder.hpp>
 #include <userver/http/common_headers.hpp>
+#include <userver/utils/trivial_map.hpp>
 #include <userver/http/url.hpp>
 #include <userver/clients/http/form.hpp>
 #include <userver/chaotic/openapi/form.hpp>
@@ -25,6 +26,22 @@ namespace openapi = USERVER_NAMESPACE::chaotic::openapi;
     static constexpr openapi::Name k{{ parameter.cpp_name }} = "{{ parameter.raw_name }}";
 {% endfor %}
 
+{% if op.has_any_hidden_query_parameters() %}
+    constexpr utils::TrivialSet kHiddenQueries = [](auto selector) {
+        return selector()
+            {% for parameter in op.parameters %}
+                {% if parameter.query_log_mode_hide %}
+                    .Case(k{{ parameter.cpp_name }})
+                {% endif %}
+            {% endfor %}
+        ;
+    };
+
+    bool IsHiddenQueryArg(std::string_view str) {
+        return kHiddenQueries.Contains(str);
+    }
+{% endif %}
+
 void SerializeRequest(const Request& request, const std::string& base_url, USERVER_NAMESPACE::clients::http::Request& http_request)
 {
   {# parameters #}
@@ -32,6 +49,11 @@ void SerializeRequest(const Request& request, const std::string& base_url, USERV
     http_request,
     base_url + "{{ op.path }}"
   );
+
+  {% if op.has_any_hidden_query_parameters() %}
+    sink.SetHiddenQueryArgNamesFunc(&IsHiddenQueryArg);
+  {% endif %}
+
   {% for parameter in op.parameters %}
     {% if parameter.required %}
       openapi::WriteParameter<{{ parameter.parser }}>(request.{{ parameter.cpp_name}}, sink);
@@ -71,6 +93,12 @@ void SerializeRequest(const Request& request, const std::string& base_url, USERV
   {% endif %}
 
   sink.Flush();
+
+  {# middlewares #}
+  {% for mw in op.middlewares %}
+      {{ mw.write_member_command('request', 'sink', 'http_request') }}
+  {% endfor %}
+
 }
 
 } // namespace
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.hpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.hpp.jinja
index 5119ff7189ef..fbf4d4b4534a 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.hpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/requests.hpp.jinja
@@ -5,6 +5,9 @@
 #pragma once
 
 #include <string>
+{% if spec.has_array_in_request_body() %}
+#include <userver/formats/serialize/common_containers.hpp>
+{% endif %}
 {% if spec.has_multiple_content_type_request() %}
 #include <variant>
 {% endif %}
@@ -46,6 +49,7 @@ namespace {{ namespace }} {
           {% endfor %}
         >;
       {% endif %}
+
         struct Request {
           {% for parameter in op.parameters %}
               {% if parameter.cpp_type.nullable %}
@@ -55,6 +59,11 @@ namespace {{ namespace }} {
               {% endif -%}
               {{ parameter.cpp_name }};
           {% endfor %}
+
+          {% for mw in op.middlewares %}
+              {{ mw.request_member_cpp_type }} {{ mw.request_member_name }};
+          {% endfor %}
+
           {% if op.request_bodies %}
               Body body;
           {% endif %}
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/responses.cpp.jinja b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/responses.cpp.jinja
index d5d7728be1b9..78d74ad335cb 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/responses.cpp.jinja
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/templates/responses.cpp.jinja
@@ -5,6 +5,7 @@
 #include <userver/http/common_headers.hpp>
 #include <userver/http/content_type.hpp>
 #include <userver/logging/log.hpp>
+#include <userver/chaotic/openapi/parameters_read.hpp>
 
 {% for include in spec.responses_definitions_includes() %}
   #include <{{ include }}>
@@ -67,7 +68,10 @@ namespace {{ namespace }} {
               static const USERVER_NAMESPACE::http::headers::PredefinedHeader kHeader("{{ header.raw_name }}");
               auto it = http_response.headers().find(kHeader);
               if (it != http_response.headers().end()) {
-                r.{{ header.cpp_name }} = it->second;
+                namespace openapi = chaotic::openapi;
+                static constexpr openapi::Name k{{ header.cpp_name }} = "{{ header.raw_name }}";
+                using Header = {{ header.parser }};
+                r.{{ header.cpp_name }} = openapi::ParseParameter<Header::Base>::Parse(std::string{it->second});
               }
             }
             {% endfor %}
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/translator.py b/chaotic-openapi/chaotic_openapi/back/cpp_client/translator.py
index 745e78c7c6b8..f9747de6d204 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/translator.py
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/translator.py
@@ -1,6 +1,7 @@
 import re
+import sys
+import traceback
 import typing
-from typing import List
 from typing import Union
 
 from chaotic import cpp_names
@@ -9,7 +10,9 @@
 from chaotic.back.cpp import types as cpp_types
 from chaotic.front import ref_resolver
 from chaotic.front import types as chaotic_types
+from chaotic_openapi.back.cpp_client import middleware
 from chaotic_openapi.back.cpp_client import types
+from chaotic_openapi.front import base_model
 from chaotic_openapi.front import model
 
 
@@ -20,7 +23,8 @@ def __init__(
         *,
         cpp_namespace: str,
         dynamic_config: str,
-        include_dirs: List[str],
+        include_dirs: list[str],
+        middleware_plugins: list[middleware.MiddlewarePlugin],
     ) -> None:
         self._spec = types.ClientSpec(
             client_name=service.name,
@@ -30,7 +34,26 @@ def __init__(
             operations=[],
             schemas={},
         )
+        self._include_dirs = include_dirs
+        self._middleware_plugins = middleware_plugins
+
+        try:
+            self.translate(service)
+        except chaotic_error.BaseError:
+            raise
+        except BaseException as exc:
+            print(traceback.format_exc(), file=sys.stderr)
+            raise chaotic_error.BaseError(
+                full_filepath=f'<{service.name}>',
+                infile_path='',
+                schema_type='openapi/swagger',
+                msg=str(exc),
+            )
 
+    def translate(
+        self,
+        service: model.Service,
+    ) -> None:
         # components/schemas
         parsed_schemas = chaotic_types.ParsedSchemas(
             schemas={str(schema.source_location()): schema for schema in service.schemas.values()},
@@ -40,7 +63,7 @@ def __init__(
             chaotic_translator.GeneratorConfig(
                 namespaces={schema.source_location().filepath: '' for schema in service.schemas.values()},
                 infile_to_name_func=self.map_infile_path_to_cpp_type,
-                include_dirs=include_dirs,
+                include_dirs=self._include_dirs,
             )
         )
         self._spec.schemas = gen.generate_types(resolved_schemas)
@@ -63,10 +86,12 @@ def __init__(
             op = types.Operation(
                 method=operation.method.upper(),
                 path=operation.path,
+                operation_id=operation.operationId,
                 description=operation.description,
                 parameters=[self._translate_parameter(parameter) for parameter in operation.parameters],
                 request_bodies=request_bodies,
                 responses=[self._translate_response(r, status) for status, r in operation.responses.items()],
+                middlewares=self._translate_middlewares(operation.x_middlewares),
             )
             self._spec.operations.append(op)
 
@@ -77,13 +102,21 @@ def map_infile_path_to_cpp_type(self, name: str, stem: str) -> str:
         if name.startswith('/components/schemas/'):
             return '{}::{}'.format(
                 self._spec.cpp_namespace,
-                name.split('/')[-1],
+                cpp_names.cpp_identifier(name.split('/')[-1]),
             )
 
         if name.startswith('/definitions/'):
             return '{}::{}'.format(
                 self._spec.cpp_namespace,
-                name.split('/')[-1],
+                cpp_names.cpp_identifier(name.split('/')[-1]),
+            )
+
+        match = re.fullmatch('/paths/\\[([^\\]]*)\\]/([a-zA-Z]*)/requestBody(/schema)?', name)
+        if match:
+            return '{}::{}::{}::Body'.format(
+                self._spec.cpp_namespace,
+                cpp_names.namespace(match.group(1)),
+                types.map_method(match.group(2)),
             )
 
         match = re.fullmatch('/paths/\\[([^\\]]*)\\]/([a-zA-Z]*)/requestBody/content/\\[([^\\]]*)\\]/schema', name)
@@ -121,6 +154,16 @@ def map_infile_path_to_cpp_type(self, name: str, stem: str) -> str:
                 ),
             )
 
+        match = re.fullmatch('/components/responses/([-a-zA-Z_0-9]*)/headers/([^/]*)/schema', name)
+        if match:
+            return '{}::Response{}Header{}'.format(
+                self._spec.cpp_namespace,
+                match.group(1),
+                cpp_names.camel_case(
+                    cpp_names.cpp_identifier(match.group(2)),
+                ),
+            )
+
         match = re.fullmatch('/paths/\\[([^\\]]*)\\]/([a-zA-Z]*)/parameters/([0-9]*)(/schema)?', name)
         if match:
             return '{}::{}::{}::Parameter{}'.format(
@@ -205,6 +248,7 @@ def _translate_single_schema(self, schema: chaotic_types.Schema) -> cpp_types.Cp
             chaotic_translator.GeneratorConfig(
                 namespaces={schema.source_location().filepath: ''},
                 infile_to_name_func=self.map_infile_path_to_cpp_type,
+                include_dirs=self._include_dirs,
             )
         )
         gen_types = gen.generate_types(
@@ -231,13 +275,14 @@ def _translate_response(
         for name, header in response.headers.items():
             headers.append(self._translate_parameter(header))
 
+        body = {}
+        for content_type, schema in response.content.items():
+            assert isinstance(schema.schema, chaotic_types.Schema)
+            body[content_type] = self._translate_single_schema(schema.schema)
         return types.Response(
             status=status,
             headers=headers,
-            body={
-                content_type: self._translate_single_schema(schema.schema)
-                for content_type, schema in response.content.items()
-            },
+            body=body,
         )
 
     def _translate_request_body(self, request_body: model.RequestBody) -> types.Body:
@@ -274,7 +319,9 @@ def _validate_primitive_object(self, schema: cpp_types.CppType) -> None:
     def _translate_parameter(self, parameter: model.Parameter) -> types.Parameter:
         in_ = parameter.in_
         in_str = in_[0].title() + in_[1:]
-        cpp_name = cpp_names.cpp_identifier(parameter.name)
+        cpp_name = cpp_names.cpp_identifier(
+            parameter.x_cpp_name or parameter.name,
+        )
 
         if isinstance(parameter.schema, chaotic_types.Array):
             delimiter = {
@@ -309,7 +356,26 @@ def _translate_parameter(self, parameter: model.Parameter) -> types.Parameter:
             cpp_type=cpp_type,
             parser=parser,
             required=parameter.required,
+            query_log_mode_hide=parameter.x_query_log_mode_hide,
         )
 
+    def _translate_middlewares(self, middlewares: base_model.XMiddlewares) -> list[middleware.Middleware]:
+        extra_members = middlewares.__pydantic_extra__ or {}
+
+        result = []
+        for plugin in self._middleware_plugins:
+            field = plugin.field
+            if field not in extra_members:
+                continue
+
+            mw = plugin.create({field: extra_members[field]})
+            result.append(mw)
+            del extra_members[field]
+
+        if extra_members:
+            raise Exception(f'Unknown member(s) in x-taxi-middlewares: {extra_members}')
+
+        return result
+
     def spec(self) -> types.ClientSpec:
         return self._spec
diff --git a/chaotic-openapi/chaotic_openapi/back/cpp_client/types.py b/chaotic-openapi/chaotic_openapi/back/cpp_client/types.py
index 3f13c23230d2..be4e6d5a99a8 100644
--- a/chaotic-openapi/chaotic_openapi/back/cpp_client/types.py
+++ b/chaotic-openapi/chaotic_openapi/back/cpp_client/types.py
@@ -1,13 +1,12 @@
 import dataclasses
-from typing import Dict
 from typing import Generator
-from typing import List
 from typing import Optional
-from typing import Set
+from typing import Union
 
 from chaotic import cpp_names
 from chaotic import error
 from chaotic.back.cpp import types as cpp_types
+from . import middleware
 
 
 @dataclasses.dataclass
@@ -19,14 +18,15 @@ class Parameter:
     parser: str
     required: bool
 
-    def declaration_includes(self) -> List[str]:
+    query_log_mode_hide: bool
+
+    def declaration_includes(self) -> list[str]:
         # TODO
         if not self.required:
             return ['optional']
         return []
 
-    @classmethod
-    def _validate_schema(cls, schema: cpp_types.CppType, *, is_array_allowed: bool) -> None:
+    def _validate_schema(self, schema: cpp_types.CppType, *, is_array_allowed: bool) -> None:
         assert schema.json_schema
         if not is_array_allowed and isinstance(schema, cpp_types.CppArray):
             source_location = schema.json_schema.source_location()
@@ -53,17 +53,28 @@ def _validate_schema(cls, schema: cpp_types.CppType, *, is_array_allowed: bool)
                 full_filepath=source_location.filepath,
                 infile_path=source_location.location,
                 schema_type='jsonschema',
-                msg='Unsupported parameter type',
+                msg=f'Unsupported parameter type for parameter "{self.raw_name}"',
             )
 
         if isinstance(schema, cpp_types.CppRef):
-            cls._validate_schema(schema.orig_cpp_type, is_array_allowed=is_array_allowed)
+            self._validate_schema(schema.orig_cpp_type, is_array_allowed=is_array_allowed)
         if isinstance(schema, cpp_types.CppArray):
-            cls._validate_schema(schema.items, is_array_allowed=False)
+            self._validate_schema(schema.items, is_array_allowed=False)
 
     def __post_init__(self) -> None:
         self._validate_schema(self.cpp_type, is_array_allowed=True)
 
+    # TODO: for handler only
+    def span_value(self) -> str:
+        if self.required:
+            arg = self.cpp_name
+        else:
+            arg = '*' + self.cpp_name
+        if self.cpp_type.cpp_user_name() == 'std::string':
+            return arg
+        else:
+            return f'::fmt::format("{{}}", {arg})'
+
 
 @dataclasses.dataclass
 class Body:
@@ -79,8 +90,8 @@ def cpp_name(self) -> str:
 @dataclasses.dataclass
 class Response:
     status: int
-    body: Dict[str, cpp_types.CppType]
-    headers: List[Parameter] = dataclasses.field(default_factory=list)
+    body: dict[str, cpp_types.CppType]
+    headers: list[Parameter] = dataclasses.field(default_factory=list)
 
     def is_error(self) -> bool:
         return self.status >= 400
@@ -108,18 +119,25 @@ def map_method(method: str) -> str:
 class Operation:
     method: str
     path: str
+    operation_id: Union[str, None]
 
     description: str = ''
-    parameters: List[Parameter] = dataclasses.field(default_factory=list)
-    request_bodies: List[Body] = dataclasses.field(default_factory=list)
-    responses: List[Response] = dataclasses.field(default_factory=list)
+    parameters: list[Parameter] = dataclasses.field(default_factory=list)
+    request_bodies: list[Body] = dataclasses.field(default_factory=list)
+    responses: list[Response] = dataclasses.field(default_factory=list)
 
     client_generate: bool = True
 
+    middlewares: list[middleware.Middleware] = dataclasses.field(default_factory=list)
+
     def cpp_namespace(self) -> str:
+        if self.operation_id:
+            return cpp_names.namespace(self.operation_id)
         return cpp_names.namespace(self.path) + '::' + map_method(self.method)
 
     def cpp_method_name(self) -> str:
+        if self.operation_id:
+            return self.operation_id
         return cpp_names.camel_case(
             cpp_names.namespace(self.path) + '_' + map_method(self.method),
         )
@@ -148,6 +166,12 @@ def iter_error_responses(self) -> Generator[Response, None, None]:
             if response.is_error():
                 yield response
 
+    def has_any_hidden_query_parameters(self) -> bool:
+        for parameter in self.parameters:
+            if parameter.query_log_mode_hide:
+                return True
+        return False
+
 
 @dataclasses.dataclass
 class ClientSpec:
@@ -155,12 +179,12 @@ class ClientSpec:
     cpp_namespace: str
     dynamic_config: str
     description: str = ''
-    operations: List[Operation] = dataclasses.field(default_factory=list)
+    operations: list[Operation] = dataclasses.field(default_factory=list)
 
     # Internal types which cannot be referred to
-    internal_schemas: Dict[str, cpp_types.CppType] = dataclasses.field(default_factory=dict)
+    internal_schemas: dict[str, cpp_types.CppType] = dataclasses.field(default_factory=dict)
     # Types which can be referred to
-    schemas: Dict[str, cpp_types.CppType] = dataclasses.field(default_factory=dict)
+    schemas: dict[str, cpp_types.CppType] = dataclasses.field(default_factory=dict)
 
     def has_multiple_content_type_request(self) -> bool:
         for op in self.operations:
@@ -168,8 +192,15 @@ def has_multiple_content_type_request(self) -> bool:
                 return True
         return False
 
-    def requests_declaration_includes(self) -> List[str]:
-        includes: Set[str] = set()
+    def has_array_in_request_body(self) -> bool:
+        for op in self.operations:
+            for body in op.request_bodies:
+                if isinstance(body.schema, cpp_types.CppArray):
+                    return True
+        return False
+
+    def requests_declaration_includes(self) -> list[str]:
+        includes: set[str] = set()
         for op in self.operations:
             if not op.client_generate:
                 continue
@@ -180,10 +211,13 @@ def requests_declaration_includes(self) -> List[str]:
             for param in op.parameters:
                 includes.update(param.declaration_includes())
 
+            for mw in op.middlewares:
+                includes.update(mw.requests_hpp_includes)
+
         return sorted(includes)
 
-    def responses_declaration_includes(self) -> List[str]:
-        includes: Set[str] = set()
+    def responses_declaration_includes(self) -> list[str]:
+        includes: set[str] = set()
         for op in self.operations:
             if not op.client_generate:
                 continue
@@ -195,8 +229,8 @@ def responses_declaration_includes(self) -> List[str]:
                     includes.update(header.declaration_includes())
         return sorted(includes)
 
-    def responses_definitions_includes(self) -> List[str]:
-        includes: Set[str] = set()
+    def responses_definitions_includes(self) -> list[str]:
+        includes: set[str] = set()
         for op in self.operations:
             if not op.client_generate:
                 continue
@@ -206,7 +240,7 @@ def responses_definitions_includes(self) -> List[str]:
                     includes.update(body.definition_includes())
         return sorted(includes)
 
-    def cpp_includes(self) -> List[str]:
+    def cpp_includes(self) -> list[str]:
         includes = []
         for cpp_type in self.extract_cpp_types().values():
             assert cpp_type.json_schema
@@ -214,12 +248,12 @@ def cpp_includes(self) -> List[str]:
             includes.append(
                 'clients/{}/{}.hpp'.format(
                     self.client_name,
-                    filepath.split('/')[-1].split('.')[0],
+                    filepath.rsplit('.', 1)[0],
                 ),
             )
         return includes
 
-    def extract_cpp_types(self) -> Dict[str, cpp_types.CppType]:
+    def extract_cpp_types(self) -> dict[str, cpp_types.CppType]:
         types = self.schemas.copy()
         types.update(self.internal_schemas)
 
diff --git a/chaotic-openapi/chaotic_openapi/back/linter/validators.py b/chaotic-openapi/chaotic_openapi/back/linter/validators.py
index e0ae6d6ee1c3..10df136ec8a5 100644
--- a/chaotic-openapi/chaotic_openapi/back/linter/validators.py
+++ b/chaotic-openapi/chaotic_openapi/back/linter/validators.py
@@ -26,7 +26,6 @@ def validate_nonobject_body(service: model.Service) -> None:
             if not isinstance(
                 schema, (types.SchemaObject, types.OneOfWithDiscriminator, types.OneOfWithoutDiscriminator)
             ):
-                print(schema, file=sys.stderr)
                 report_error('non-object-body', schema.source_location(), 'Non-object type in body root is forbidden')
 
 
diff --git a/chaotic-openapi/chaotic_openapi/front/base_model.py b/chaotic-openapi/chaotic_openapi/front/base_model.py
index 527cfbe141e7..fd147d5c1a81 100644
--- a/chaotic-openapi/chaotic_openapi/front/base_model.py
+++ b/chaotic-openapi/chaotic_openapi/front/base_model.py
@@ -1,12 +1,11 @@
 from typing import Any
-from typing import List
 
 import pydantic
 
 
 class BaseModel(pydantic.BaseModel):
     model_config = pydantic.ConfigDict(extra='allow')
-    _model_userver_tags: List[str] = []
+    _model_userver_tags: list[str] = []
 
     def model_post_init(self, context: Any) -> None:
         super().model_post_init(context)
@@ -14,7 +13,9 @@ def model_post_init(self, context: Any) -> None:
         if not self.__pydantic_extra__:
             return
         for field in self.__pydantic_extra__:
-            if field.startswith('x-taxi-py3-'):
+            if field.startswith('x-taxi-py3'):
+                continue
+            if field.startswith('x-taxi-go-'):
                 continue
             if field.startswith('x-taxi-') or field.startswith('x-usrv-'):
                 assert field in self._model_userver_tags, f'Field {field} is not allowed in this context'
@@ -23,3 +24,11 @@ def model_post_init(self, context: Any) -> None:
             if field.startswith('x-'):
                 continue
             raise Exception(f'Unknown field "{field}"')
+
+
+class XMiddlewares(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(extra='allow')
+
+    tvm: bool = True
+
+    # TODO: validate field set
diff --git a/chaotic-openapi/chaotic_openapi/front/model.py b/chaotic-openapi/chaotic_openapi/front/model.py
index 73799c1b9fbd..b6f17b696438 100644
--- a/chaotic-openapi/chaotic_openapi/front/model.py
+++ b/chaotic-openapi/chaotic_openapi/front/model.py
@@ -1,12 +1,11 @@
 import dataclasses
 import enum
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 from typing import Union
 
 from chaotic.front import types
+from . import base_model
 
 
 class In(str, enum.Enum):
@@ -32,7 +31,7 @@ class Parameter:
     name: str
     in_: In
     description: str
-    examples: Dict[str, Any]
+    examples: dict[str, Any]
 
     deprecated: bool
     required: bool
@@ -41,18 +40,21 @@ class Parameter:
     style: Style
     schema: types.Schema
 
+    x_cpp_name: Optional[str]
+    x_query_log_mode_hide: bool
+
 
 @dataclasses.dataclass
 class MediaType:
-    schema: Union[types.Schema, types.Ref]
-    examples: Dict[str, Any]
+    schema: Union[types.Schema, types.Ref, None]
+    examples: dict[str, Any]
 
 
 @dataclasses.dataclass
 class Response:
     description: str
-    headers: Dict[str, Parameter]
-    content: Dict[str, MediaType]
+    headers: dict[str, Parameter]
+    content: dict[str, MediaType]
 
 
 @dataclasses.dataclass
@@ -87,7 +89,7 @@ class ApiKeySecurity(Security):
 @dataclasses.dataclass
 class Flow:
     refreshUrl: str
-    scopes: Dict[str, str]
+    scopes: dict[str, str]
 
 
 @dataclasses.dataclass
@@ -113,7 +115,7 @@ class AuthCodeFlow(Flow):
 
 @dataclasses.dataclass
 class OAuthSecurity(Security):
-    flows: List[Flow]
+    flows: list[Flow]
 
 
 @dataclasses.dataclass
@@ -132,22 +134,25 @@ class Operation:
     description: str
     path: str
     method: str
-    operationId: str
-    parameters: List[Parameter]
-    requestBody: Union[List[RequestBody], Ref]
-    responses: Dict[int, Union[Response, Ref]]
-    security: List[Security]
+    operationId: Union[str, None]
+    parameters: list[Parameter]
+    requestBody: Union[list[RequestBody], Ref]
+    responses: dict[int, Union[Response, Ref]]
+    security: list[Security]
+
+    x_client_codegen: bool
+    x_middlewares: base_model.XMiddlewares
 
 
 @dataclasses.dataclass
 class Service:
     name: str
     description: str = ''
-    operations: List[Operation] = dataclasses.field(default_factory=list)
-
-    schemas: Dict[str, types.Schema] = dataclasses.field(default_factory=dict)
-    responses: Dict[str, Response] = dataclasses.field(default_factory=dict)
-    parameters: Dict[str, Parameter] = dataclasses.field(default_factory=dict)
-    headers: Dict[str, Parameter] = dataclasses.field(default_factory=dict)
-    requestBodies: Dict[str, List[RequestBody]] = dataclasses.field(default_factory=dict)
-    security: Dict[str, Security] = dataclasses.field(default_factory=dict)
+    operations: list[Operation] = dataclasses.field(default_factory=list)
+
+    schemas: dict[str, types.Schema] = dataclasses.field(default_factory=dict)
+    responses: dict[str, Response] = dataclasses.field(default_factory=dict)
+    parameters: dict[str, Parameter] = dataclasses.field(default_factory=dict)
+    headers: dict[str, Parameter] = dataclasses.field(default_factory=dict)
+    requestBodies: dict[str, list[RequestBody]] = dataclasses.field(default_factory=dict)
+    security: dict[str, Security] = dataclasses.field(default_factory=dict)
diff --git a/chaotic-openapi/chaotic_openapi/front/openapi.py b/chaotic-openapi/chaotic_openapi/front/openapi.py
index 9e8216aa8dd2..718f8d6f60b3 100644
--- a/chaotic-openapi/chaotic_openapi/front/openapi.py
+++ b/chaotic-openapi/chaotic_openapi/front/openapi.py
@@ -1,7 +1,5 @@
 import enum
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 from typing import Union
 
@@ -25,7 +23,7 @@ class Info(base_model.BaseModel):
 class Server(base_model.BaseModel):
     url: str
     description: Optional[str] = None
-    variables: Dict[str, Any] = pydantic.Field(default_factory=dict)
+    variables: dict[str, Any] = pydantic.Field(default_factory=dict)
 
 
 Schema = Any
@@ -54,15 +52,20 @@ class Header(base_model.BaseModel):
     allowReserved: bool = False
     schema_: Schema = pydantic.Field(alias='schema')
     example: Any = None
-    examples: Dict[str, Any] = pydantic.Field(default_factory=dict)
+    examples: dict[str, Any] = pydantic.Field(default_factory=dict)
 
 
 # https://spec.openapis.org/oas/v3.0.0.html#media-type-object
 class MediaType(base_model.BaseModel):
     schema_: Schema = pydantic.Field(alias='schema', default=None)
     example: Any = None
-    examples: Dict[str, Any] = pydantic.Field(default_factory=dict)
-    # encoding: Dict[str, Encoding] = {}
+    examples: dict[str, Any] = pydantic.Field(default_factory=dict)
+    # encoding: dict[str, Encoding] = {}
+
+    _model_userver_tags: list[str] = [
+        'x-taxi-non-std-type-reason',
+        'x-usrv-non-std-type-reason',
+    ]
 
 
 # https://spec.openapis.org/oas/v3.0.0.html#reference-object
@@ -73,10 +76,15 @@ class Ref(base_model.BaseModel):
 # https://spec.openapis.org/oas/v3.0.0.html#responses-object
 class Response(base_model.BaseModel):
     description: str
-    headers: Dict[str, Union[Header, Ref]] = pydantic.Field(default_factory=dict)
-    content: Dict[str, MediaType] = pydantic.Field(default_factory=dict)
+    headers: dict[str, Union[Header, Ref]] = pydantic.Field(default_factory=dict)
+    content: dict[str, MediaType] = pydantic.Field(default_factory=dict)
     # TODO: links
 
+    def model_post_init(self, context: Any, /) -> None:
+        if 'application/json' in self.content and not self.content['application/json'].schema_:
+            # empty application/json means the same "no body"
+            del self.content['application/json']
+
 
 class In(str, enum.Enum):
     path = 'path'
@@ -85,6 +93,11 @@ class In(str, enum.Enum):
     cookie = 'cookie'
 
 
+class QueryLogMode(str, enum.Enum):
+    show = 'show'
+    hide = 'hide'
+
+
 # https://spec.openapis.org/oas/v3.0.0.html#parameter-object
 class Parameter(base_model.BaseModel):
     name: str
@@ -99,9 +112,26 @@ class Parameter(base_model.BaseModel):
     allowReserved: bool = False
     schema_: Schema = pydantic.Field(alias='schema')
     example: Any = None
-    examples: Dict[str, Any] = pydantic.Field(default_factory=dict)
+    examples: dict[str, Any] = pydantic.Field(default_factory=dict)
 
-    # content: Dict[str, MediaType] = {}
+    # content: dict[str, MediaType] = {}
+
+    x_handler_tag: Optional[str] = pydantic.Field(
+        default=None,
+        validation_alias=pydantic.AliasChoices('x-taxi-handler-tag', 'x-usrv-handler-tag'),
+    )
+    x_cpp_name: Optional[str] = pydantic.Field(
+        default=None,
+        validation_alias=pydantic.AliasChoices('x-taxi-cpp-name', 'x-usrv-cpp-name'),
+    )
+    x_query_log_mode: QueryLogMode = pydantic.Field(
+        default=QueryLogMode.show,
+        validation_alias=pydantic.AliasChoices('x-taxi-query-log-mode', 'x-usrv-query-log-mode'),
+    )
+    x_explode_true_reason: str = pydantic.Field(
+        default='',
+        validation_alias=pydantic.AliasChoices('x-taxi-explode-true-reason', 'x-usrv-explode-true-reason'),
+    )
 
     def model_post_init(self, context: Any, /) -> None:
         super().model_post_init(context)
@@ -119,7 +149,7 @@ def model_post_init(self, context: Any, /) -> None:
 # https://spec.openapis.org/oas/v3.0.0.html#request-body-object
 class RequestBody(base_model.BaseModel):
     description: Optional[str] = None
-    content: Dict[str, MediaType]
+    content: dict[str, MediaType]
     required: bool = False
 
 
@@ -138,25 +168,25 @@ class SecurityIn(str, enum.Enum):
 
 class ImplicitFlow(base_model.BaseModel):
     refreshUrl: Optional[str] = None
-    scopes: Dict[str, str] = pydantic.Field(default_factory=dict)
+    scopes: dict[str, str] = pydantic.Field(default_factory=dict)
     authorizationUrl: str
 
 
 class PasswordFlow(base_model.BaseModel):
     refreshUrl: Optional[str] = None
-    scopes: Dict[str, str] = pydantic.Field(default_factory=dict)
+    scopes: dict[str, str] = pydantic.Field(default_factory=dict)
     tokenUrl: str
 
 
 class ClientCredFlow(base_model.BaseModel):
     refreshUrl: Optional[str] = None
-    scopes: Dict[str, str] = pydantic.Field(default_factory=dict)
+    scopes: dict[str, str] = pydantic.Field(default_factory=dict)
     tokenUrl: str
 
 
 class AuthCodeFlow(base_model.BaseModel):
     refreshUrl: Optional[str] = None
-    scopes: Dict[str, str] = pydantic.Field(default_factory=dict)
+    scopes: dict[str, str] = pydantic.Field(default_factory=dict)
     authorizationUrl: str
     tokenUrl: str
 
@@ -199,47 +229,65 @@ def model_post_init(self, context: Any, /) -> None:
                 raise ValueError(errors.missing_field_msg('openIdConnectUrl'))
 
 
-SecuritySchemes = Dict[str, Union[SecurityScheme, Ref]]
+SecuritySchemes = dict[str, Union[SecurityScheme, Ref]]
 
 
 # https://spec.openapis.org/oas/v3.0.0.html#security-requirement-object
-Security = Dict[str, List[str]]
+Security = dict[str, list[str]]
 
 
 # https://spec.openapis.org/oas/v3.0.0.html#components-object
 class Components(base_model.BaseModel):
-    schemas: Dict[str, Schema] = pydantic.Field(default_factory=dict)
-    requests: Dict[str, Any] = pydantic.Field(default_factory=dict)  # TODO
-    responses: Dict[str, Response] = pydantic.Field(default_factory=dict)
-    parameters: Dict[str, Parameter] = pydantic.Field(default_factory=dict)
-    headers: Dict[str, Header] = pydantic.Field(default_factory=dict)
-    requestBodies: Dict[str, RequestBody] = pydantic.Field(default_factory=dict)
+    schemas: dict[str, Schema] = pydantic.Field(default_factory=dict)
+    requests: dict[str, Any] = pydantic.Field(default_factory=dict)  # TODO
+    responses: dict[str, Response] = pydantic.Field(default_factory=dict)
+    parameters: dict[str, Parameter] = pydantic.Field(default_factory=dict)
+    headers: dict[str, Header] = pydantic.Field(default_factory=dict)
+    requestBodies: dict[str, RequestBody] = pydantic.Field(default_factory=dict)
     securitySchemes: SecuritySchemes = pydantic.Field(default_factory=dict)
 
 
-class XTaxiMiddlewares(base_model.BaseModel):
-    tvm: bool = True
-
-
 # https://spec.openapis.org/oas/v3.0.0.html#operation-object
 class Operation(base_model.BaseModel):
-    tags: List[str] = pydantic.Field(default_factory=list)
+    tags: list[str] = pydantic.Field(default_factory=list)
     summary: Optional[str] = None
     description: str = ''
     externalDocs: Any = None
 
     operationId: Optional[str] = None
-    parameters: List[Union[Parameter, Ref]] = pydantic.Field(default_factory=list)
+    parameters: list[Union[Parameter, Ref]] = pydantic.Field(default_factory=list)
     requestBody: Optional[Union[RequestBody, Ref]] = None
-    responses: Dict[Union[str, int], Union[Response, Ref]]
+    responses: dict[Union[str, int], Union[Response, Ref]]
     deprecated: bool = False
     security: Optional[Security] = None
-    servers: List[Server] = pydantic.Field(default_factory=list)
+    servers: list[Server] = pydantic.Field(default_factory=list)
 
-    x_taxi_middlewares: Optional[XTaxiMiddlewares] = pydantic.Field(
+    x_taxi_middlewares: Optional[base_model.XMiddlewares] = pydantic.Field(
         default=None,
-        alias='x-taxi-middlewares',
+        validation_alias=pydantic.AliasChoices('x-taxi-middlewares', 'x-usrv-middlewares'),
+    )
+    x_taxi_handler_codegen: bool = pydantic.Field(
+        default=True,
+        validation_alias=pydantic.AliasChoices('x-taxi-handler-codegen', 'x-usrv-handler-codegen'),
+    )
+    x_query_log_mode: QueryLogMode = pydantic.Field(
+        default=QueryLogMode.show,
+        validation_alias=pydantic.AliasChoices('x-taxi-query-log-mode', 'x-usrv-query-log-mode'),
     )
+    x_client_codegen: bool = pydantic.Field(
+        default=True,
+        validation_alias=pydantic.AliasChoices('x-taxi-client-codegen', 'x-usrv-client-codegen'),
+    )
+
+    def model_post_init(self, context: Any, /) -> None:
+        super().model_post_init(context)
+
+        if self.x_query_log_mode == QueryLogMode.hide:
+            for parameter in self.parameters:
+                if not isinstance(parameter, Parameter):
+                    continue
+                if parameter.in_ == In.query:
+                    parameter.x_query_log_mode = QueryLogMode.hide
 
 
 # https://spec.openapis.org/oas/v3.0.0.html#path-item-object
@@ -256,8 +304,8 @@ class Path(base_model.BaseModel):
     patch: Optional[Operation] = None
     trace: Optional[Operation] = None
 
-    servers: List[Server] = pydantic.Field(default_factory=list)
-    parameters: List[Union[Parameter, Ref]] = pydantic.Field(default_factory=list)
+    servers: list[Server] = pydantic.Field(default_factory=list)
+    parameters: list[Union[Parameter, Ref]] = pydantic.Field(default_factory=list)
 
 
 class XTaxiClientQos(base_model.BaseModel):
@@ -268,20 +316,20 @@ class XTaxiClientQos(base_model.BaseModel):
 class OpenApi(base_model.BaseModel):
     openapi: str = '3.0.0'
     info: Optional[Info] = None
-    servers: List[Server] = pydantic.Field(default_factory=list)
-    paths: Dict[str, Path] = pydantic.Field(default_factory=dict)
+    servers: list[Server] = pydantic.Field(default_factory=list)
+    paths: dict[str, Path] = pydantic.Field(default_factory=dict)
     components: Components = Components()
     security: Security = pydantic.Field(default_factory=dict)
-    tags: List[Any] = pydantic.Field(default_factory=list)
+    tags: list[Any] = pydantic.Field(default_factory=list)
     externalDocs: Any = None
 
     x_taxi_client_qos: Optional[XTaxiClientQos] = pydantic.Field(
         default=None,
-        alias='x-taxi-client-qos',
+        validation_alias=pydantic.AliasChoices('x-taxi-client-qos', 'x-usrv-client-qos'),
     )
-    x_taxi_middlewares: Optional[XTaxiMiddlewares] = pydantic.Field(
+    x_taxi_middlewares: Optional[base_model.XMiddlewares] = pydantic.Field(
         default=None,
-        alias='x-taxi-middlewares',
+        validation_alias=pydantic.AliasChoices('x-taxi-middlewares', 'x-usrv-middlewares'),
     )
 
     def validate_security(self, security: Optional[Security]) -> None:
diff --git a/chaotic-openapi/chaotic_openapi/front/parser.py b/chaotic-openapi/chaotic_openapi/front/parser.py
index fecc7696d962..caa831714e29 100644
--- a/chaotic-openapi/chaotic_openapi/front/parser.py
+++ b/chaotic-openapi/chaotic_openapi/front/parser.py
@@ -3,17 +3,16 @@
 import typing
 from typing import Any
 from typing import Callable
-from typing import Dict
-from typing import List
 from typing import Optional
-from typing import Tuple
 from typing import Union
 
 import pydantic
 
-from chaotic import cpp_names
+from chaotic import error as chaotic_error
 from chaotic.front import parser as chaotic_parser
+from chaotic.front import ref
 from chaotic.front import types
+from . import base_model
 from . import errors
 from . import model
 from . import openapi
@@ -24,7 +23,10 @@
 @dataclasses.dataclass
 class ParserState:
     service: model.Service
+    # Full filepath in filesystem as-is
     full_filepath: str = ''
+    # Virtual filepath for .cpp/.hpp file generation (e.g. relative paths)
+    full_vfilepath: str = ''
 
 
 class Parser:
@@ -34,8 +36,9 @@ def __init__(
     ) -> None:
         self._state = ParserState(service=model.Service(name=name))
 
-    def parse_schema(self, schema: dict, full_filepath: str) -> None:
+    def parse_schema(self, schema: dict, full_filepath: str, full_vfilepath: str) -> None:
         self._state.full_filepath = full_filepath
+        self._state.full_vfilepath = full_vfilepath
         parser = self._guess_parser(schema)
         try:
             parsed = parser(**schema)
@@ -82,6 +85,8 @@ def _convert_swagger_header(self, name: str, header: swagger.Header, infile_path
             allowEmptyValue=False,
             style=model.Style.simple,
             schema=self._parse_schema(header_dict, infile_path + '/schema'),
+            x_cpp_name=None,
+            x_query_log_mode_hide=False,
         )
 
     def _convert_media_type(
@@ -99,11 +104,11 @@ def _convert_media_type(
 
     RIGHT_SLASH_RE = re.compile('/[^/]*$')
 
-    def _locate_ref(self, ref: str) -> str:
-        if ref.startswith('#'):
-            return self._state.full_filepath + ref
+    def _locate_ref(self, ref_: str) -> str:
+        if not ref.Ref(ref_).file:
+            return self._state.full_filepath + ref_
         cur = re.sub(self.RIGHT_SLASH_RE, '/', self._state.full_filepath)
-        return chaotic_parser.SchemaParser._normalize_ref(cur + ref)
+        return chaotic_parser.SchemaParser._normalize_ref(cur + ref_)
 
     def _convert_openapi_parameter(
         self,
@@ -122,13 +127,15 @@ def _convert_openapi_parameter(
             allowEmptyValue=parameter.allowEmptyValue,
             style=model.Style(parameter.style),
             schema=self._parse_schema(parameter.schema_, infile_path + '/schema'),
+            x_cpp_name=parameter.x_cpp_name,
+            x_query_log_mode_hide=(parameter.x_query_log_mode == openapi.QueryLogMode.hide),
         )
         return p
 
     def _is_swagger_request_body(
         self,
         parameter: Union[swagger.Parameter, swagger.Ref],
-        global_params: Dict[str, Union[model.Parameter, List[model.RequestBody]]],
+        global_params: dict[str, Union[model.Parameter, list[model.RequestBody]]],
     ) -> bool:
         if isinstance(parameter, swagger.Ref):
             return isinstance(global_params[self._locate_ref(parameter.ref)], list)
@@ -139,14 +146,14 @@ def _convert_swagger_request_body(
         self,
         request_body: Union[swagger.Parameter, swagger.Ref],
         infile_path: str,
-        consumes: List[str] = [],
-    ) -> Union[List[model.RequestBody], model.Ref]:
+        consumes: list[str] = [],
+    ) -> Union[list[model.RequestBody], model.Ref]:
         if isinstance(request_body, swagger.Ref):
-            ref = ref_resolver.normalize_ref(
+            ref_ = ref_resolver.normalize_ref(
                 self._state.full_filepath,
                 request_body.ref,
             )
-            return model.Ref(ref)
+            return model.Ref(ref_)
 
         if request_body.in_ == swagger.In.body:
             return [
@@ -160,6 +167,15 @@ def _convert_swagger_request_body(
 
         assert request_body.in_ == swagger.In.formData
 
+        if request_body.type == 'file':
+            if 'multipart/form-data' not in consumes and 'application/x-www-form-urlencoded' not in consumes:
+                raise chaotic_error.BaseError(
+                    full_filepath=self._state.full_filepath,
+                    infile_path=infile_path,
+                    schema_type='swagger',
+                    msg='"consumes" must be either "multipart/form-data" or "application/x-www-form-urlencoded" for "type: file"',
+                )
+
         schema = self._parse_schema(
             request_body.model_dump(
                 by_alias=True,
@@ -167,6 +183,7 @@ def _convert_swagger_request_body(
                 exclude_unset=True,
             ),
             infile_path,
+            allow_file=True,
         )
         return [
             model.RequestBody(
@@ -190,6 +207,7 @@ def _convert_swagger_parameter(
                 exclude_unset=True,
             ),
             infile_path,
+            allow_file=True,
         )
 
         style: model.Style
@@ -208,6 +226,8 @@ def _convert_swagger_parameter(
             allowEmptyValue=parameter.allowEmptyValue,
             style=style,
             schema=schema,
+            x_cpp_name=parameter.x_cpp_name,
+            x_query_log_mode_hide=False,
         )
 
         return p
@@ -220,12 +240,15 @@ def _convert_openapi_response(
         assert infile_path.count('#') <= 1
 
         if isinstance(response, openapi.Ref):
-            ref = ref_resolver.normalize_ref(
+            ref_ = ref_resolver.normalize_ref(
                 self._state.full_filepath,
                 response.ref,
             )
-            assert ref.count('#') == 1, ref
-            return model.Ref(ref)
+
+            # validate
+            ref.Ref(ref_)
+
+            return model.Ref(ref_)
 
         content = {}
         for content_type, openapi_content in response.content.items():
@@ -243,17 +266,20 @@ def _convert_openapi_response(
         )
 
     def _convert_swagger_response(
-        self, response: Union[swagger.Response, swagger.Ref], produces: List[str], infile_path: str
+        self, response: Union[swagger.Response, swagger.Ref], produces: list[str], infile_path: str
     ) -> Union[model.Response, model.Ref]:
         assert infile_path.count('#') <= 1
 
         if isinstance(response, swagger.Ref):
-            ref = ref_resolver.normalize_ref(
+            ref_ = ref_resolver.normalize_ref(
                 self._state.full_filepath,
                 response.ref,
             )
-            assert ref.count('#') == 1, ref
-            return model.Ref(ref)
+
+            # validate
+            ref.Ref(ref_)
+
+            return model.Ref(ref_)
 
         if response.schema_:
             schema = self._parse_schema(response.schema_, infile_path + '/schema')
@@ -275,13 +301,13 @@ def _convert_openapi_request_body(
         self,
         request_body: Union[openapi.RequestBody, openapi.Ref],
         infile_path: str,
-    ) -> Union[List[model.RequestBody], model.Ref]:
+    ) -> Union[list[model.RequestBody], model.Ref]:
         if isinstance(request_body, openapi.Ref):
-            ref = ref_resolver.normalize_ref(
+            ref_ = ref_resolver.normalize_ref(
                 self._state.full_filepath,
                 request_body.ref,
             )
-            return model.Ref(ref)
+            return model.Ref(ref_)
 
         requestBody = []
         for content_type, media_type in request_body.content.items():
@@ -298,8 +324,8 @@ def _convert_openapi_request_body(
             )
         return requestBody
 
-    def _convert_openapi_flows(self, flows: openapi.OAuthFlows) -> List[model.Flow]:
-        model_flows: List[model.Flow] = []
+    def _convert_openapi_flows(self, flows: openapi.OAuthFlows) -> list[model.Flow]:
+        model_flows: list[model.Flow] = []
         if flows.implicit:
             implicit = flows.implicit
             refreshUrl = implicit.refreshUrl or ''
@@ -322,7 +348,7 @@ def _convert_openapi_flows(self, flows: openapi.OAuthFlows) -> List[model.Flow]:
         return model_flows
 
     def _convert_openapi_securuty(
-        self, security_scheme: Union[openapi.SecurityScheme, openapi.Ref], flows_scopes: Optional[List[str]] = None
+        self, security_scheme: Union[openapi.SecurityScheme, openapi.Ref], flows_scopes: Optional[list[str]] = None
     ) -> model.Security:
         if isinstance(security_scheme, openapi.Ref):
             return self._state.service.security[self._locate_ref(security_scheme.ref)]
@@ -350,7 +376,7 @@ def _convert_openapi_securuty(
             assert False
 
     def _convert_swagger_security(
-        self, security_def: swagger.SecurityDef, flows_scopes: Optional[List[str]] = None
+        self, security_def: swagger.SecurityDef, flows_scopes: Optional[list[str]] = None
     ) -> model.Security:
         description = security_def.description or ''
         if security_def.type == swagger.SecurityType.basic:
@@ -388,7 +414,7 @@ def _append_schema(
         self,
         parsed: Union[openapi.OpenApi, swagger.Swagger],
     ) -> None:
-        components_schemas: Dict[str, Any] = {}
+        components_schemas: dict[str, Any] = {}
         components_schemas_path = ''
         if isinstance(parsed, openapi.OpenApi):
             parsed = typing.cast(openapi.OpenApi, parsed)
@@ -414,11 +440,11 @@ def _append_schema(
                 security_scheme = self._convert_openapi_securuty(sec_scheme)
                 self._state.service.security[self._state.full_filepath + '#' + infile_path] = security_scheme
 
-            def _convert_op_security(security: Optional[openapi.Security]) -> List[model.Security]:
+            def _convert_op_security(security: Optional[openapi.Security]) -> list[model.Security]:
                 if not security:
                     security = default_security
 
-                securities: List[model.Security] = []
+                securities: list[model.Security] = []
                 for name, scopes in security.items():
                     securities.append(self._convert_openapi_securuty(security_schemas[name], scopes))
 
@@ -451,7 +477,7 @@ def _convert_op_security(security: Optional[openapi.Security]) -> List[model.Sec
             # paths
             for path, path_item in parsed.paths.items():
                 infile_path = f'/paths/[{path}]'
-                path_params: Dict[Tuple[str, model.In], model.Parameter] = {}
+                path_params: dict[tuple[str, model.In], model.Parameter] = {}
                 for i, path_parameter in enumerate(path_item.parameters):
                     param = self._convert_openapi_parameter(path_parameter, infile_path + f'/parameters/{i}')
                     path_params[(param.name, param.in_)] = param
@@ -474,7 +500,7 @@ def _convert_op_security(security: Optional[openapi.Security]) -> List[model.Sec
             consumes = parsed.consumes
 
             # parameters
-            global_params: Dict[str, Union[model.Parameter, List[model.RequestBody]]] = {}
+            global_params: dict[str, Union[model.Parameter, list[model.RequestBody]]] = {}
             for name, sw_parameter in parsed.parameters.items():
                 if self._is_swagger_request_body(sw_parameter, global_params):
                     infile_path = '/requestBodies/' + name
@@ -506,11 +532,11 @@ def _convert_op_security(security: Optional[openapi.Security]) -> List[model.Sec
                 security_def = self._convert_swagger_security(sec_def)
                 self._state.service.security[self._state.full_filepath + '#' + infile_path] = security_def
 
-            def _convert_op_security(security: Optional[swagger.Security]) -> List[model.Security]:
+            def _convert_op_security(security: Optional[swagger.Security]) -> list[model.Security]:
                 if not security:
                     security = default_security
 
-                securities: List[model.Security] = []
+                securities: list[model.Security] = []
                 for name, scopes in security.items():
                     securities.append(self._convert_swagger_security(security_defs[name], scopes))
 
@@ -519,8 +545,8 @@ def _convert_op_security(security: Optional[swagger.Security]) -> List[model.Sec
             # paths
             for sw_path, sw_path_item in parsed.paths.items():
                 infile_path = f'/paths/[{sw_path}]'
-                sw_path_params: Dict[Tuple[str, model.In], model.Parameter] = {}
-                sw_path_body: Union[List[model.RequestBody], model.Ref] = []
+                sw_path_params: dict[tuple[str, model.In], model.Parameter] = {}
+                sw_path_body: Union[list[model.RequestBody], model.Ref] = []
                 for i, sw_path_parameter in enumerate(sw_path_item.parameters):
                     if self._is_swagger_request_body(sw_path_parameter, global_params):
                         sw_path_body = self._convert_swagger_request_body(
@@ -533,8 +559,8 @@ def _convert_op_security(security: Optional[swagger.Security]) -> List[model.Sec
                 def _convert_op_params(
                     op_params: swagger.Parameters,
                     infile_path: str,
-                    consumes: List[str],
-                ) -> Tuple[List[model.Parameter], Union[List[model.RequestBody], model.Ref]]:
+                    consumes: list[str],
+                ) -> tuple[list[model.Parameter], Union[list[model.RequestBody], model.Ref]]:
                     params = sw_path_params.copy()
                     body = sw_path_body
                     for i, sw_parameter in enumerate(op_params):
@@ -577,7 +603,7 @@ def _convert_op_params(
         parser = chaotic_parser.SchemaParser(
             config=chaotic_parser.ParserConfig(erase_prefix=''),
             full_filepath=self._state.full_filepath,
-            full_vfilepath=self._state.full_filepath,
+            full_vfilepath=self._state.full_vfilepath,
         )
         for name, schema in components_schemas.items():
             infile_path = components_schemas_path + '/' + name
@@ -594,15 +620,14 @@ def _make_sure_operations_are_unique(self) -> None:
                 raise Exception(f'Operation {operation.method.upper()} {operation.path} is duplicated')
             seen.add(new)
 
-    @staticmethod
-    def _gen_operation_id(path: str, method: str) -> str:
-        return cpp_names.camel_case((path + '_' + method).replace('/', '_'))
-
-    def _parse_schema(self, schema: Any, infile_path: str) -> Union[types.Schema, types.Ref]:
+    def _parse_schema(self, schema: Any, infile_path: str, allow_file=False) -> Union[types.Schema, types.Ref]:
         parser = chaotic_parser.SchemaParser(
-            config=chaotic_parser.ParserConfig(erase_prefix=''),
+            config=chaotic_parser.ParserConfig(
+                erase_prefix='',
+                allow_file=allow_file,
+            ),
             full_filepath=self._state.full_filepath,
-            full_vfilepath=self._state.full_filepath,
+            full_vfilepath=self._state.full_vfilepath,
         )
         parser.parse_schema(infile_path, schema)
         parsed_schemas = parser.parsed_schemas()
@@ -610,13 +635,13 @@ def _parse_schema(self, schema: Any, infile_path: str) -> Union[types.Schema, ty
         schema_ref = list(parsed_schemas.schemas.values())[0]
 
         if isinstance(schema_ref, types.Ref):
-            ref = types.Ref(
+            ref_ = types.Ref(
                 chaotic_parser.SchemaParser._normalize_ref(schema_ref.ref),
                 indirect=schema_ref.indirect,
                 self_ref=schema_ref.self_ref,
             )
-            ref._source_location = schema_ref._source_location  # type: ignore
-            return ref
+            ref_._source_location = schema_ref._source_location  # type: ignore
+            return ref_
         else:
             return schema_ref
 
@@ -625,8 +650,8 @@ def _append_openapi_operation(
         path: str,
         method: str,
         operation: Optional[openapi.Operation],
-        security_converter: Callable[[Optional[openapi.Security]], List[model.Security]],
-        path_params: Dict[Tuple[str, model.In], model.Parameter],
+        security_converter: Callable[[Optional[openapi.Security]], list[model.Security]],
+        path_params: dict[tuple[str, model.In], model.Parameter],
     ) -> None:
         if not operation:
             return
@@ -651,7 +676,7 @@ def _append_openapi_operation(
                 description=operation.description,
                 path=path,
                 method=method,
-                operationId=(operation.operationId or self._gen_operation_id(path, method)),
+                operationId=operation.operationId,
                 parameters=list(params.values()),
                 requestBody=requestBody,
                 responses={
@@ -659,6 +684,8 @@ def _append_openapi_operation(
                     for status, response in operation.responses.items()
                 },
                 security=security_converter(operation.security),
+                x_middlewares=operation.x_taxi_middlewares or base_model.XMiddlewares(tvm=True),
+                x_client_codegen=operation.x_client_codegen,
             )
         )
 
@@ -667,10 +694,10 @@ def _append_swagger_operation(
         path: str,
         method: str,
         operation: Optional[swagger.Operation],
-        security_converter: Callable[[Optional[swagger.Security]], List[model.Security]],
+        security_converter: Callable[[Optional[swagger.Security]], list[model.Security]],
         params_converter: Callable[
-            [swagger.Parameters, str, List[str]],
-            Tuple[List[model.Parameter], Union[List[model.RequestBody], model.Ref]],
+            [swagger.Parameters, str, list[str]],
+            tuple[list[model.Parameter], Union[list[model.RequestBody], model.Ref]],
         ],
     ) -> None:
         if not operation:
@@ -685,7 +712,7 @@ def _append_swagger_operation(
                 description=operation.description,
                 path=path,
                 method=method,
-                operationId=(operation.operationId or self._gen_operation_id(path, method)),
+                operationId=operation.operationId,
                 parameters=params,
                 requestBody=body,
                 responses={
@@ -695,6 +722,8 @@ def _append_swagger_operation(
                     for status, response in operation.responses.items()
                 },
                 security=security_converter(operation.security),
+                x_middlewares=operation.x_taxi_middlewares or base_model.XMiddlewares(tvm=True),
+                x_client_codegen=operation.x_client_codegen,
             )
         )
 
diff --git a/chaotic-openapi/chaotic_openapi/front/ref_resolver.py b/chaotic-openapi/chaotic_openapi/front/ref_resolver.py
index 997976c152f8..1893aa58197c 100644
--- a/chaotic-openapi/chaotic_openapi/front/ref_resolver.py
+++ b/chaotic-openapi/chaotic_openapi/front/ref_resolver.py
@@ -1,31 +1,26 @@
 import collections
-import re
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Tuple
 
 from chaotic.front import parser as chaotic_parser
+from chaotic.front import ref
 from chaotic.front import ref_resolver
 
-REF_SHRINK_RE = re.compile('/[^/]+/../')
 
-
-def normalize_ref(filepath: str, ref: str) -> str:
-    if ref.startswith('#'):
-        return filepath + ref
+def normalize_ref(filepath: str, ref_: str) -> str:
+    if not ref.Ref(ref_).file:
+        return filepath + ref_
 
     return chaotic_parser.SchemaParser._normalize_ref(
         '{}/{}'.format(
             filepath.rsplit('/', 1)[0],
-            ref,
+            ref_,
         )
     )
 
 
 # Extracts list of external (non-'#ref') $refs in global form
 # (e.g. 'other.yaml#ref' becomes '/path/to/other.yaml#ref')
-def _extract_refs(filepath: str, content: Any) -> List[str]:
+def _extract_refs(filepath: str, content: Any) -> list[str]:
     refs = []
 
     def visit(value: Any) -> None:
@@ -36,15 +31,16 @@ def visit(value: Any) -> None:
             for item in value.values():
                 visit(item)
             if '$ref' in value:
-                ref = value['$ref']
-                if not ref.startswith('#'):
-                    refs.append(normalize_ref(filepath, ref).split('#')[0])
+                ref_ = value['$ref']
+                reference = ref.Ref(ref_)
+                if reference.file:
+                    refs.append(ref.Ref(normalize_ref(filepath, ref_)).file)
 
     visit(content)
     return refs
 
 
-def sort_openapis(contents: Dict[str, Any]) -> List[Tuple[str, Any]]:
+def sort_openapis(contents: dict[str, Any]) -> list[tuple[str, Any]]:
     nodes = set()
 
     edges = collections.defaultdict(list)
@@ -52,8 +48,8 @@ def sort_openapis(contents: Dict[str, Any]) -> List[Tuple[str, Any]]:
         nodes.add(filepath)
 
         refs = _extract_refs(filepath, content)
-        for ref in refs:
-            edges[filepath].append(ref)
+        for ref_ in refs:
+            edges[filepath].append(ref_)
 
     sorted_nodes = ref_resolver.sort_dfs(nodes, edges)
     return [(filepath, contents[filepath]) for filepath in sorted_nodes]
diff --git a/chaotic-openapi/chaotic_openapi/front/swagger.py b/chaotic-openapi/chaotic_openapi/front/swagger.py
index 2692ff83c229..2ce02e4c1b6a 100644
--- a/chaotic-openapi/chaotic_openapi/front/swagger.py
+++ b/chaotic-openapi/chaotic_openapi/front/swagger.py
@@ -1,7 +1,5 @@
 import enum
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 from typing import Union
 
@@ -44,12 +42,17 @@ class Parameter(base_model.BaseModel):
     type: Optional[str] = None
     format: Optional[str] = None
     allowEmptyValue: bool = False
-    items: Optional[Dict] = None
+    items: Optional[dict] = None
     collectionFormat: Optional[str] = None
     default: Any = None
 
     # TODO: validators
 
+    x_cpp_name: Optional[str] = pydantic.Field(
+        default=None,
+        validation_alias=pydantic.AliasChoices('x-taxi-cpp-name', 'x-usrv-cpp-name'),
+    )
+
     def model_post_init(self, context: Any, /) -> None:
         if self.in_ == In.body:
             if not self.schema_:
@@ -67,7 +70,7 @@ class Header(base_model.BaseModel):
     description: Optional[str] = None
     type: str
     format: Optional[str] = None
-    items: Optional[Dict] = None
+    items: Optional[dict] = None
     collectionFormat: Optional[str] = None
     default: Any = None
 
@@ -88,11 +91,11 @@ def model_post_init(self, context: Any, /) -> None:
 class Response(base_model.BaseModel):
     description: str
     schema_: Schema = pydantic.Field(alias='schema', default=None)
-    headers: Dict[str, Header] = pydantic.Field(default_factory=dict)
-    examples: Dict[str, Any] = pydantic.Field(default_factory=dict)
+    headers: dict[str, Header] = pydantic.Field(default_factory=dict)
+    examples: dict[str, Any] = pydantic.Field(default_factory=dict)
 
 
-Responses = Dict[Union[str, int], Union[Response, Ref]]
+Responses = dict[Union[str, int], Union[Response, Ref]]
 
 
 class SecurityType(str, enum.Enum):
@@ -122,7 +125,7 @@ class SecurityDef(base_model.BaseModel):
     flow: Optional[OAuthFlow] = None
     authorizationUrl: Optional[str] = None
     tokenUrl: Optional[str] = None
-    scopes: Dict[str, str] = pydantic.Field(default_factory=dict)
+    scopes: dict[str, str] = pydantic.Field(default_factory=dict)
 
     def model_post_init(self, context: Any, /) -> None:
         if self.type == SecurityType.apiKey:
@@ -150,26 +153,39 @@ def model_post_init(self, context: Any, /) -> None:
 
 
 # https://spec.openapis.org/oas/v2.0.html#security-requirement-object
-Security = Dict[str, List[str]]
+Security = dict[str, list[str]]
 
-Parameters = List[Union[Parameter, Ref]]
+Parameters = list[Union[Parameter, Ref]]
 
 
 # https://spec.openapis.org/oas/v2.0.html#operation-object
 class Operation(base_model.BaseModel):
-    tags: Optional[List[str]] = None
+    tags: Optional[list[str]] = None
     summary: Optional[str] = None
     description: str = ''
-    externalDocs: Optional[Dict] = None
+    externalDocs: Optional[dict] = None
     operationId: Optional[str] = None
-    consumes: List[str] = pydantic.Field(default_factory=list)
-    produces: List[str] = pydantic.Field(default_factory=list)
+    consumes: list[str] = pydantic.Field(default_factory=list)
+    produces: list[str] = pydantic.Field(default_factory=list)
     parameters: Parameters = pydantic.Field(default_factory=list)
     responses: Responses
-    schemes: List[str] = pydantic.Field(default_factory=list)
+    schemes: list[str] = pydantic.Field(default_factory=list)
     deprecated: bool = False
     security: Optional[Security] = None
 
+    x_taxi_middlewares: Optional[base_model.XMiddlewares] = pydantic.Field(
+        default=None,
+        validation_alias=pydantic.AliasChoices('x-taxi-middlewares', 'x-usrv-middlewares'),
+    )
+    x_taxi_handler_codegen: bool = pydantic.Field(
+        default=True,
+        validation_alias=pydantic.AliasChoices('x-taxi-handler-codegen', 'x-usrv-handler-codegen'),
+    )
+    x_client_codegen: bool = pydantic.Field(
+        default=True,
+        validation_alias=pydantic.AliasChoices('x-taxi-client-codegen', 'x-usrv-client-codegen'),
+    )
+
 
 # https://spec.openapis.org/oas/v2.0.html#paths-object
 class Path(base_model.BaseModel):
@@ -183,7 +199,7 @@ class Path(base_model.BaseModel):
     parameters: Parameters = pydantic.Field(default_factory=list)
 
 
-Paths = Dict[str, Path]
+Paths = dict[str, Path]
 
 
 # https://spec.openapis.org/oas/v2.0.html#schema
@@ -192,14 +208,14 @@ class Swagger(base_model.BaseModel):
     info: Optional[Info] = None
     host: Optional[str] = None
     basePath: str = ''
-    schemes: List[str] = pydantic.Field(default_factory=list)
-    consumes: List[str] = pydantic.Field(default_factory=list)
-    produces: List[str] = pydantic.Field(default_factory=list)
+    schemes: list[str] = pydantic.Field(default_factory=list)
+    consumes: list[str] = pydantic.Field(default_factory=list)
+    produces: list[str] = pydantic.Field(default_factory=list)
     paths: Paths = pydantic.Field(default_factory=dict)
-    definitions: Dict[str, Schema] = pydantic.Field(default_factory=dict)
-    parameters: Dict[str, Parameter] = pydantic.Field(default_factory=dict)
-    responses: Dict[str, Response] = pydantic.Field(default_factory=dict)
-    securityDefinitions: Dict[str, SecurityDef] = pydantic.Field(default_factory=dict)
+    definitions: dict[str, Schema] = pydantic.Field(default_factory=dict)
+    parameters: dict[str, Parameter] = pydantic.Field(default_factory=dict)
+    responses: dict[str, Response] = pydantic.Field(default_factory=dict)
+    securityDefinitions: dict[str, SecurityDef] = pydantic.Field(default_factory=dict)
     security: Security = pydantic.Field(default_factory=dict)
 
     def validate_security(self, security: Optional[Security]) -> None:
diff --git a/chaotic-openapi/chaotic_openapi/main.py b/chaotic-openapi/chaotic_openapi/main.py
index 89a524aea959..6e003096da52 100644
--- a/chaotic-openapi/chaotic_openapi/main.py
+++ b/chaotic-openapi/chaotic_openapi/main.py
@@ -1,4 +1,5 @@
 import argparse
+import os
 import sys
 
 import yaml
@@ -23,7 +24,7 @@ def do_main():
 
     # sort
     contents = {}
-    for file in args.file:
+    for file in args.files:
         with open(file) as ifile:
             content = yaml.safe_load(ifile)
         contents[file] = content
@@ -32,14 +33,15 @@ def do_main():
     # parse
     parser = front_parser.Parser(args.name)
     for file, content in sorted_contents:
-        parser.parse_schema(content, file)
+        parser.parse_schema(content, file, os.path.basename(file))
 
     # translate
     spec = translator.Translator(
         parser.service(),
         dynamic_config=args.dynamic_config,
         cpp_namespace=(args.namespace or f'clients::{args.name}'),
-        include_dirs=[],
+        include_dirs=args.include_dirs or [],
+        middleware_plugins=[],
     ).spec()
 
     # render
@@ -67,7 +69,14 @@ def parse_args() -> argparse.Namespace:
         ),
     )
     parser.add_argument(
-        'file',
+        '-I',
+        '--include-dir',
+        dest='include_dirs',
+        action='append',
+        help='Path to search for include files for x-usrv-cpp-type',
+    )
+    parser.add_argument(
+        'files',
         nargs='+',
         help='openapi/swagger yaml/json schemas',
     )
diff --git a/chaotic-openapi/include/userver/chaotic/openapi/form.hpp b/chaotic-openapi/include/userver/chaotic/openapi/form.hpp
index 537ff5997dfa..5d8b933f2ce1 100644
--- a/chaotic-openapi/include/userver/chaotic/openapi/form.hpp
+++ b/chaotic-openapi/include/userver/chaotic/openapi/form.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <string>
 
 USERVER_NAMESPACE_BEGIN
diff --git a/chaotic-openapi/include/userver/chaotic/openapi/parameters.hpp b/chaotic-openapi/include/userver/chaotic/openapi/parameters.hpp
index e72578e00424..1ff3d86a6d21 100644
--- a/chaotic-openapi/include/userver/chaotic/openapi/parameters.hpp
+++ b/chaotic-openapi/include/userver/chaotic/openapi/parameters.hpp
@@ -29,41 +29,41 @@ inline constexpr bool kIsTrivialRawType<std::string> = true;
 template <>
 inline constexpr bool kIsTrivialRawType<double> = true;
 
-template <typename RawType_, typename UserType_>
+template <typename TRawType, typename TUserType>
 struct TrivialParameterBase {
-    using RawType = RawType_;
-    using UserType = UserType_;
+    using RawType = TRawType;
+    using UserType = TUserType;
 
     static_assert(kIsTrivialRawType<RawType>);
 };
 
-template <In In_, const Name& Name_, typename RawType_, typename UserType_ = RawType_>
+template <In TIn, const Name& Name, typename RawType, typename UserType = RawType>
 struct TrivialParameter {
-    static constexpr auto kIn = In_;
-    static constexpr auto& kName = Name_;
+    static constexpr auto kIn = TIn;
+    static constexpr auto& kName = Name;
 
-    using Base = TrivialParameterBase<RawType_, UserType_>;
+    using Base = TrivialParameterBase<RawType, UserType>;
 
     static_assert(kIn != In::kQueryExplode);
 };
 
-template <In In_, char Delimiter_, typename RawItemType_, typename UserItemType_ = RawItemType_>
+template <In TIn, char Delimiter, typename TRawItemType, typename TUserItemType = TRawItemType>
 struct ArrayParameterBase {
-    static constexpr char kDelimiter = Delimiter_;
-    static constexpr auto kIn = In_;
+    static constexpr char kDelimiter = Delimiter;
+    static constexpr auto kIn = TIn;
 
     using RawType = std::vector<std::string>;
-    using RawItemType = RawItemType_;
-    using UserType = std::vector<UserItemType_>;
-    using UserItemType = UserItemType_;
+    using RawItemType = TRawItemType;
+    using UserType = std::vector<TUserItemType>;
+    using UserItemType = TUserItemType;
 };
 
-template <In In_, const Name& Name_, char Delimiter_, typename RawItemType_, typename UserItemType_ = RawItemType_>
+template <In TIn, const Name& Name, char Delimiter, typename TRawItemType, typename TUserItemType = TRawItemType>
 struct ArrayParameter {
-    static constexpr auto& kName = Name_;
-    static constexpr auto kIn = In_;
+    static constexpr auto& kName = Name;
+    static constexpr auto kIn = TIn;
 
-    using Base = ArrayParameterBase<In_, Delimiter_, RawItemType_, UserItemType_>;
+    using Base = ArrayParameterBase<TIn, Delimiter, TRawItemType, TUserItemType>;
 };
 
 }  // namespace chaotic::openapi
diff --git a/chaotic-openapi/include/userver/chaotic/openapi/parameters_read.hpp b/chaotic-openapi/include/userver/chaotic/openapi/parameters_read.hpp
index c21911619773..34d1f14abe2b 100644
--- a/chaotic-openapi/include/userver/chaotic/openapi/parameters_read.hpp
+++ b/chaotic-openapi/include/userver/chaotic/openapi/parameters_read.hpp
@@ -24,18 +24,18 @@ namespace chaotic::openapi {
  *
  */
 
-template <In In_>
+template <In TIn>
 auto GetParameter(std::string_view name, const server::http::HttpRequest& source) {
-    if constexpr (In_ == In::kPath) {
+    if constexpr (TIn == In::kPath) {
         return source.GetPathArg(name);
-    } else if constexpr (In_ == In::kCookie) {
+    } else if constexpr (TIn == In::kCookie) {
         return source.GetCookie(std::string{name});
-    } else if constexpr (In_ == In::kHeader) {
+    } else if constexpr (TIn == In::kHeader) {
         return source.GetHeader(name);
-    } else if constexpr (In_ == In::kQuery) {
+    } else if constexpr (TIn == In::kQuery) {
         return source.GetArg(name);
     } else {
-        static_assert(In_ == In::kQueryExplode, "Unknown 'In'");
+        static_assert(TIn == In::kQueryExplode, "Unknown 'In'");
         return source.GetArgVector(name);
     }
 }
@@ -78,8 +78,8 @@ void SplitByDelimiter(std::string_view str, char delimiter, utils::function_ref<
 
 }
 
-template <In In_, char Delimiter, typename RawType, typename UserType>
-struct ParseParameter<ArrayParameterBase<In_, Delimiter, RawType, UserType>> {
+template <In TIn, char Delimiter, typename RawType, typename UserType>
+struct ParseParameter<ArrayParameterBase<TIn, Delimiter, RawType, UserType>> {
     static auto Parse(std::string&& str_value) {
         openapi::ParseParameter<TrivialParameterBase<RawType, UserType>> parser;
 
diff --git a/chaotic-openapi/include/userver/chaotic/openapi/parameters_write.hpp b/chaotic-openapi/include/userver/chaotic/openapi/parameters_write.hpp
index 81e16cad89c6..f2ec49e854d4 100644
--- a/chaotic-openapi/include/userver/chaotic/openapi/parameters_write.hpp
+++ b/chaotic-openapi/include/userver/chaotic/openapi/parameters_write.hpp
@@ -54,32 +54,39 @@ class ParameterSinkHttpClient final : public ParameterSinkBase {
 
     void Flush();
 
+    const clients::http::Headers& GetHeaders() const;
+
+    using HiddenQueryArgNamesFunc = bool (*)(std::string_view);
+
+    void SetHiddenQueryArgNamesFunc(HiddenQueryArgNamesFunc func);
+
 private:
     std::string url_pattern_;
     clients::http::Request& request_;
     clients::http::Headers headers_;
     http::MultiArgs query_args_;
+    HiddenQueryArgNamesFunc hidden_query_arg_names_func_{};
     std::unordered_map<std::string, std::string> cookies_;
     fmt::dynamic_format_arg_store<fmt::format_context> path_vars_;
 };
 
 void ValidatePathVariableValue(std::string_view name, std::string_view value);
 
-template <In In, typename StrType>
+template <In TIn, typename StrType>
 void SetParameter(Name& name, StrType&& str_value, ParameterSinkBase& dest) {
     static_assert(std::is_same_v<StrType, std::string> || std::is_same_v<StrType, std::vector<std::string>>);
 
-    if constexpr (In == In::kPath) {
+    if constexpr (TIn == In::kPath) {
         USERVER_NAMESPACE::chaotic::openapi::ValidatePathVariableValue(name, str_value);
         dest.SetPath(name, std::forward<StrType>(str_value));
-    } else if constexpr (In == In::kCookie) {
+    } else if constexpr (TIn == In::kCookie) {
         dest.SetCookie(name, std::forward<StrType>(str_value));
-    } else if constexpr (In == In::kHeader) {
+    } else if constexpr (TIn == In::kHeader) {
         dest.SetHeader(name, std::forward<StrType>(str_value));
-    } else if constexpr (In == In::kQuery) {
+    } else if constexpr (TIn == In::kQuery) {
         dest.SetQuery(name, std::forward<StrType>(str_value));
     } else {
-        static_assert(In == In::kQueryExplode, "Unknown 'In'");
+        static_assert(TIn == In::kQueryExplode, "Unknown 'In'");
         dest.SetMultiQuery(name, std::forward<StrType>(str_value));
     }
 }
@@ -145,9 +152,9 @@ struct SerializeParameter<ArrayParameterBase<In::kQueryExplode, Delimiter, T, U>
     }
 };
 
-template <In In_, char Delimiter, typename RawType, typename UserType>
-struct SerializeParameter<ArrayParameterBase<In_, Delimiter, RawType, UserType>> {
-    static_assert(In_ != In::kQueryExplode);
+template <In TIn, char Delimiter, typename RawType, typename UserType>
+struct SerializeParameter<ArrayParameterBase<TIn, Delimiter, RawType, UserType>> {
+    static_assert(TIn != In::kQueryExplode);
 
     std::string operator()(const UserType& item) const { return ToStrParameter(Convert(item, convert::To<RawType>{})); }
 
diff --git a/chaotic-openapi/integration_tests/clients/body-with-array/openapi.yaml b/chaotic-openapi/integration_tests/clients/body-with-array/openapi.yaml
new file mode 100644
index 000000000000..4f47e43b77d1
--- /dev/null
+++ b/chaotic-openapi/integration_tests/clients/body-with-array/openapi.yaml
@@ -0,0 +1,18 @@
+openapi: 3.0.0
+info:
+    title: test-object client
+    version: '1.0'
+
+paths:
+    /test1:
+        post:
+            requestBody:
+                content:
+                    application/json:
+                        schema:
+                            type: array
+                            items:
+                                type: string
+            responses:
+                '200':
+                    description: OK
diff --git a/chaotic-openapi/integration_tests/clients/empty-openapi/openapi.yaml b/chaotic-openapi/integration_tests/clients/empty-openapi/openapi.yaml
new file mode 100644
index 000000000000..30776fa4e2a5
--- /dev/null
+++ b/chaotic-openapi/integration_tests/clients/empty-openapi/openapi.yaml
@@ -0,0 +1,12 @@
+openapi: 3.0.0
+info:
+    title: test-object client
+    version: '1.0'
+
+paths:
+    /test1:
+        post:
+            responses:
+                '200':
+                    description: OK
+components: {}
diff --git a/chaotic-openapi/integration_tests/clients/handler-tag/openapi.yaml b/chaotic-openapi/integration_tests/clients/handler-tag/openapi.yaml
new file mode 100644
index 000000000000..e094a1e0279f
--- /dev/null
+++ b/chaotic-openapi/integration_tests/clients/handler-tag/openapi.yaml
@@ -0,0 +1,51 @@
+openapi: 3.0.0
+info:
+    title: test-object client
+    version: '1.0'
+
+paths:
+    /test1:
+        get:
+            parameters:
+              - name: param1
+                in: query
+                required: true
+                x-usrv-handler-tag: param1
+                schema:
+                    type: integer
+              - name: param2
+                in: query
+                required: true
+                x-usrv-handler-tag: param2
+                schema:
+                    type: number
+              - name: param3
+                in: query
+                required: true
+                x-usrv-handler-tag: param3
+                schema:
+                    type: string
+
+              - name: param4
+                in: query
+                required: false
+                x-usrv-handler-tag: param4
+                schema:
+                    type: integer
+              - name: param5
+                in: query
+                required: false
+                x-usrv-handler-tag: param5
+                schema:
+                    type: number
+              - name: param6
+                in: query
+                required: false
+                x-usrv-handler-tag: param6
+                schema:
+                    type: string
+
+            responses:
+                '200':
+                    description: OK
+components: {}
diff --git a/chaotic-openapi/integration_tests/clients/non-alphanum/openapi.yaml b/chaotic-openapi/integration_tests/clients/non-alphanum/openapi.yaml
new file mode 100644
index 000000000000..a7eadf154ba7
--- /dev/null
+++ b/chaotic-openapi/integration_tests/clients/non-alphanum/openapi.yaml
@@ -0,0 +1,24 @@
+openapi: 3.0.0
+info:
+    title: test-object client
+    version: '1.0'
+
+paths:
+    /some.method-name:
+        x-tag: test
+        post:
+            responses:
+                '200':
+                    description: OK
+                    content:
+                        application/json:
+                            schema:
+                                type: object
+                                additionalProperties: false
+                                properties: {}
+components:
+    schemas:
+        My.Super-Object:
+            type: object
+            additionalProperties: false
+            properties: {}
diff --git a/chaotic-openapi/integration_tests/clients/operation/non_std_type_reason.yaml b/chaotic-openapi/integration_tests/clients/operation/non_std_type_reason.yaml
new file mode 100644
index 000000000000..d9646f7d3e72
--- /dev/null
+++ b/chaotic-openapi/integration_tests/clients/operation/non_std_type_reason.yaml
@@ -0,0 +1,26 @@
+openapi: 3.0.0
+info:
+    title: test-object client
+    version: '1.0'
+
+paths:
+    /test2:
+        get:
+            operationId: MyTest2
+            requestBody:
+                content:
+                    application/json:
+                        x-usrv-non-std-type-reason: bla bla
+                        schema:
+                            type: string
+            responses:
+                '200':
+                    description: OK
+                    content:
+                        application/json:
+                            x-usrv-non-std-type-reason: bla bla bla
+                            schema:
+                                type: object
+                                properties: {}
+                                additionalProperties: false
+components: {}
diff --git a/chaotic-openapi/integration_tests/clients/operation/openapi.yaml b/chaotic-openapi/integration_tests/clients/operation/openapi.yaml
new file mode 100644
index 000000000000..3d4e8a3b7e2a
--- /dev/null
+++ b/chaotic-openapi/integration_tests/clients/operation/openapi.yaml
@@ -0,0 +1,26 @@
+openapi: 3.0.0
+info:
+    title: test-object client
+    version: '1.0'
+
+paths:
+    /test1:
+        get:
+            operationId: MyTest
+            responses:
+                '200':
+                    description: OK
+                    content:
+                        application/json:
+                            schema:
+                                type: object
+                                properties: {}
+                                additionalProperties: false
+    /test3:
+        get:
+            responses:
+                '200':
+                    description: OK
+                    content:
+                        application/json: {}
+components: {}
diff --git a/chaotic-openapi/integration_tests/clients/parameters/openapi.yaml b/chaotic-openapi/integration_tests/clients/parameters/openapi.yaml
index 8813f946e46f..b27cf61542a5 100644
--- a/chaotic-openapi/integration_tests/clients/parameters/openapi.yaml
+++ b/chaotic-openapi/integration_tests/clients/parameters/openapi.yaml
@@ -15,6 +15,12 @@ paths:
                       - one
                       - two
                       - three
+              - name: class
+                x-usrv-cpp-name: myclass
+                in: query
+                required: false
+                schema:
+                    type: string
             requestBody:
                 content:
                     application/json:
@@ -41,4 +47,41 @@ paths:
                     description: Some error
                 '500':
                     description: Some error
+
+    /test1/query-log-mode:
+        get:
+            x-taxi-query-log-mode: hide
+            parameters:
+              - in: query
+                name: password
+                required: true
+                schema:
+                    type: string
+              - in: query
+                name: secret
+                required: false
+                schema:
+                    type: string
+            responses:
+                '200':
+                    description: OK
+
+    /test1/query-log-mode/parameter:
+        get:
+            parameters:
+              - in: query
+                name: password
+                required: true
+                x-taxi-query-log-mode: hide
+                schema:
+                    type: string
+              - in: query
+                name: secret
+                required: false
+                schema:
+                    type: string
+            responses:
+                '200':
+                    description: OK
+
 components: {}
diff --git a/chaotic-openapi/integration_tests/clients/response-headers/openapi.yaml b/chaotic-openapi/integration_tests/clients/response-headers/openapi.yaml
index 1ece697b68a4..fd4161df5be7 100644
--- a/chaotic-openapi/integration_tests/clients/response-headers/openapi.yaml
+++ b/chaotic-openapi/integration_tests/clients/response-headers/openapi.yaml
@@ -19,4 +19,18 @@ paths:
                         X-Header:
                             schema:
                                 type: string
-components: {}
+                        X-Integer:
+                            schema:
+                                type: integer
+                        X-Seconds:
+                            schema:
+                                type: integer
+                                x-taxi-cpp-type: std::chrono::seconds
+components:
+    responses:
+        ResponseX:
+            description: OK
+            headers:
+                X-Header:
+                    schema:
+                        type: string
diff --git a/chaotic-openapi/integration_tests/clients/swagger/swagger.yaml b/chaotic-openapi/integration_tests/clients/swagger/swagger.yaml
index 137e8471f8b4..a7a1fd19e3c3 100644
--- a/chaotic-openapi/integration_tests/clients/swagger/swagger.yaml
+++ b/chaotic-openapi/integration_tests/clients/swagger/swagger.yaml
@@ -21,6 +21,42 @@ paths:
                 '404':
                     $ref: '#/responses/Response404'
 
+    /test1/no-tvm:
+        post:
+            x-usrv-middlewares:
+                tvm: false
+            responses:
+                '200':
+                    description: OK
+
+    /test1/body:
+        get:
+            consumes:
+              - application/json
+            produces:
+              - application/json
+            parameters:
+              - in: body
+                name: body
+                required: true
+                schema:
+                    type: string
+            responses:
+                '200':
+                    description: OK
+
+    /test1/file:
+        post:
+            consumes:
+              - multipart/form-data
+            parameters:
+              - in: formData
+                name: file
+                required: true
+                type: file
+            responses:
+                '200':
+                    description: OK
 
 parameters:
     X-Header-456:
diff --git a/chaotic-openapi/integration_tests/clients/test-object/openapi.yaml b/chaotic-openapi/integration_tests/clients/test-object/openapi.yaml
index df35b5aaf772..becc3c8269c6 100644
--- a/chaotic-openapi/integration_tests/clients/test-object/openapi.yaml
+++ b/chaotic-openapi/integration_tests/clients/test-object/openapi.yaml
@@ -37,6 +37,9 @@ components:
         Type:
             type: object
             properties:
+                bar:
+                    type: integer
+                    x-usrv-cpp-type: unsigned
                 baz:
                     type: string
             additionalProperties: false
diff --git a/chaotic-openapi/integration_tests/src/operation_test.cpp b/chaotic-openapi/integration_tests/src/operation_test.cpp
new file mode 100644
index 000000000000..4368fd3d190e
--- /dev/null
+++ b/chaotic-openapi/integration_tests/src/operation_test.cpp
@@ -0,0 +1,28 @@
+#include <userver/utest/utest.hpp>
+
+#include <userver/utest/http_client.hpp>
+
+#include <clients/operation/client_impl.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+UTEST(Operation, OperationId) {
+    auto http_client = utest::CreateHttpClient();
+    ::clients::operation::ClientImpl client(
+        {
+            "",
+        },
+        *http_client
+    );
+
+    if (false) {
+        // Dead code intentionally
+        [[maybe_unused]] ::clients::operation::mytest::Response200 response = client.MyTest({});
+    }
+}
+
+}  // namespace
+
+USERVER_NAMESPACE_END
diff --git a/chaotic-openapi/integration_tests/src/parameters_test.cpp b/chaotic-openapi/integration_tests/src/parameters_test.cpp
new file mode 100644
index 000000000000..1b347ebca618
--- /dev/null
+++ b/chaotic-openapi/integration_tests/src/parameters_test.cpp
@@ -0,0 +1,20 @@
+#include <userver/utest/utest.hpp>
+
+#include <clients/parameters/requests.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+namespace client = ::clients::parameters::test1::post;
+
+UTEST(Parameters, CppName) {
+    client::Request request;
+
+    // compilation test
+    request.myclass = "123";
+}
+
+}  // namespace
+
+USERVER_NAMESPACE_END
diff --git a/chaotic-openapi/integration_tests/src/requests_test.cpp b/chaotic-openapi/integration_tests/src/requests_test.cpp
index 632802933cab..99980d1ac1c0 100644
--- a/chaotic-openapi/integration_tests/src/requests_test.cpp
+++ b/chaotic-openapi/integration_tests/src/requests_test.cpp
@@ -5,8 +5,11 @@
 #include <userver/utest/assert_macros.hpp>
 #include <userver/utest/http_client.hpp>
 #include <userver/utest/http_server_mock.hpp>
+#include <userver/utest/log_capture_fixture.hpp>
+#include <userver/utils/text_light.hpp>
 
 #include <clients/multiple_content_types/requests.hpp>
+#include <clients/parameters/requests.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -96,6 +99,43 @@ UTEST(RequestsMultipleContentTypes, OctetStream) {
     auto response = request.perform();
     EXPECT_EQ(response->status_code(), 200);
 }
+
+class RequestsQueryLogMode : public utest::LogCaptureFixture<> {};
+
+UTEST_F(RequestsQueryLogMode, HideOperation) {
+    const utest::HttpServerMock http_server([&](const utest::HttpServerMock::HttpRequest&) {
+        return utest::HttpServerMock::HttpResponse{200};
+    });
+    auto http_client_ptr = utest::CreateHttpClient();
+    auto request = http_client_ptr->CreateRequest();
+
+    namespace client = ::clients::parameters::test1_query_log_mode::get;
+    client::SerializeRequest({client::Request{"foo", "bar"}}, http_server.GetBaseUrl(), request);
+    auto response = request.perform();
+
+    EXPECT_EQ(response->status_code(), 200);
+
+    auto text = GetLogCapture().GetAll().back().GetTag("http_url");
+    EXPECT_TRUE(utils::text::EndsWith(text, "test1/query-log-mode?password=***&secret=***"));
+}
+
+UTEST_F(RequestsQueryLogMode, HideParameter) {
+    const utest::HttpServerMock http_server([&](const utest::HttpServerMock::HttpRequest&) {
+        return utest::HttpServerMock::HttpResponse{200};
+    });
+    auto http_client_ptr = utest::CreateHttpClient();
+    auto request = http_client_ptr->CreateRequest();
+
+    namespace client = ::clients::parameters::test1_query_log_mode_parameter::get;
+    client::SerializeRequest({client::Request{"foo", "bar"}}, http_server.GetBaseUrl(), request);
+    auto response = request.perform();
+
+    EXPECT_EQ(response->status_code(), 200);
+
+    auto text = GetLogCapture().GetAll().back().GetTag("http_url");
+    EXPECT_TRUE(utils::text::EndsWith(text, "test1/query-log-mode/parameter?password=***&secret=bar")) << text;
+}
+
 }  // namespace
 
 USERVER_NAMESPACE_END
diff --git a/chaotic-openapi/integration_tests/src/responses_test.cpp b/chaotic-openapi/integration_tests/src/responses_test.cpp
index 2a67d547f5bf..6e0372f49f54 100644
--- a/chaotic-openapi/integration_tests/src/responses_test.cpp
+++ b/chaotic-openapi/integration_tests/src/responses_test.cpp
@@ -190,6 +190,8 @@ UTEST(ResponsesMultipleContentType, HeaderParse) {
         r.body = R"({})";
         r.headers[std::string{"Content-Type"}] = "application/json";
         r.headers[std::string{"X-Header"}] = "string";
+        r.headers[std::string{"X-Integer"}] = "42";
+        r.headers[std::string{"X-Seconds"}] = "100";
         return r;
     });
     auto http_client = utest::CreateHttpClient();
@@ -198,6 +200,8 @@ UTEST(ResponsesMultipleContentType, HeaderParse) {
     namespace client = ::clients::response_headers::test1::post;
     auto response = client::ParseResponse(*http_response);
     EXPECT_EQ(response.X_Header, "string");
+    EXPECT_EQ(response.X_Integer, 42);
+    EXPECT_EQ(response.X_Seconds, 100);
 }
 
 }  // namespace
diff --git a/chaotic-openapi/src/chaotic/openapi/parameters_write.cpp b/chaotic-openapi/src/chaotic/openapi/parameters_write.cpp
index 2d36488072be..a198cde0fdf7 100644
--- a/chaotic-openapi/src/chaotic/openapi/parameters_write.cpp
+++ b/chaotic-openapi/src/chaotic/openapi/parameters_write.cpp
@@ -1,11 +1,34 @@
 #include <userver/chaotic/openapi/parameters_write.hpp>
 
+#include <boost/range/adaptor/transformed.hpp>
+
 #include <fmt/format.h>
 
+#include <userver/utils/algo.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace chaotic::openapi {
 
+namespace {
+
+constexpr std::string_view kMask = "***";
+
+auto MaskQueryMultiArgs(const http::MultiArgs& args, ParameterSinkHttpClient::HiddenQueryArgNamesFunc func) {
+    using Pair = std::pair<std::string_view, std::string_view>;
+
+    auto masked = args | boost::adaptors::transformed([&func](const auto& pair) {
+                      const auto& [name, value] = pair;
+                      if (func(name))
+                          return Pair(name, kMask);
+                      else
+                          return Pair(name, value);
+                  });
+    return utils::AsContainer<std::vector<Pair>>(std::move(masked));
+}
+
+}  // namespace
+
 ParameterSinkHttpClient::ParameterSinkHttpClient(clients::http::Request& request, std::string&& url_pattern)
     : url_pattern_(std::move(url_pattern)), request_(request) {}
 
@@ -35,10 +58,21 @@ void ParameterSinkHttpClient::SetMultiQuery(std::string_view name, std::vector<s
 
 void ParameterSinkHttpClient::Flush() {
     request_.url(http::MakeUrl(fmt::vformat(url_pattern_, path_vars_), {}, query_args_));
+    if (hidden_query_arg_names_func_) {
+        auto logged_query_args = MaskQueryMultiArgs(query_args_, hidden_query_arg_names_func_);
+        auto url = http::MakeUrl(fmt::vformat(url_pattern_, path_vars_), logged_query_args);
+        request_.SetLoggedUrl(url);
+    }
     request_.headers(std::move(headers_));
     request_.cookies(std::move(cookies_));
 }
 
+const clients::http::Headers& ParameterSinkHttpClient::GetHeaders() const { return headers_; }
+
+void ParameterSinkHttpClient::SetHiddenQueryArgNamesFunc(HiddenQueryArgNamesFunc func) {
+    hidden_query_arg_names_func_ = func;
+}
+
 std::string ToStrParameter(bool value) noexcept { return value ? "true" : "false"; }
 
 std::string ToStrParameter(double value) noexcept { return fmt::to_string(value); }
diff --git a/chaotic-openapi/tests/back/conftest.py b/chaotic-openapi/tests/back/conftest.py
index 0b14c20db733..065854a3c216 100644
--- a/chaotic-openapi/tests/back/conftest.py
+++ b/chaotic-openapi/tests/back/conftest.py
@@ -7,7 +7,7 @@
 def translate_single_schema():
     def func(schema):
         parser = front_parser.Parser('test')
-        parser.parse_schema(schema, '<inline>')
+        parser.parse_schema(schema, '<inline>', '<inline>')
         service = parser.service()
 
         tr = translator.Translator(
@@ -15,6 +15,7 @@ def func(schema):
             dynamic_config='',
             cpp_namespace='test_namespace',
             include_dirs=[],
+            middleware_plugins=[],
         )
         return tr.spec()
 
diff --git a/chaotic-openapi/tests/back/test_headers.py b/chaotic-openapi/tests/back/test_headers.py
index 89931db57b26..8e1279c1ef31 100644
--- a/chaotic-openapi/tests/back/test_headers.py
+++ b/chaotic-openapi/tests/back/test_headers.py
@@ -37,6 +37,7 @@ def test_headers(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[],
                 responses=[
                     types.Response(
@@ -59,6 +60,7 @@ def test_headers(translate_single_schema):
                                 ),
                                 parser='openapi::TrivialParameter<openapi::In::kHeader, kHeader, int, int>',
                                 required=False,
+                                query_log_mode_hide=False,
                             )
                         ],
                         body={},
@@ -108,6 +110,7 @@ def test_header_ref(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[],
                 responses=[
                     types.Response(
@@ -129,6 +132,7 @@ def test_header_ref(translate_single_schema):
                                 ),
                                 parser='openapi::TrivialParameter<openapi::In::kHeader, kXHeader, bool, bool>',
                                 required=False,
+                                query_log_mode_hide=False,
                             ),
                         ],
                     )
diff --git a/chaotic-openapi/tests/back/test_parameters.py b/chaotic-openapi/tests/back/test_parameters.py
index 0fdfaec0c239..d8af7a024076 100644
--- a/chaotic-openapi/tests/back/test_parameters.py
+++ b/chaotic-openapi/tests/back/test_parameters.py
@@ -36,6 +36,7 @@ def test_parameters(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 parameters=[
                     types.Parameter(
                         description='parameter description',
@@ -54,6 +55,7 @@ def test_parameters(translate_single_schema):
                         ),
                         parser='openapi::TrivialParameter<openapi::In::kQuery, kparam, int, int>',
                         required=False,
+                        query_log_mode_hide=False,
                     )
                 ],
                 request_bodies=[],
@@ -100,6 +102,7 @@ def test_parameters_ref(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 parameters=[
                     types.Parameter(
                         description='parameter description',
@@ -118,6 +121,7 @@ def test_parameters_ref(translate_single_schema):
                         ),
                         parser='openapi::TrivialParameter<openapi::In::kQuery, kparam, int, int>',
                         required=False,
+                        query_log_mode_hide=False,
                     )
                 ],
                 request_bodies=[],
@@ -164,6 +168,7 @@ def test_parameters_schemas_ref(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 parameters=[
                     types.Parameter(
                         description='parameter description',
@@ -198,6 +203,7 @@ def test_parameters_schemas_ref(translate_single_schema):
                         ),
                         parser='openapi::TrivialParameter<openapi::In::kQuery, kparam, int, int>',
                         required=False,
+                        query_log_mode_hide=False,
                     )
                 ],
                 request_bodies=[],
@@ -309,6 +315,6 @@ def test_parameters_too_complex_schema(translate_single_schema):
 Unhandled error while processing <inline>
 Path "/paths/[/]/get/parameters/0/schema", Format "jsonschema"
 Error:
-Unsupported parameter type
+Unsupported parameter type for parameter "param"
 ==============================================================="""
     )
diff --git a/chaotic-openapi/tests/back/test_request_body.py b/chaotic-openapi/tests/back/test_request_body.py
index 948931f40ebe..871deac6603d 100644
--- a/chaotic-openapi/tests/back/test_request_body.py
+++ b/chaotic-openapi/tests/back/test_request_body.py
@@ -35,6 +35,7 @@ def test_request_body(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[
                     types.Body(
                         content_type='application/json',
@@ -91,6 +92,7 @@ def test_request_body_ref(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[
                     types.Body(
                         content_type='application/json',
@@ -140,6 +142,7 @@ def test_request_body_nonrequired(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[
                     types.Body(
                         content_type='application/json',
diff --git a/chaotic-openapi/tests/back/test_responses.py b/chaotic-openapi/tests/back/test_responses.py
index cf2264ae88bf..f1f85b61fa31 100644
--- a/chaotic-openapi/tests/back/test_responses.py
+++ b/chaotic-openapi/tests/back/test_responses.py
@@ -36,6 +36,7 @@ def test_response(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[],
                 responses=[
                     types.Response(
@@ -97,6 +98,7 @@ def test_response_ref(translate_single_schema):
             types.Operation(
                 method='GET',
                 path='/',
+                operation_id=None,
                 request_bodies=[],
                 responses=[
                     types.Response(
diff --git a/chaotic-openapi/tests/front/conftest.py b/chaotic-openapi/tests/front/conftest.py
index 58561e15e228..1a662dfaec78 100644
--- a/chaotic-openapi/tests/front/conftest.py
+++ b/chaotic-openapi/tests/front/conftest.py
@@ -6,7 +6,7 @@
 def simple_parser():
     def _simple_parser(schema):
         parser = front_parser.Parser('test')
-        parser.parse_schema(schema, '<inline>')
+        parser.parse_schema(schema, '<inline>', '<inline>')
         return parser.service()
 
     return _simple_parser
diff --git a/chaotic-openapi/tests/front/test_openapi.py b/chaotic-openapi/tests/front/test_openapi.py
index a1d0677d471d..fb18a7aa760b 100644
--- a/chaotic-openapi/tests/front/test_openapi.py
+++ b/chaotic-openapi/tests/front/test_openapi.py
@@ -1,3 +1,4 @@
+from chaotic_openapi.front import base_model
 from chaotic_openapi.front import model
 import pytest
 
@@ -42,7 +43,7 @@ def test_openapi_body_schema(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 parameters=[],
                 requestBody=[
                     model.RequestBody(
@@ -53,6 +54,8 @@ def test_openapi_body_schema(simple_parser):
                 ],
                 responses={},
                 security=[],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             )
         ],
     )
@@ -140,7 +143,7 @@ def test_openapi_security(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 parameters=[],
                 responses={},
                 requestBody=[],
@@ -163,12 +166,14 @@ def test_openapi_security(simple_parser):
                         ],
                     ),
                 ],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             ),
             model.Operation(
                 description='',
                 path='/',
                 method='post',
-                operationId='Post',
+                operationId=None,
                 parameters=[],
                 responses={},
                 requestBody=[],
@@ -191,12 +196,14 @@ def test_openapi_security(simple_parser):
                         ],
                     ),
                 ],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             ),
             model.Operation(
                 description='',
                 path='/',
                 method='put',
-                operationId='Put',
+                operationId=None,
                 parameters=[],
                 responses={},
                 requestBody=[],
@@ -219,6 +226,8 @@ def test_openapi_security(simple_parser):
                         ],
                     ),
                 ],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             ),
         ],
     )
@@ -309,6 +318,8 @@ def test_openapi_parameters(simple_parser):
                 examples={},
                 deprecated=False,
                 allowEmptyValue=False,
+                x_cpp_name=None,
+                x_query_log_mode_hide=False,
             )
         },
         operations=[
@@ -316,10 +327,12 @@ def test_openapi_parameters(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 responses={},
                 requestBody=[],
                 security=[],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
                 parameters=[
                     model.Parameter(
                         name='pamparam1',
@@ -331,6 +344,8 @@ def test_openapi_parameters(simple_parser):
                         examples={},
                         deprecated=False,
                         allowEmptyValue=False,
+                        x_cpp_name=None,
+                        x_query_log_mode_hide=False,
                     ),
                     model.Parameter(
                         name='pamparam2',
@@ -342,6 +357,8 @@ def test_openapi_parameters(simple_parser):
                         examples={},
                         deprecated=False,
                         allowEmptyValue=False,
+                        x_cpp_name=None,
+                        x_query_log_mode_hide=False,
                     ),
                     model.Parameter(
                         name='pamparam2',
@@ -353,6 +370,8 @@ def test_openapi_parameters(simple_parser):
                         examples={},
                         deprecated=False,
                         allowEmptyValue=False,
+                        x_cpp_name=None,
+                        x_query_log_mode_hide=False,
                     ),
                 ],
             )
diff --git a/chaotic-openapi/tests/front/test_swagger.py b/chaotic-openapi/tests/front/test_swagger.py
index 353949c529e3..47d3180638e9 100644
--- a/chaotic-openapi/tests/front/test_swagger.py
+++ b/chaotic-openapi/tests/front/test_swagger.py
@@ -1,5 +1,8 @@
+from chaotic_openapi.front import base_model
 from chaotic_openapi.front import model
+import pytest
 
+from chaotic import error
 from chaotic.front import types
 
 
@@ -43,7 +46,7 @@ def test_swagger_body_schema(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 parameters=[],
                 requestBody=[
                     model.RequestBody(
@@ -54,6 +57,8 @@ def test_swagger_body_schema(simple_parser):
                 ],
                 responses={},
                 security=[],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             )
         ],
     )
@@ -118,6 +123,8 @@ def test_swagger_responses(simple_parser):
                         allowEmptyValue=False,
                         style=model.Style.simple,
                         schema=types.String(),
+                        x_cpp_name=None,
+                        x_query_log_mode_hide=False,
                     )
                 },
                 content={
@@ -137,7 +144,7 @@ def test_swagger_responses(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 parameters=[],
                 requestBody=[],
                 responses={
@@ -154,6 +161,8 @@ def test_swagger_responses(simple_parser):
                                 allowEmptyValue=False,
                                 style=model.Style.simple,
                                 schema=types.String(),
+                                x_cpp_name=None,
+                                x_query_log_mode_hide=False,
                             ),
                             'X-Header-Name-2': model.Parameter(
                                 name='X-Header-Name-2',
@@ -165,6 +174,8 @@ def test_swagger_responses(simple_parser):
                                 allowEmptyValue=False,
                                 style=model.Style.simple,
                                 schema=types.Array(items=types.Integer()),
+                                x_cpp_name=None,
+                                x_query_log_mode_hide=False,
                             ),
                         },
                         content={
@@ -181,6 +192,8 @@ def test_swagger_responses(simple_parser):
                     500: model.Ref('<inline>#/responses/500'),
                 },
                 security=[],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             )
         ],
     )
@@ -274,7 +287,7 @@ def test_swagger_securuty(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 parameters=[],
                 responses={},
                 requestBody=[],
@@ -302,12 +315,14 @@ def test_swagger_securuty(simple_parser):
                         ],
                     ),
                 ],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             ),
             model.Operation(
                 description='',
                 path='/',
                 method='post',
-                operationId='Post',
+                operationId=None,
                 parameters=[],
                 responses={},
                 requestBody=[],
@@ -335,12 +350,14 @@ def test_swagger_securuty(simple_parser):
                         ],
                     ),
                 ],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             ),
             model.Operation(
                 description='',
                 path='/',
                 method='put',
-                operationId='Put',
+                operationId=None,
                 parameters=[],
                 responses={},
                 requestBody=[],
@@ -368,6 +385,8 @@ def test_swagger_securuty(simple_parser):
                         ],
                     ),
                 ],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
             ),
         ],
     )
@@ -449,13 +468,15 @@ def test_swagger_parameters(simple_parser):
                 description='',
                 path='/',
                 method='get',
-                operationId='Get',
+                operationId=None,
                 responses={},
                 requestBody=[
                     model.RequestBody(content_type='text/plain; charset=utf-8', required=True, schema=types.Number()),
                     model.RequestBody(content_type='application/json', required=True, schema=types.Number()),
                 ],
                 security=[],
+                x_middlewares=base_model.XMiddlewares(tvm=True),
+                x_client_codegen=True,
                 parameters=[
                     model.Parameter(
                         name='pamparam2',
@@ -467,6 +488,8 @@ def test_swagger_parameters(simple_parser):
                         examples={},
                         deprecated=False,
                         allowEmptyValue=False,
+                        x_cpp_name=None,
+                        x_query_log_mode_hide=False,
                     ),
                     model.Parameter(
                         name='pamparam2',
@@ -478,8 +501,73 @@ def test_swagger_parameters(simple_parser):
                         examples={},
                         deprecated=False,
                         allowEmptyValue=False,
+                        x_cpp_name=None,
+                        x_query_log_mode_hide=False,
                     ),
                 ],
             )
         ],
     )
+
+
+@pytest.mark.parametrize(
+    'consumes',
+    [
+        'multipart/form-data',
+        'application/x-www-form-urlencoded',
+    ],
+)
+def test_swagger_file_in_body_ok(simple_parser, consumes):
+    simple_parser(
+        {
+            'swagger': '2.0',
+            'info': {},
+            'paths': {
+                '/': {
+                    'get': {
+                        'consumes': [consumes],
+                        'parameters': [
+                            {
+                                'name': 'pamparam',
+                                'in': 'formData',
+                                'required': True,
+                                'type': 'file',
+                            },
+                        ],
+                        'responses': {},
+                    },
+                },
+            },
+        },
+    )
+
+
+def test_swagger_file_in_body_wrong_consumes(simple_parser):
+    with pytest.raises(error.BaseError) as exc_info:
+        simple_parser(
+            {
+                'swagger': '2.0',
+                'info': {},
+                'paths': {
+                    '/': {
+                        'get': {
+                            'consumes': ['application/json'],
+                            'parameters': [
+                                {
+                                    'name': 'pamparam',
+                                    'in': 'formData',
+                                    'required': True,
+                                    'type': 'file',
+                                },
+                            ],
+                            'responses': {},
+                        },
+                    },
+                },
+            },
+        )
+
+    assert (
+        exc_info.value.msg
+        == '"consumes" must be either "multipart/form-data" or "application/x-www-form-urlencoded" for "type: file"'
+    )
diff --git a/chaotic/CMakeLists.txt b/chaotic/CMakeLists.txt
index 475eceb28abd..b8b749c24c7f 100644
--- a/chaotic/CMakeLists.txt
+++ b/chaotic/CMakeLists.txt
@@ -7,6 +7,7 @@ userver_module(
     SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
     LINK_LIBRARIES userver::universal
+    DEPENDS universal
     NO_CORE_LINK
 )
 
@@ -24,7 +25,11 @@ if(USERVER_BUILD_TESTS)
     )
 
     add_subdirectory(integration_tests)
-    add_subdirectory(golden_tests)
+
+    option(USERVER_CHAOTIC_GOLDEN_TESTS "Whether to run golden tests of chaotic" ON)
+    if (USERVER_CHAOTIC_GOLDEN_TESTS)
+        add_subdirectory(golden_tests)
+    endif()
 endif()
 
 _userver_directory_install(
diff --git a/chaotic/chaotic/back/cpp/renderer.py b/chaotic/chaotic/back/cpp/renderer.py
index c05fa3229bec..88a898b4db69 100644
--- a/chaotic/chaotic/back/cpp/renderer.py
+++ b/chaotic/chaotic/back/cpp/renderer.py
@@ -2,8 +2,6 @@
 import dataclasses
 import os
 import pathlib
-from typing import Dict
-from typing import List
 from typing import Optional
 
 import jinja2
@@ -26,7 +24,7 @@ class CppOutputFile:
 @dataclasses.dataclass
 class CppOutput:
     filepath_wo_ext: str
-    files: List[CppOutputFile]
+    files: list[CppOutputFile]
 
 
 current_namespace = ''  # pylint: disable=invalid-name
@@ -76,14 +74,14 @@ def cpp_type(name: str) -> str:
     return name_part
 
 
-def declaration_includes(types: List[cpp_types.CppType]) -> List[str]:
+def declaration_includes(types: list[cpp_types.CppType]) -> list[str]:
     includes = set()
     for type_ in types:
         includes.update(set(type_.declaration_includes()))
     return sorted(includes)
 
 
-def definition_includes(types: List[cpp_types.CppType]) -> List[str]:
+def definition_includes(types: list[cpp_types.CppType]) -> list[str]:
     includes = set()
     for type_ in types:
         includes.update(set(type_.definition_includes()))
@@ -144,7 +142,7 @@ def __init__(
         self,
         *,
         relative_to: str,
-        vfilepath_to_relfilepath: Dict[str, str],
+        vfilepath_to_relfilepath: dict[str, str],
         clang_format_bin: str,
         parse_extra_formats: bool = False,
         generate_serializer: bool = False,
@@ -165,9 +163,9 @@ def _vfilepath_to_relfilepath(self, vfilepath: str) -> str:
 
     def extract_external_includes(
         self,
-        types_cpp: Dict[str, cpp_types.CppType],
+        types_cpp: dict[str, cpp_types.CppType],
         ignore_filepath_wo_ext: str,
-    ) -> List[str]:
+    ) -> list[str]:
         result = set()
 
         def visitor(
@@ -200,11 +198,11 @@ def filepath_to_include(self, filepath_wo_ext: str) -> str:
 
     def render(
         self,
-        types: Dict[str, cpp_types.CppType],
+        types: dict[str, cpp_types.CppType],
         local_pair_header=True,
         pair_header: Optional[str] = None,
-    ) -> List[CppOutput]:
-        files: Dict[str, Dict[str, cpp_types.CppType]] = collections.defaultdict(dict)
+    ) -> list[CppOutput]:
+        files: dict[str, dict[str, cpp_types.CppType]] = collections.defaultdict(dict)
 
         for name, type_ in types.items():
             assert type_.json_schema
@@ -297,7 +295,7 @@ def render(
         return output
 
     @staticmethod
-    def get_output_files(stem: str, path: str) -> List[str]:
+    def get_output_files(stem: str, path: str) -> list[str]:
         return [
             f'include/{path}/{stem}_fwd.hpp',
             f'include/{path}/{stem}_parsers.ipp',
diff --git a/chaotic/chaotic/back/cpp/translator.py b/chaotic/chaotic/back/cpp/translator.py
index fefa06cbcc3e..4bea33ef8212 100644
--- a/chaotic/chaotic/back/cpp/translator.py
+++ b/chaotic/chaotic/back/cpp/translator.py
@@ -4,27 +4,25 @@
 import pathlib
 import re
 from typing import Callable
-from typing import Dict
-from typing import List
 from typing import NoReturn
 from typing import Optional
-from typing import Set
 
 from chaotic import cpp_names
 from chaotic import error
 from chaotic.back.cpp import type_name
 from chaotic.back.cpp import types as cpp_types
+from chaotic.front import ref
 from chaotic.front import types
 
 
 @dataclasses.dataclass
 class GeneratorConfig:
     # vfull -> namespace
-    namespaces: Dict[str, str]
+    namespaces: dict[str, str]
     # infile_path -> cpp type
     infile_to_name_func: Callable
     # type: ignore
-    include_dirs: Optional[List[str]] = dataclasses.field(
+    include_dirs: Optional[list[str]] = dataclasses.field(
         # type: ignore
         default_factory=list,
     )
@@ -34,11 +32,11 @@ class GeneratorConfig:
 
 @dataclasses.dataclass
 class GeneratorState:
-    types: Dict[str, cpp_types.CppType]
-    refs: Dict[types.Schema, str]  # type: ignore
-    ref_objects: List[cpp_types.CppRef]
-    external_types: Dict[types.Schema, cpp_types.CppType]  # type: ignore
-    seen_includes: Set[str]
+    types: dict[str, cpp_types.CppType]
+    refs: dict[types.Schema, str]  # type: ignore
+    ref_objects: list[cpp_types.CppRef]
+    external_types: dict[types.Schema, cpp_types.CppType]  # type: ignore
+    seen_includes: set[str]
 
 
 NON_NAME_SYMBOL_RE = re.compile('[^_0-9a-zA-Z]')
@@ -47,11 +45,11 @@ class GeneratorState:
 
 
 class FormatChooser:
-    def __init__(self, types: List[cpp_types.CppType]) -> None:
+    def __init__(self, types: list[cpp_types.CppType]) -> None:
         self.types = types
-        self.parent: Dict[
+        self.parent: dict[
             cpp_types.CppType,
-            List[Optional[cpp_types.CppType]],
+            list[Optional[cpp_types.CppType]],
         ] = collections.defaultdict(list)
 
     def check_for_json_onlyness(self) -> None:
@@ -117,8 +115,8 @@ def __init__(self, config: GeneratorConfig) -> None:
     def generate_types(
         self,
         schemas: types.ResolvedSchemas,
-        external_schemas: Dict[str, cpp_types.CppType] = {},
-    ) -> Dict[str, cpp_types.CppType]:
+        external_schemas: dict[str, cpp_types.CppType] = {},
+    ) -> dict[str, cpp_types.CppType]:
         self._state.seen_includes = set()
 
         for cpp_type in external_schemas.values():
@@ -128,6 +126,16 @@ def generate_types(
 
         for name, schema in schemas.schemas.items():
             fq_cpp_name = self._gen_fq_cpp_name(name)
+            if fq_cpp_name in self._state.types:
+                sl1 = schema.source_location()
+                path1 = f'{sl1.filepath}#{sl1.location}'
+
+                existing_schema = self._state.types[fq_cpp_name].json_schema
+                assert existing_schema
+                sl2 = existing_schema.source_location()
+                path2 = f'{sl2.filepath}#{sl2.location}'
+                raise Exception(f'Duplicate type name: {fq_cpp_name}, generated from {path1} and {path2}')
+
             self._state.refs[schema] = fq_cpp_name
             self._state.types[fq_cpp_name] = self._generate_type(
                 type_name.TypeName(fq_cpp_name),
@@ -140,7 +148,7 @@ def generate_types(
         return self._state.types
 
     @property
-    def seen_includes(self) -> Set[str]:
+    def seen_includes(self) -> set[str]:
         return self._state.seen_includes
 
     def _validate_type(self, type_: cpp_types.CppType) -> None:
@@ -149,11 +157,15 @@ def _validate_type(self, type_: cpp_types.CppType) -> None:
         if type_.has_generated_user_cpp_type():
             return
 
+        user_includes = type_.get_includes_by_cpp_type(type_.user_cpp_type)
+        for user_include in user_includes:
+            self._validate_user_include_exists(type_, user_include)
+
+    def _validate_user_include_exists(self, type_: cpp_types.CppType, user_include: str) -> None:
         if self._config.include_dirs is None:
             # no check at all
             return
 
-        user_include = type_.cpp_type_to_user_include_path(type_.user_cpp_type)
         for include_dir in self._config.include_dirs:
             path = os.path.join(include_dir, user_include)
             if os.path.exists(path):
@@ -217,19 +229,19 @@ def _extract_container(self, schema: types.Schema) -> str:
         return container
 
     def fixup_refs(self) -> None:
-        for ref in self._state.ref_objects:
-            assert isinstance(ref.json_schema, types.Ref)
-            schema = ref.json_schema.schema
+        for ref_ in self._state.ref_objects:
+            assert isinstance(ref_.json_schema, types.Ref)
+            schema = ref_.json_schema.schema
             name = self._state.refs.get(schema)
             if name:
                 orig_cpp_type = self._state.types[name]
             else:
                 orig_cpp_type = self._state.external_types[schema]
 
-            ref.orig_cpp_type = orig_cpp_type
-            ref.indirect = ref.json_schema.indirect
-            ref.self_ref = ref.json_schema.self_ref
-            ref.cpp_name = name
+            ref_.orig_cpp_type = orig_cpp_type
+            ref_.indirect = ref_.json_schema.indirect
+            ref_.self_ref = ref_.json_schema.self_ref
+            ref_.cpp_name = name
 
     def fixup_formats(self) -> None:
         chooser = FormatChooser(list(self._state.types.values()))
@@ -247,9 +259,9 @@ def _generate_type(
         return cpp_type
 
     def _gen_fq_cpp_name(self, jsonschema_name: str) -> str:
-        vfile, infile = jsonschema_name.split('#')
-        name = self._config.infile_to_name_func(infile, pathlib.Path(vfile).stem)
-        namespace = self._config.namespaces[vfile]
+        reference = ref.Ref(jsonschema_name)
+        name = self._config.infile_to_name_func(reference.fragment, pathlib.Path(reference.file).stem)
+        namespace = self._config.namespaces[reference.file]
         if namespace:
             return '::' + namespace + '::' + name
         else:
@@ -285,7 +297,7 @@ def _gen_integer(
             if 'x-enum-varnames' in schema.x_properties:
                 enum_names = schema.x_properties['x-enum-varnames']
 
-            emum_items: List[cpp_types.CppIntEnumItem] = []
+            emum_items: list[cpp_types.CppIntEnumItem] = []
 
             def to_camel_case(text: str) -> str:
                 words = SPLIT_RE.findall(text)
@@ -607,8 +619,8 @@ def _gen_one_of_with_discriminator(
             mapping_values = schema.mapping.as_ints()
 
         for field_value, refs in zip(schema.oneOf, mapping_values):
-            for ref in refs:
-                variants[ref] = self._gen_ref(
+            for ref_ in refs:
+                variants[ref_] = self._gen_ref(
                     type_name.TypeName(''),
                     field_value,
                 )
@@ -698,7 +710,7 @@ def _gen_ref(
         name: type_name.TypeName,
         schema: types.Ref,
     ) -> cpp_types.CppType:
-        ref = cpp_types.CppRef(
+        ref_ = cpp_types.CppRef(
             json_schema=schema,
             nullable=False,
             # stub
@@ -713,8 +725,8 @@ def _gen_ref(
             indirect=False,
             self_ref=False,
         )
-        self._state.ref_objects.append(ref)
-        return ref
+        self._state.ref_objects.append(ref_)
+        return ref_
 
 
 # pylint: disable=protected-access
diff --git a/chaotic/chaotic/back/cpp/type_name.py b/chaotic/chaotic/back/cpp/type_name.py
index dd7071be73b4..21970a445912 100644
--- a/chaotic/chaotic/back/cpp/type_name.py
+++ b/chaotic/chaotic/back/cpp/type_name.py
@@ -1,9 +1,8 @@
-from typing import List
 from typing import Union
 
 
 class TypeName:
-    def __init__(self, name: Union[str, List[str]]) -> None:
+    def __init__(self, name: Union[str, list[str]]) -> None:
         if isinstance(name, str):
             self._components = name.split('::')
         else:
diff --git a/chaotic/chaotic/back/cpp/types.py b/chaotic/chaotic/back/cpp/types.py
index 5b65341098ab..016c7092947b 100644
--- a/chaotic/chaotic/back/cpp/types.py
+++ b/chaotic/chaotic/back/cpp/types.py
@@ -2,8 +2,6 @@
 import dataclasses
 import itertools
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
 from typing import Union
 
@@ -45,13 +43,13 @@ def without_json_schema(self) -> 'CppType':
 
     # Should return only direct subtypes, not recursively because
     # jinja's generate_*() is called recursively.
-    def subtypes(self) -> List['CppType']:
+    def subtypes(self) -> list['CppType']:
         return []
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         raise NotImplementedError()
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         raise NotImplementedError()
 
     def parser_type(self, ns: str, name: str) -> str:
@@ -123,26 +121,32 @@ def cpp_comment(self) -> str:
         assert self.json_schema
 
         kwargs = self.json_schema.x_properties
-        description = kwargs.get('description')
+        description = (kwargs.get('title', '') + '\n' + kwargs.get('description', '')).strip()
         if description:
             return '// ' + description.replace('\n', '\n//')
         else:
             return ''
 
     @classmethod
-    def cpp_type_to_user_include_path(cls, cpp_type: str) -> str:
+    def get_includes_by_cpp_type(cls, cpp_type: str) -> list[str]:
+        includes = []
+
         parts = cpp_type.split('<', 1)
         cpp_type = parts[0]
         if cpp_type == 'userver::utils::StrongTypedef' and parts[1][-1] == '>':
             cpp_type = parts[1].split(', ', 1)[0]
+            includes.append('userver/utils/strong_typedef.hpp')
+        elif cpp_type == 'utils::StrongTypedef' and parts[1][-1] == '>':
+            # legacy uservices
+            cpp_type = parts[1].split(', ', 1)[0]
+            includes.append('userver/utils/strong_typedef.hpp')
 
         if cpp_type.startswith('::'):
             cpp_type = cpp_type[2:]
-        return 'userver/chaotic/io/' + camel_to_snake_case(cpp_type.replace('::', '/')) + '.hpp'
 
-    @classmethod
-    def get_include_by_cpp_type(cls, cpp_type: str) -> List[str]:
-        return [cls.cpp_type_to_user_include_path(cpp_type)]
+        includes.append('userver/chaotic/io/' + camel_to_snake_case(cpp_type.replace('::', '/')) + '.hpp')
+
+        return includes
 
     def _primitive_parser_type(self) -> str:
         raw_cpp_type = f'USERVER_NAMESPACE::chaotic::Primitive<{self.raw_cpp_type.in_global_scope()}>'
@@ -247,10 +251,10 @@ class CppPrimitiveType(CppType):
 
     __hash__ = CppType.__hash__
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         includes = []
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
 
         assert self.json_schema
         type_ = self.json_schema.type  # type: ignore
@@ -258,13 +262,13 @@ def declaration_includes(self) -> List[str]:
             includes.append('cstdint')
         elif type_ in ('number', 'boolean'):
             pass
-        elif type_ == 'string':
+        elif type_ in ('string', 'file'):
             includes.append('string')
         else:
             raise NotImplementedError(type_)
         return includes
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         includes = ['userver/chaotic/primitive.hpp']
         if not self.validators.is_none():
             includes.append('userver/chaotic/validators.hpp')
@@ -344,16 +348,16 @@ def cpp_user_name(self) -> str:
             cpp_type = 'USERVER_NAMESPACE::' + cpp_type[len(USERVER_COLONCOLON) :]
         return cpp_type
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         includes = []
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
-        includes += self.get_include_by_cpp_type(self.format_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
+        includes += self.get_includes_by_cpp_type(self.format_cpp_type)
 
         includes.append('string')
         return includes
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         includes = ['userver/chaotic/primitive.hpp']
         includes.append('userver/chaotic/with_type.hpp')
         return includes
@@ -406,7 +410,7 @@ def cpp_user_name(self) -> str:
             else:
                 return self.cpp_name
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         if self.indirect:
             return ['userver/utils/box.hpp']
         if self.self_ref:
@@ -414,7 +418,7 @@ def declaration_includes(self) -> List[str]:
         else:
             return self.orig_cpp_type.declaration_includes()
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         if self.indirect:
             return ['userver/chaotic/ref.hpp']
         if self.self_ref:
@@ -444,21 +448,21 @@ class CppIntEnumItem:
     raw_name: str
     cpp_name: str
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         return ['fmt/core.h']
 
 
 @dataclasses.dataclass
 class CppIntEnum(CppType):
     name: str
-    enums: List[CppIntEnumItem]
+    enums: list[CppIntEnumItem]
 
     __hash__ = CppType.__hash__
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         return ['fmt/core.h']
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         return [
             'cstdint',
             'userver/chaotic/exception.hpp',
@@ -484,22 +488,22 @@ class CppStringEnumItem:
     raw_name: str
     cpp_name: str
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         return ['fmt/core.h']
 
 
 @dataclasses.dataclass
 class CppStringEnum(CppType):
     name: str
-    enums: List[CppStringEnumItem]
+    enums: list[CppStringEnumItem]
     default: Optional[EnumItemName]
 
     __hash__ = CppType.__hash__
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         return ['string', 'fmt/core.h']
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         return [
             'userver/chaotic/exception.hpp',
             'userver/chaotic/primitive.hpp',
@@ -604,7 +608,7 @@ def cpp_field_parse_type(self) -> str:
 
 @dataclasses.dataclass
 class CppStruct(CppType):
-    fields: Dict[str, CppStructField]
+    fields: dict[str, CppStructField]
     # 'None' means 'do not generate extra member'
     extra_type: Union[CppType, bool, None] = False
     autodiscover_default_dict: bool = False
@@ -665,7 +669,7 @@ def parser_type(self, ns: str, name: str) -> str:
             return f'USERVER_NAMESPACE::chaotic::WithType<{parser_type}, {dict_type}>'
         return parser_type
 
-    def subtypes(self) -> List[CppType]:
+    def subtypes(self) -> list[CppType]:
         types = [field.schema for field in self.fields.values()]
         if isinstance(self.extra_type, CppType) and not self._is_default_dict():
             types.append(self.extra_type)
@@ -679,10 +683,10 @@ def extra_container(self) -> str:
             kwargs.get('x-taxi-cpp-extra-type', 'std::unordered_map'),
         )
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         includes = ['optional']
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
         for field in self.fields.values():
             includes.extend(field.schema.declaration_includes())
 
@@ -690,7 +694,7 @@ def declaration_includes(self) -> List[str]:
             includes.append('string')
             if isinstance(self.extra_type, CppType):
                 extra_container = self.extra_container()
-                includes += self.get_include_by_cpp_type(extra_container)
+                includes += self.get_includes_by_cpp_type(extra_container)
                 includes.extend(self.extra_type.declaration_includes())
             else:
                 includes.append('userver/formats/json/value.hpp')
@@ -699,7 +703,7 @@ def declaration_includes(self) -> List[str]:
             includes.append('userver/utils/default_dict.hpp')
         return includes
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         includes = [
             'userver/formats/parse/common_containers.hpp',
             'userver/formats/serialize/common_containers.hpp',
@@ -718,7 +722,7 @@ def definition_includes(self) -> List[str]:
         if isinstance(self.extra_type, CppType):
             includes.extend(self.extra_type.definition_includes())
         if self._is_default_dict():
-            includes += self.get_include_by_cpp_type(
+            includes += self.get_includes_by_cpp_type(
                 'userver::utils::DefaultDict<>',
             )
         return includes
@@ -767,7 +771,7 @@ def without_json_schema(self) -> 'CppArray':
         tmp.items = self.items.without_json_schema()
         return tmp
 
-    def subtypes(self) -> List[CppType]:
+    def subtypes(self) -> list[CppType]:
         return [self.items]
 
     def parser_type(self, ns: str, name: str) -> str:
@@ -787,13 +791,13 @@ def parser_type(self, ns: str, name: str) -> str:
             parser_type = f'USERVER_NAMESPACE::chaotic::WithType<{parser_type}, {user_cpp_type}>'
         return parser_type
 
-    def declaration_includes(self) -> List[str]:
-        includes = self.get_include_by_cpp_type(self.container) + self.items.declaration_includes()
+    def declaration_includes(self) -> list[str]:
+        includes = self.get_includes_by_cpp_type(self.container) + self.items.declaration_includes()
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
         return includes
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         return [
             'userver/chaotic/array.hpp',
             'userver/chaotic/with_type.hpp',
@@ -812,20 +816,20 @@ def flatten(data: list) -> list:
 
 @dataclasses.dataclass
 class CppStructAllOf(CppType):
-    parents: List[CppType]
+    parents: list[CppType]
 
     KNOWN_X_PROPERTIES = ['x-usrv-cpp-type', 'x-taxi-cpp-type']
 
     __hash__ = CppType.__hash__
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         includes = []
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
         includes += flatten([item.declaration_includes() for item in self.parents])
         return includes
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         return [
             'userver/formats/common/merge.hpp',
             'userver/chaotic/primitive.hpp',
@@ -834,7 +838,7 @@ def definition_includes(self) -> List[str]:
     def parser_type(self, ns: str, name: str) -> str:
         return self._primitive_parser_type()
 
-    def subtypes(self) -> List[CppType]:
+    def subtypes(self) -> list[CppType]:
         return self.parents
 
     def need_dom_parser(self) -> bool:
@@ -849,16 +853,16 @@ def need_operator_eq(self) -> bool:
 
 @dataclasses.dataclass
 class CppVariant(CppType):
-    variants: List[CppType]
+    variants: list[CppType]
 
     KNOWN_X_PROPERTIES = ['x-usrv-cpp-type', 'x-taxi-cpp-type']
 
     __hash__ = CppType.__hash__
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         includes = []
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
         return (
             includes
             + [
@@ -869,7 +873,7 @@ def declaration_includes(self) -> List[str]:
             + flatten([item.declaration_includes() for item in self.variants])
         )
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         return [
             'userver/chaotic/primitive.hpp',
             'userver/chaotic/variant.hpp',
@@ -885,7 +889,7 @@ def parser_type(self, ns: str, name: str) -> str:
         else:
             return parser_type
 
-    def subtypes(self) -> List[CppType]:
+    def subtypes(self) -> list[CppType]:
         return self.variants
 
     def need_operator_lshift(self) -> bool:
@@ -895,21 +899,21 @@ def need_operator_lshift(self) -> bool:
 @dataclasses.dataclass
 class CppVariantWithDiscriminator(CppType):
     property_name: str
-    variants: Dict[str, CppType]
+    variants: dict[str, CppType]
     mapping_type: types.MappingType = types.MappingType.STR
 
     KNOWN_X_PROPERTIES = ['x-usrv-cpp-type', 'x-taxi-cpp-type']
 
     __hash__ = CppType.__hash__
 
-    def declaration_includes(self) -> List[str]:
+    def declaration_includes(self) -> list[str]:
         includes = ['variant', 'userver/chaotic/oneof_with_discriminator.hpp']
 
         if self.user_cpp_type:
-            includes += self.get_include_by_cpp_type(self.user_cpp_type)
+            includes += self.get_includes_by_cpp_type(self.user_cpp_type)
         return includes + flatten([item.declaration_includes() for item in self.variants.values()])
 
-    def definition_includes(self) -> List[str]:
+    def definition_includes(self) -> list[str]:
         return ['userver/formats/json/serialize_variant.hpp'] + flatten([
             item.definition_includes() for item in self.variants.values()
         ])
diff --git a/chaotic/chaotic/compilers/dynamic_config.py b/chaotic/chaotic/compilers/dynamic_config.py
index 6e37d5294174..ce6e7e0300d7 100644
--- a/chaotic/chaotic/compilers/dynamic_config.py
+++ b/chaotic/chaotic/compilers/dynamic_config.py
@@ -3,10 +3,6 @@
 import pathlib
 import subprocess
 from typing import Any
-from typing import Dict
-from typing import List
-from typing import Set
-from typing import Tuple
 
 import jinja2
 import yaml
@@ -16,12 +12,16 @@
 from chaotic.back.cpp import renderer
 from chaotic.back.cpp import translator
 from chaotic.back.cpp import types
+from chaotic.front import ref
 from chaotic.front.types import ResolvedSchemas
 from chaotic.main import generate_cpp_name_func
 from chaotic.main import NameMapItem
 from chaotic.main import read_schemas
 
-INCLUDE_DIR = str(pathlib.Path(__file__).parent.parent.parent / 'include')
+INCLUDE_DIRS = [
+    str(pathlib.Path(__file__).parent.parent.parent / 'include'),
+    str(pathlib.Path(__file__).parent.parent.parent.parent / 'universal' / 'include'),
+]
 TEMPLATE_DIR = str(pathlib.Path(__file__).parent / 'dynamic_config' / 'templates')
 
 CLANG_FORMAT_BIN = None
@@ -80,25 +80,25 @@ def enrich_jinja_env(env: jinja2.Environment) -> None:
 
 class CompilerBase:
     def __init__(self) -> None:
-        self._variables_types: Dict[str, Dict[str, types.CppType]] = {}
-        self._definitions: Dict[
+        self._variables_types: dict[str, dict[str, types.CppType]] = {}
+        self._definitions: dict[
             str,
-            Tuple[ResolvedSchemas, Dict[str, types.CppType]],
+            tuple[ResolvedSchemas, dict[str, types.CppType]],
         ] = {}
-        self._defaults: Dict[str, Any] = {}
-        self.seen_includes: Dict[str, Set[str]] = {}
+        self._defaults: dict[str, Any] = {}
+        self.seen_includes: dict[str, set[str]] = {}
 
-    def extract_definition_names(self, filepath: str) -> List[str]:
+    def extract_definition_names(self, filepath: str) -> list[str]:
         with open(filepath, 'r') as ifile:
             content = yaml.load(ifile, Loader=yaml.CLoader)
         return list(set(self._extract_definition_names(content)) - set(['']))
 
-    def _extract_definition_names(self, content: Any) -> List[str]:
+    def _extract_definition_names(self, content: Any) -> list[str]:
         if isinstance(content, dict):
             refs = []
-            ref = content.get('$ref')
-            if isinstance(ref, str):
-                filename = ref.split('#')[0]
+            ref_ = content.get('$ref')
+            if isinstance(ref_, str):
+                filename = ref.Ref(ref_).file
                 refs.append(filename)
 
             for value in content.values():
@@ -130,7 +130,7 @@ def parse_definition(
         self,
         filepath: str,
         name: str,
-        include_dirs: List[str] = [],
+        include_dirs: list[str] = [],
     ) -> None:
         name_lower = self.format_ns_name(name)
         name_map = [NameMapItem('/([^/]+)/={0}')]
@@ -148,16 +148,16 @@ def parse_definition(
         self._definitions[name] = (schemas, types)
         self.seen_includes[filepath] = seen_includes
 
-    def definitions_includes_hpp(self) -> List[str]:
+    def definitions_includes_hpp(self) -> list[str]:
         types = self._collect_types()
-        includes: List[str] = []
+        includes: list[str] = []
         for type_ in types.values():
             includes += type_.declaration_includes()
         return sorted(set(includes))
 
-    def definitions_includes_cpp(self) -> List[str]:
+    def definitions_includes_cpp(self) -> list[str]:
         types = self._collect_types()
-        includes: List[str] = []
+        includes: list[str] = []
         for type_ in types.values():
             includes += type_.definition_includes()
         return sorted(set(includes))
@@ -167,7 +167,7 @@ def parse_variable(
         filepath: str,
         name: str,
         namespace: str,
-        include_dirs: List[str] = [],
+        include_dirs: list[str] = [],
     ) -> None:
         name_lower = self.format_ns_name(name)
         name_map = [
@@ -193,13 +193,13 @@ def parse_variable(
         self._defaults[name] = self._read_default(filepath)
         self.seen_includes[filepath] = seen_includes
 
-    def _collect_schemas(self) -> List[ResolvedSchemas]:
+    def _collect_schemas(self) -> list[ResolvedSchemas]:
         schemas = []
         for def_schemas, _definitions in self._definitions.values():
             schemas.append(def_schemas)
         return schemas
 
-    def _collect_types(self) -> Dict[str, types.CppType]:
+    def _collect_types(self) -> dict[str, types.CppType]:
         types = {}
         for _def_schemas, definitions in self._definitions.values():
             types.update(definitions)
@@ -212,8 +212,8 @@ def _generate_types(
         erase_prefix: str,
         name_map,
         fname: str,
-        include_dirs: List[str],
-    ) -> Tuple[ResolvedSchemas, Dict[str, types.CppType], Set[str]]:
+        include_dirs: list[str],
+    ) -> tuple[ResolvedSchemas, dict[str, types.CppType], set[str]]:
         schemas = read_schemas(
             erase_path_prefix=erase_prefix,
             filepaths=[filepath],
@@ -227,7 +227,7 @@ def _generate_types(
         )
         gen = translator.Generator(
             config=translator.GeneratorConfig(
-                include_dirs=include_dirs + [INCLUDE_DIR],
+                include_dirs=include_dirs + INCLUDE_DIRS,
                 namespaces={fname: namespace},
                 infile_to_name_func=cpp_name_func,
                 autodiscover_default_dict=True,
@@ -240,22 +240,22 @@ def _generate_types(
         )
         return schemas, types, gen.seen_includes
 
-    def variables_includes_hpp(self, name: str) -> List[str]:
+    def variables_includes_hpp(self, name: str) -> list[str]:
         types = self._variables_types[name]
-        includes: List[str] = []
+        includes: list[str] = []
         for type_ in types.values():
             includes += type_.declaration_includes()
 
         return sorted(set(includes))
 
-    def variables_includes_cpp(self, name: str) -> List[str]:
+    def variables_includes_cpp(self, name: str) -> list[str]:
         types = self._variables_types[name]
-        includes: List[str] = []
+        includes: list[str] = []
         for type_ in types.values():
             includes += type_.definition_includes()
         return sorted(set(includes))
 
-    def variables_external_includes_hpp(self, name: str) -> List[str]:
+    def variables_external_includes_hpp(self, name: str) -> list[str]:
         types = self._variables_types[name]
         return self.renderer_for_variable(
             name,
@@ -273,8 +273,8 @@ def _jinja(self) -> jinja2.Environment:
 
     def create_aliases(
         self,
-        types: Dict[str, types.CppType],
-    ) -> List[Tuple[str, str]]:
+        types: dict[str, types.CppType],
+    ) -> list[tuple[str, str]]:
         return []
 
     def renderer_for_variable(
diff --git a/chaotic/chaotic/front/parser.py b/chaotic/chaotic/front/parser.py
index b7200b2dd8b4..a4592ff9448a 100644
--- a/chaotic/chaotic/front/parser.py
+++ b/chaotic/chaotic/front/parser.py
@@ -3,20 +3,22 @@
 import dataclasses
 import os
 import re
-from typing import Dict
+from typing import Any
 from typing import Generator
-from typing import List
 from typing import NoReturn
 from typing import Optional
 from typing import Union
 
 from chaotic import error
+from chaotic.front import ref
 from chaotic.front import types
 
 
 @dataclasses.dataclass(frozen=True)
 class ParserConfig:
     erase_prefix: str
+    # Allow type: file
+    allow_file: bool = False
 
 
 @dataclasses.dataclass
@@ -24,7 +26,7 @@ class ParserState:
     # Current location in file
     infile_path: str
 
-    schemas: Dict[str, types.Schema]
+    schemas: dict[str, types.Schema]
     schema_type: str = 'jsonschema'
 
 
@@ -89,7 +91,7 @@ def do_parse_schema(self, input__: dict) -> Union[types.Schema, types.Ref]:
     def _parse_allof(self, variants: list, input__: dict) -> types.AllOf:
         raw = types.AllOfRaw(**input__)
 
-        variables: List[types.Schema] = []
+        variables: list[types.Schema] = []
         with self._path_enter('allOf') as _:
             for i, variant in enumerate(variants):
                 with self._path_enter(str(i)) as _:
@@ -113,7 +115,10 @@ def _parse_oneof(self, variants: list, input__: dict) -> types.Schema:
                     with self._path_enter(str(i)) as _:
                         type_ = self._parse_schema(variant)
                         variables.append(type_)
-                obj = types.OneOfWithoutDiscriminator(oneOf=variables)
+                obj = types.OneOfWithoutDiscriminator(
+                    oneOf=variables,
+                    nullable=raw.nullable,
+                )
                 obj.x_properties = raw.x_properties  # type:ignore
                 return obj
 
@@ -129,7 +134,10 @@ def _parse_oneof_i(
             self._raise('Not a $ref in oneOf with discriminator')
 
         assert self._state
-        dest_type = self._state.schemas.get(type_.ref)
+        dest_type: Any = type_
+        while isinstance(dest_type, types.Ref):
+            dest_type = self._state.schemas.get(dest_type.ref)
+
         # TODO: fix in TAXICOMMON-8910
         #
         # if not dest_type:
@@ -139,7 +147,7 @@ def _parse_oneof_i(
         #     )
         if dest_type:
             if not isinstance(dest_type, types.SchemaObject):
-                self._raise('oneOf $ref to non-object')
+                self._raise(f'oneOf $ref to non-object ({type(dest_type).__name__})')
             if discriminator_property not in (dest_type.properties or {}):
                 self._raise(
                     f'No discriminator property "{discriminator_property}"',
@@ -150,7 +158,7 @@ def _parse_oneof_i(
     def _parse_oneof_disc_mapping(
         self,
         user_mapping: dict,
-        variables: List[types.Ref],
+        variables: list[types.Ref],
     ) -> types.DiscMapping:
         with self._path_enter('discriminator/mapping') as _:
             idx_mapping = collections.defaultdict(list)
@@ -171,11 +179,11 @@ def _parse_oneof_disc_mapping(
 
                     idx_mapping[abs_ref].append(key)
 
-            for ref in variables:
-                assert isinstance(ref, types.Ref)
-                map_value = idx_mapping.pop(ref.ref, None)
+            for ref_ in variables:
+                assert isinstance(ref_, types.Ref)
+                map_value = idx_mapping.pop(ref_.ref, None)
                 if map_value is None:
-                    self._raise(f'Missing $ref in mapping: {ref.ref}')
+                    self._raise(f'Missing $ref in mapping: {ref_.ref}')
 
                 mapping.append(map_value)
 
@@ -195,7 +203,7 @@ def _parse_oneof_w_discriminator(
 
         discriminator_property = input_['discriminator']['propertyName']
 
-        variables: List[types.Ref] = []
+        variables: list[types.Ref] = []
         with self._path_enter('oneOf') as _:
             for i, variant in enumerate(variants):
                 with self._path_enter(str(i)) as _:
@@ -209,11 +217,12 @@ def _parse_oneof_w_discriminator(
         if user_mapping is not None:
             mapping = self._parse_oneof_disc_mapping(user_mapping, variables)
         else:
-            mapping = types.DiscMapping(str_values=[[ref.ref.split('/')[-1]] for ref in variables], int_values=None)
+            mapping = types.DiscMapping(str_values=[[ref_.ref.split('/')[-1]] for ref_ in variables], int_values=None)
         obj = types.OneOfWithDiscriminator(
             oneOf=variables,
             discriminator_property=discriminator_property,
             mapping=mapping,
+            nullable=input_.get('nullable', False),
         )
 
         del input_['discriminator']
@@ -229,7 +238,6 @@ def _path_enter(self, path_component: str) -> Generator[None, None, None]:
         if self._state.infile_path:
             self._state.infile_path += '/'
         self._state.infile_path += path_component
-        # print(f'enter => {self._state.infile_path}')
 
         try:
             yield
@@ -240,7 +248,7 @@ def _path_enter(self, path_component: str) -> Generator[None, None, None]:
         except ParserError:
             raise
         except Exception as exc:  # pylint: disable=broad-exception-caught
-            self._raise(exc.__repr__())
+            self._raise(str(exc))
         else:
             self._state.infile_path = old
 
@@ -328,30 +336,40 @@ def _parse_string(self, input_: dict) -> types.String:
             fmt = None
         return types.String(**input_, format=fmt)
 
+    def _parse_file(self, input_: dict) -> types.String:
+        if not self._config.allow_file:
+            with self._path_enter('type') as _:
+                self._raise('"file" type is not allowed')
+
+        return self._parse_string(input_)
+
     REF_SHRINK_RE = re.compile('/[^/]+/\\.\\./')
     REF_SHRINK_DOT_RE = re.compile('/\\./')
 
     @staticmethod
-    def _normalize_ref(ref: str) -> str:
-        while SchemaParser.REF_SHRINK_RE.search(ref):
-            ref = re.sub(SchemaParser.REF_SHRINK_RE, '/', ref)
-        while SchemaParser.REF_SHRINK_DOT_RE.search(ref):
-            ref = re.sub(SchemaParser.REF_SHRINK_DOT_RE, '/', ref)
-        return ref
-
-    def _make_abs_ref(self, ref: str) -> str:
+    def _normalize_ref(ref_: str) -> str:
+        ref_ = '/' + ref_  # for regex simplicity
+
+        while SchemaParser.REF_SHRINK_RE.search(ref_):
+            ref_ = re.sub(SchemaParser.REF_SHRINK_RE, '/', ref_)
+        while SchemaParser.REF_SHRINK_DOT_RE.search(ref_):
+            ref_ = re.sub(SchemaParser.REF_SHRINK_DOT_RE, '/', ref_)
+
+        return ref_[1:]
+
+    def _make_abs_ref(self, ref_: str) -> str:
         assert self._state
 
-        if ref.startswith('#'):
+        if not ref.Ref(ref_).file:
             # Local $ref
-            return self.full_vfilepath + ref
+            return self.full_vfilepath + ref_
         else:
             my_ref = '/'.join(self.full_vfilepath.split('/')[:-1])
-            file, infile = ref.split('#')
-            out_file = self._normalize_ref(os.path.join(my_ref, file))
-            return out_file + '#' + infile
+            reference = ref.Ref(ref_)
+            out_file = self._normalize_ref(os.path.join(my_ref, reference.file))
+            return out_file + '#' + reference.fragment
 
-    def _parse_ref(self, ref: str, input_: dict) -> types.Ref:
+    def _parse_ref(self, ref_: str, input_: dict) -> types.Ref:
         assert self._state
 
         fields = set(input_.keys())
@@ -376,7 +394,7 @@ def _parse_ref(self, ref: str, input_: dict) -> types.Ref:
             self._raise(f'Unknown field(s) {list(fields)}')
 
         with self._path_enter('$ref') as _:
-            abs_ref = self._make_abs_ref(ref)
+            abs_ref = self._make_abs_ref(ref_)
             ref_value = types.Ref(
                 ref=abs_ref,
                 indirect=indirect,
@@ -399,6 +417,7 @@ def parsed_schemas(self) -> types.ParsedSchemas:
     'integer': SchemaParser._parse_int,
     'number': SchemaParser._parse_number,
     'string': SchemaParser._parse_string,
+    'file': SchemaParser._parse_file,
     'array': SchemaParser._parse_array,
     'object': SchemaParser._parse_object,
 }
diff --git a/chaotic/chaotic/front/ref.py b/chaotic/chaotic/front/ref.py
new file mode 100644
index 000000000000..a56548c7b9b6
--- /dev/null
+++ b/chaotic/chaotic/front/ref.py
@@ -0,0 +1,10 @@
+class Ref:
+    def __init__(self, ref: str) -> None:
+        self._ref = ref
+
+        parts = ref.split('#')
+        if len(parts) != 2:
+            raise Exception(f'Error in $ref ({ref}): there should be exactly one "#" inside')
+
+        self.file = parts[0]
+        self.fragment = parts[1]
diff --git a/chaotic/chaotic/front/ref_resolver.py b/chaotic/chaotic/front/ref_resolver.py
index 9166b82b965c..4498d97b62f5 100644
--- a/chaotic/chaotic/front/ref_resolver.py
+++ b/chaotic/chaotic/front/ref_resolver.py
@@ -1,9 +1,6 @@
 import collections
 from typing import Any
-from typing import Dict
-from typing import List
 from typing import Optional
-from typing import Set
 
 from chaotic import error
 from chaotic.front import types
@@ -13,9 +10,9 @@ class ResolverError(Exception):
     pass
 
 
-def sort_dfs(nodes: Set[str], edges: Dict[str, List[str]]) -> List[str]:
+def sort_dfs(nodes: set[str], edges: dict[str, list[str]]) -> list[str]:
     visited = set()
-    visiting: List[str] = []
+    visiting: list[str] = []
     sorted_nodes = []
 
     def do_node(node: str):
@@ -152,9 +149,9 @@ def _search_refs(cls, data: Any, *, inside_items: bool):
 
     def sort_json_types(
         self,
-        types: Dict[str, Any],
+        types: dict[str, Any],
         erase_path_prefix: str = '',
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         Sorts not-yet-parsed schemas. Required for correct allOf/oneOf parsing.
         """
diff --git a/chaotic/chaotic/front/types.py b/chaotic/chaotic/front/types.py
index 65d36ae5ca7e..777acfa1241e 100644
--- a/chaotic/chaotic/front/types.py
+++ b/chaotic/chaotic/front/types.py
@@ -4,8 +4,6 @@
 import typing
 from typing import Any
 from typing import Callable
-from typing import Dict
-from typing import List
 from typing import Optional
 from typing import TypeVar
 from typing import Union
@@ -22,7 +20,7 @@ def __init__(self, field: str, msg: str) -> None:
 def is_ignored_prefix(arg: str) -> bool:
     if arg.startswith('x-'):
         return True
-    if arg in ('description', 'example'):
+    if arg in ('description', 'example', 'title'):
         return True
     return False
 
@@ -77,7 +75,7 @@ def validate_type(field_name: str, value, type_) -> None:
                 f'field "{field_name}" has wrong type',
             )
     except TypeError:
-        # TODO: type=List[str]
+        # TODO: type=list[str]
         pass
 
 
@@ -105,7 +103,7 @@ def __post_init__(self) -> None:
 
 @dataclasses.dataclass
 class Schema(Base):
-    x_properties: Dict[str, Any] = dataclasses.field(
+    x_properties: dict[str, Any] = dataclasses.field(
         init=False,
         default_factory=dict,
     )
@@ -170,7 +168,7 @@ class Ref(Schema):
     schema: Schema = _NOT_IMPL
 
     def __post_init__(self):
-        assert self.ref.find('/../') == -1
+        assert self.ref.find('/../') == -1, self.ref
 
     __hash__ = Schema.__hash__
 
@@ -181,6 +179,7 @@ class Boolean(Schema):
     type: str = 'boolean'
     default: Optional[bool] = None
     nullable: bool = False
+    deprecated: bool = False
 
     __hash__ = Schema.__hash__
 
@@ -217,8 +216,9 @@ class Integer(Schema):
     exclusiveMinimum: Optional[int] = None
     exclusiveMaximum: Optional[int] = None
     # TODO: multipleOf
-    enum: Optional[List[int]] = None
+    enum: Optional[list[int]] = None
     format: Optional[IntegerFormat] = None
+    deprecated: bool = False
 
     def __post_init__(self) -> None:
         super().__post_init__()
@@ -244,6 +244,7 @@ class Number(Schema):
     exclusiveMinimum: Optional[Union[float, int]] = None
     exclusiveMaximum: Optional[Union[float, int]] = None
     format: Optional[str] = None
+    deprecated: bool = False
     # TODO: multipleOf
 
     __hash__ = Schema.__hash__
@@ -285,11 +286,12 @@ class String(Schema):
     type: str = 'string'
     default: Optional[str] = None
     nullable: bool = False
-    enum: Optional[List[str]] = None
+    enum: Optional[list[str]] = None
     pattern: Optional[str] = None
     format: Optional[StringFormat] = None
     minLength: Optional[int] = None
     maxLength: Optional[int] = None
+    deprecated: bool = False
 
     def __post_init__(self) -> None:
         super().__post_init__()
@@ -313,6 +315,7 @@ class Array(Schema):
     nullable: bool = False
     minItems: Optional[int] = None
     maxItems: Optional[int] = None
+    deprecated: bool = False
 
     def visit_children(self, cb: Callable[[Schema, Schema], None]) -> None:
         cb(self.items, self)
@@ -327,16 +330,17 @@ class SchemaObjectRaw:
     type: str
     additionalProperties: Any
     properties: Optional[dict] = None
-    required: Optional[List[str]] = None
+    required: Optional[list[str]] = None
     nullable: bool = False
+    deprecated: bool = False
 
 
 @smart_fields
 @dataclasses.dataclass
 class SchemaObject(Schema):
     additionalProperties: Union[Schema, bool]
-    properties: Dict[str, Schema]
-    required: Optional[List[str]] = None
+    properties: dict[str, Schema]
+    required: Optional[list[str]] = None
     nullable: bool = False
 
     def __post_init__(self) -> None:
@@ -364,7 +368,7 @@ def visit_children(self, cb: Callable[[Schema, Schema], None]) -> None:
 @smart_fields
 @dataclasses.dataclass
 class AllOf(Schema):
-    allOf: List[Schema]  # type: ignore
+    allOf: list[Schema]  # type: ignore
     nullable: bool = False
 
     def visit_children(self, cb: Callable[[Schema, Schema], None]) -> None:
@@ -380,6 +384,7 @@ def visit_children(self, cb: Callable[[Schema, Schema], None]) -> None:
 class AllOfRaw:
     allOf: list  # type:ignore
     nullable: bool = False
+    deprecated: bool = False
 
     def __post_init__(self) -> None:
         if not self.allOf:
@@ -389,7 +394,7 @@ def __post_init__(self) -> None:
 @smart_fields
 @dataclasses.dataclass
 class OneOfWithoutDiscriminator(Schema):
-    oneOf: List[Schema]  # type:ignore
+    oneOf: list[Schema]  # type:ignore
     nullable: bool = False
 
     def visit_children(self, cb: Callable[[Schema, Schema], None]) -> None:
@@ -408,14 +413,14 @@ class MappingType(enum.Enum):
 @dataclasses.dataclass
 class DiscMapping:
     # only one list must be not none
-    str_values: Optional[List[List[str]]] = None
-    int_values: Optional[List[List[int]]] = None
+    str_values: Optional[list[list[str]]] = None
+    int_values: Optional[list[list[int]]] = None
 
     def append(self, value: list):
         if self.str_values is not None:
-            self.str_values.append(typing.cast(List[str], value))
+            self.str_values.append(typing.cast(list[str], value))
         elif self.int_values is not None:
-            self.int_values.append(typing.cast(List[int], value))
+            self.int_values.append(typing.cast(list[int], value))
 
     def enable_str(self):
         self.str_values = []
@@ -431,11 +436,11 @@ def get_type(self) -> MappingType:
 
         return MappingType.STR
 
-    def as_strs(self) -> List[List[str]]:
-        return typing.cast(List[List[str]], self.str_values)
+    def as_strs(self) -> list[list[str]]:
+        return typing.cast(list[list[str]], self.str_values)
 
-    def as_ints(self) -> List[List[int]]:
-        return typing.cast(List[List[int]], self.int_values)
+    def as_ints(self) -> list[list[int]]:
+        return typing.cast(list[list[int]], self.int_values)
 
     def is_int(self):
         return self.int_values is not None
@@ -447,7 +452,7 @@ def is_str(self):
 @smart_fields
 @dataclasses.dataclass
 class OneOfWithDiscriminator(Schema):
-    oneOf: List[Ref]  # type:ignore
+    oneOf: list[Ref]  # type:ignore
     discriminator_property: Optional[str] = None
     mapping: DiscMapping = dataclasses.field(default_factory=DiscMapping)
     nullable: bool = False
@@ -464,7 +469,7 @@ def visit_children(self, cb: Callable[[Schema, Schema], None]) -> None:
 @dataclasses.dataclass
 class OneOfDiscriminatorRaw:
     propertyName: str  # type:ignore
-    mapping: Optional[Dict[str, str]] = None
+    mapping: Optional[dict[str, str]] = None
 
 
 @smart_fields
@@ -472,6 +477,8 @@ class OneOfDiscriminatorRaw:
 class OneOfRaw:
     oneOf: list  # type:ignore
     discriminator: Optional[dict] = None
+    nullable: bool = False
+    deprecated: bool = False
 
     def __post_init__(self) -> None:
         if not self.oneOf:
@@ -480,12 +487,12 @@ def __post_init__(self) -> None:
 
 @dataclasses.dataclass
 class ParsedSchemas:
-    schemas: Dict[str, Schema] = dataclasses.field(
+    schemas: dict[str, Schema] = dataclasses.field(
         default_factory=collections.OrderedDict,
     )
 
     @staticmethod
-    def merge(schemas: List['ParsedSchemas']) -> 'ParsedSchemas':
+    def merge(schemas: list['ParsedSchemas']) -> 'ParsedSchemas':
         result = ParsedSchemas()
         for schema in schemas:
             result.schemas.update(schema.schemas)
@@ -494,4 +501,4 @@ def merge(schemas: List['ParsedSchemas']) -> 'ParsedSchemas':
 
 @dataclasses.dataclass
 class ResolvedSchemas:
-    schemas: Dict[str, Schema]
+    schemas: dict[str, Schema]
diff --git a/chaotic/chaotic/main.py b/chaotic/chaotic/main.py
index 271779187382..c8c56bc473c8 100644
--- a/chaotic/chaotic/main.py
+++ b/chaotic/chaotic/main.py
@@ -6,8 +6,6 @@
 import sys
 from typing import Any
 from typing import Callable
-from typing import Dict
-from typing import List
 from typing import Optional
 
 import yaml
@@ -115,7 +113,7 @@ def parse_args() -> argparse.Namespace:
 
 
 def generate_cpp_name_func(
-    name_map: List[NameMapItem],
+    name_map: list[NameMapItem],
     erase_prefix: str,
 ) -> Callable:
     def cpp_name_func(schema_name: str, stem: str) -> str:
@@ -129,7 +127,7 @@ def cpp_name_func(schema_name: str, stem: str) -> str:
     return cpp_name_func
 
 
-def vfilepath_from_filepath(filepath: str, file_map: List[NameMapItem]) -> str:
+def vfilepath_from_filepath(filepath: str, file_map: list[NameMapItem]) -> str:
     for item in file_map:
         vfilepath = item.match(filepath, stem=pathlib.Path(filepath).stem)
         if vfilepath:
@@ -168,8 +166,8 @@ def traverse_dfs(path: str, data: Any):
 
 def extract_schemas_to_scan(
     inp: dict,
-    name_map: List[NameMapItem],
-) -> Dict[str, Any]:
+    name_map: list[NameMapItem],
+) -> dict[str, Any]:
     schemas = []
 
     gen = traverse_dfs('/', inp)
@@ -192,10 +190,10 @@ def extract_schemas_to_scan(
 
 def read_schemas(
     erase_path_prefix: str,
-    filepaths: List[str],
+    filepaths: list[str],
     name_map,
     file_map,
-    dependencies: List[types.ResolvedSchemas] = [],
+    dependencies: list[types.ResolvedSchemas] = [],
 ) -> types.ResolvedSchemas:
     config = front_parser.ParserConfig(erase_prefix=erase_path_prefix)
     rr = ref_resolver.RefResolver()
diff --git a/chaotic/include/userver/chaotic/io/boost/uuids/uuid.hpp b/chaotic/include/userver/chaotic/io/boost/uuids/uuid.hpp
index 8365631f7e34..167ffac411e4 100644
--- a/chaotic/include/userver/chaotic/io/boost/uuids/uuid.hpp
+++ b/chaotic/include/userver/chaotic/io/boost/uuids/uuid.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_hash.hpp>
 
 #include <userver/chaotic/convert/to.hpp>
 
diff --git a/chaotic/include/userver/chaotic/io/std/int32_t.hpp b/chaotic/include/userver/chaotic/io/std/int32_t.hpp
new file mode 100644
index 000000000000..d0879af92bfb
--- /dev/null
+++ b/chaotic/include/userver/chaotic/io/std/int32_t.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstddef>
+
+#include <fmt/format.h>
+
+#include <userver/chaotic/convert/to.hpp>
+#include <userver/utils/numeric_cast.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace chaotic::convert {
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, T> Convert(const std::int32_t& value, To<T>) {
+    return utils::numeric_cast<T>(value);
+}
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, std::int32_t> Convert(const T& value, To<std::int32_t>) {
+    return utils::numeric_cast<std::int32_t>(value);
+}
+
+}  // namespace chaotic::convert
+
+USERVER_NAMESPACE_END
diff --git a/chaotic/include/userver/chaotic/io/std/int64_t.hpp b/chaotic/include/userver/chaotic/io/std/int64_t.hpp
new file mode 100644
index 000000000000..d0fc56a02095
--- /dev/null
+++ b/chaotic/include/userver/chaotic/io/std/int64_t.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstddef>
+
+#include <fmt/format.h>
+
+#include <userver/chaotic/convert/to.hpp>
+#include <userver/utils/numeric_cast.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace chaotic::convert {
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, T> Convert(const std::int64_t& value, To<T>) {
+    return utils::numeric_cast<T>(value);
+}
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, std::int64_t> Convert(const T& value, To<std::int64_t>) {
+    return utils::numeric_cast<std::int64_t>(value);
+}
+
+}  // namespace chaotic::convert
+
+USERVER_NAMESPACE_END
diff --git a/chaotic/integration_tests/CMakeLists.txt b/chaotic/integration_tests/CMakeLists.txt
index 34c7fa4f01f8..91ea8afcf578 100644
--- a/chaotic/integration_tests/CMakeLists.txt
+++ b/chaotic/integration_tests/CMakeLists.txt
@@ -18,6 +18,7 @@ userver_target_generate_chaotic(
     INCLUDE_DIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/include
     ${CMAKE_CURRENT_SOURCE_DIR}/../include
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../universal/include
     LAYOUT
     "/definitions/([^/]*)/=ns::{0}"
     OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/src
diff --git a/chaotic/integration_tests/schemas/container_format.yaml b/chaotic/integration_tests/schemas/container_format.yaml
new file mode 100644
index 000000000000..54b60d13074d
--- /dev/null
+++ b/chaotic/integration_tests/schemas/container_format.yaml
@@ -0,0 +1,11 @@
+definitions:
+    ContainerWithFormatItem:
+        type: object
+        additionalProperties: false
+        properties:
+            my_field:
+                type: array
+                x-usrv-cpp-container: std::unordered_set
+                items:
+                    type: string
+                    format: uuid
diff --git a/chaotic/integration_tests/schemas/custom_cpp_type.yaml b/chaotic/integration_tests/schemas/custom_cpp_type.yaml
index 118bc7eeec1e..e8545b6498e4 100644
--- a/chaotic/integration_tests/schemas/custom_cpp_type.yaml
+++ b/chaotic/integration_tests/schemas/custom_cpp_type.yaml
@@ -115,3 +115,10 @@ definitions:
             type: string
             x-usrv-cpp-type: my::CustomString
         x-usrv-cpp-type: userver::utils::DefaultDict<my::CustomString>
+    StrongTypedefObject:
+        type: object
+        additionalProperties: false
+        properties:
+            strong_typedef:
+                type: string
+                x-usrv-cpp-type: userver::utils::StrongTypedef<my::CustomString, std::string>
diff --git a/chaotic/integration_tests/schemas/oneofdiscriminator.yaml b/chaotic/integration_tests/schemas/oneofdiscriminator.yaml
index 41392f447a4d..6eb30a291281 100644
--- a/chaotic/integration_tests/schemas/oneofdiscriminator.yaml
+++ b/chaotic/integration_tests/schemas/oneofdiscriminator.yaml
@@ -56,3 +56,12 @@ definitions:
         properties:
             version:
                 type: integer
+
+    OneOfToRefToRef:
+        oneOf:
+          - $ref: '#/definitions/RefToC'
+        discriminator:
+            propertyName: version
+
+    RefToC:
+        $ref: '#/definitions/C'
diff --git a/chaotic/tests/back/cpp/conftest.py b/chaotic/tests/back/cpp/conftest.py
index 3347723e616b..206b8ba47189 100644
--- a/chaotic/tests/back/cpp/conftest.py
+++ b/chaotic/tests/back/cpp/conftest.py
@@ -1,5 +1,4 @@
 from collections import OrderedDict
-from typing import Dict
 
 import pytest
 
@@ -33,7 +32,7 @@ def func(input_: dict):
 
 @pytest.fixture(name='clean')
 def _clean():
-    def func(ordered_dict: OrderedDict) -> Dict[str, CppType]:
+    def func(ordered_dict: OrderedDict) -> dict[str, CppType]:
         res = {}
         for key, val in ordered_dict.items():
             res[key] = val.without_json_schema()
diff --git a/chaotic/tests/back/cpp/test_external.py b/chaotic/tests/back/cpp/test_external.py
index a06f4a962279..c1ce55acd35a 100644
--- a/chaotic/tests/back/cpp/test_external.py
+++ b/chaotic/tests/back/cpp/test_external.py
@@ -1,3 +1,5 @@
+import pytest
+
 from chaotic.back.cpp import type_name
 from chaotic.back.cpp import types as cpp_types
 from chaotic.back.cpp.translator import Generator
@@ -32,16 +34,14 @@ def parse(path, input_, external_schemas, external_types, cpp_name_func):
     return resolved_schemas, types
 
 
-def test_import(cpp_name_func):
+def test_import(cpp_name_func, cpp_primitive_type):
     ext_schemas, ext_types = parse('/type1', {'type': 'string'}, types.ResolvedSchemas(schemas={}), {}, cpp_name_func)
     assert ext_schemas.schemas == {'vfull#/type1': types.String(type='string')}
     assert ext_types == {
-        '::type1': cpp_types.CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('std::string'),
-            nullable=False,
-            user_cpp_type=None,
-            json_schema=types.String(type='string'),
+        '::type1': cpp_primitive_type(
             validators=cpp_types.CppPrimitiveValidator(prefix='type1'),
+            raw_cpp_type_str='std::string',
+            json_schema=types.String(type='string'),
         ),
     }
 
@@ -65,3 +65,42 @@ def test_import(cpp_name_func):
             json_schema=new_schemas.schemas['vfull#/type2'],
         ),
     }
+
+
+def test_duplicate_name(cpp_name_func):
+    config = parser.ParserConfig(erase_prefix='')
+
+    schema_parser = parser.SchemaParser(
+        config=config,
+        full_filepath='full',
+        full_vfilepath='vfull',
+    )
+    schema_parser.parse_schema('/type1', {'type': 'string'})
+    schemas1 = schema_parser.parsed_schemas()
+
+    schema_parser = parser.SchemaParser(
+        config=config,
+        full_filepath='full2',
+        full_vfilepath='vfull2',
+    )
+    schema_parser.parse_schema('/type1', {'type': 'integer'})
+    schemas2 = schema_parser.parsed_schemas()
+
+    schemas = types.ParsedSchemas.merge([schemas1, schemas2])
+    rr = ref_resolver.RefResolver()
+    resolved_schemas = rr.sort_schemas(
+        schemas,
+    )
+
+    gen = Generator(
+        config=GeneratorConfig(
+            namespaces={'vfull': '', 'vfull2': ''}, include_dirs=None, infile_to_name_func=cpp_name_func
+        ),
+    )
+
+    with pytest.raises(
+        BaseException, match='Duplicate type name: ::type1, generated from vfull2#/type1 and vfull#/type1'
+    ):
+        gen.generate_types(
+            resolved_schemas,
+        )
diff --git a/chaotic/tests/back/cpp/test_tr_array.py b/chaotic/tests/back/cpp/test_tr_array.py
index 697923168028..0b0574679df7 100644
--- a/chaotic/tests/back/cpp/test_tr_array.py
+++ b/chaotic/tests/back/cpp/test_tr_array.py
@@ -1,11 +1,10 @@
 from chaotic.back.cpp import type_name
 from chaotic.back.cpp.types import CppArray
 from chaotic.back.cpp.types import CppArrayValidator
-from chaotic.back.cpp.types import CppPrimitiveType
 from chaotic.back.cpp.types import CppPrimitiveValidator
 
 
-def test_array_int(simple_gen):
+def test_array_int(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'array', 'items': {'type': 'integer'}})
     assert types == {
         '::type': CppArray(
@@ -13,12 +12,9 @@ def test_array_int(simple_gen):
             user_cpp_type=None,
             json_schema=None,
             nullable=False,
-            items=CppPrimitiveType(
-                raw_cpp_type=type_name.TypeName('int'),
-                user_cpp_type=None,
-                json_schema=None,
-                nullable=False,
+            items=cpp_primitive_type(
                 validators=CppPrimitiveValidator(prefix='typeA'),
+                raw_cpp_type_str='int',
             ),
             container='std::vector',
             validators=CppArrayValidator(),
@@ -26,7 +22,7 @@ def test_array_int(simple_gen):
     }
 
 
-def test_array_array_with_validators(simple_gen):
+def test_array_array_with_validators(simple_gen, cpp_primitive_type):
     types = simple_gen({
         'type': 'array',
         'items': {'type': 'array', 'items': {'type': 'integer', 'minimum': 1}},
@@ -42,15 +38,12 @@ def test_array_array_with_validators(simple_gen):
                 user_cpp_type=None,
                 json_schema=None,
                 nullable=False,
-                items=CppPrimitiveType(
-                    raw_cpp_type=type_name.TypeName('int'),
-                    user_cpp_type=None,
-                    json_schema=None,
-                    nullable=False,
+                items=cpp_primitive_type(
                     validators=CppPrimitiveValidator(
                         min=1,
                         prefix='typeAA',
                     ),
+                    raw_cpp_type_str='int',
                 ),
                 container='std::vector',
                 validators=CppArrayValidator(),
diff --git a/chaotic/tests/back/cpp/test_tr_int.py b/chaotic/tests/back/cpp/test_tr_int.py
index d383c33bf08a..2fa1c64cc23a 100644
--- a/chaotic/tests/back/cpp/test_tr_int.py
+++ b/chaotic/tests/back/cpp/test_tr_int.py
@@ -2,19 +2,15 @@
 from chaotic.back.cpp import type_name
 from chaotic.back.cpp.types import CppIntEnum
 from chaotic.back.cpp.types import CppIntEnumItem
-from chaotic.back.cpp.types import CppPrimitiveType
 from chaotic.back.cpp.types import CppPrimitiveValidator
 
 
-def test_int(simple_gen):
+def test_int(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer'})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
+            raw_cpp_type_str='int',
         ),
     }
 
@@ -30,118 +26,99 @@ def test_wrong_type_x(simple_gen):
         assert exc.msg == 'Non-string x- property "x-usrv-cpp-type"'
 
 
-def test_int_nullable(simple_gen):
+def test_int_nullable(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'nullable': True})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
-            nullable=True,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
+            raw_cpp_type_str='int',
+            nullable=True,
         ),
     }
 
 
-def test_int_cpp_type(simple_gen):
+def test_int_cpp_type(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'x-usrv-cpp-type': 'X'})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type='X',
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
+            raw_cpp_type_str='int',
+            user_cpp_type='X',
         ),
     }
 
 
-def test_int_default(simple_gen):
+def test_int_default(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'default': 42})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            default=42,
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
+            raw_cpp_type_str='int',
+            default=42,
         ),
     }
 
 
-def test_int_min(simple_gen):
+def test_int_min(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'minimum': 1})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(
                 min=1,
                 prefix='type',
             ),
+            raw_cpp_type_str='int',
         ),
     }
 
 
-def test_int_min_max(simple_gen):
+def test_int_min_max(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'minimum': 1, 'maximum': 10})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(
                 min=1,
                 max=10,
                 prefix='type',
             ),
-            nullable=False,
+            raw_cpp_type_str='int',
         ),
     }
 
 
-def test_int_min_max_exclusive(simple_gen):
+def test_int_min_max_exclusive(simple_gen, cpp_primitive_type):
     types = simple_gen({
         'type': 'integer',
         'exclusiveMinimum': 1,
         'exclusiveMaximum': 10,
     })
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(
                 exclusiveMin=1,
                 exclusiveMax=10,
                 prefix='type',
             ),
-            nullable=False,
+            raw_cpp_type_str='int',
         ),
     }
 
 
-def test_int_min_max_exclusive_false(simple_gen):
+def test_int_min_max_exclusive_false(simple_gen, cpp_primitive_type):
     types = simple_gen({
         'type': 'integer',
         'exclusiveMinimum': False,
         'exclusiveMaximum': False,
     })
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
-            nullable=False,
+            raw_cpp_type_str='int',
         ),
     }
 
 
-def test_int_min_max_exclusive_legacy(simple_gen):
+def test_int_min_max_exclusive_legacy(simple_gen, cpp_primitive_type):
     types = simple_gen({
         'type': 'integer',
         'exclusiveMinimum': True,
@@ -150,42 +127,33 @@ def test_int_min_max_exclusive_legacy(simple_gen):
         'maximum': 10,
     })
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('int'),
-            user_cpp_type=None,
-            json_schema=None,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(
                 exclusiveMin=2,
                 exclusiveMax=10,
                 prefix='type',
             ),
-            nullable=False,
+            raw_cpp_type_str='int',
         ),
     }
 
 
-def test_int_format_int32(simple_gen):
+def test_int_format_int32(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'format': 'int32'})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('std::int32_t'),
-            user_cpp_type=None,
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
+            raw_cpp_type_str='std::int32_t',
         ),
     }
 
 
-def test_int_format_int64(simple_gen):
+def test_int_format_int64(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'integer', 'format': 'int64'})
     assert types == {
-        '::type': CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('std::int64_t'),
-            user_cpp_type=None,
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=CppPrimitiveValidator(prefix='type'),
+            raw_cpp_type_str='std::int64_t',
         ),
     }
 
diff --git a/chaotic/tests/back/cpp/test_tr_object.py b/chaotic/tests/back/cpp/test_tr_object.py
index 28d8d330c10c..587aa6be1976 100644
--- a/chaotic/tests/back/cpp/test_tr_object.py
+++ b/chaotic/tests/back/cpp/test_tr_object.py
@@ -6,7 +6,6 @@
 from chaotic.back.cpp.types import CppPrimitiveValidator
 from chaotic.back.cpp.types import CppStruct
 from chaotic.back.cpp.types import CppStructField
-from chaotic.back.cpp.types import CppStructPrimitiveField
 
 
 def test_empty(simple_gen):
@@ -26,7 +25,7 @@ def test_empty(simple_gen):
     }
 
 
-def test_additional_properties_simple(simple_gen):
+def test_additional_properties_simple(simple_gen, cpp_primitive_type):
     schemas = simple_gen({
         'type': 'object',
         'properties': {},
@@ -39,22 +38,19 @@ def test_additional_properties_simple(simple_gen):
             nullable=False,
             user_cpp_type=None,
             fields={},
-            extra_type=CppPrimitiveType(
-                raw_cpp_type=type_name.TypeName('int'),
-                json_schema=None,
-                nullable=False,
-                user_cpp_type=None,
+            extra_type=cpp_primitive_type(
                 validators=CppPrimitiveValidator(
                     namespace='::type',
                     prefix='Extra',
                 ),
+                raw_cpp_type_str='int',
             ),
         ),
     }
 
 
 @pytest.mark.skip(reason='see comment in translator.py: _gen_field()')
-def test_field_external(simple_gen):
+def test_field_external(simple_gen, cpp_primitive_type):
     schemas = simple_gen({
         'type': 'object',
         'properties': {'field': {'type': 'integer'}},
@@ -71,8 +67,12 @@ def test_field_external(simple_gen):
                 'field': CppStructField(
                     name='field',
                     required=False,
-                    external_schema=CppStructPrimitiveField(
-                        raw_cpp_type=type_name.TypeName('int'),
+                    schema=cpp_primitive_type(
+                        validators=CppPrimitiveValidator(
+                            namespace='::type',
+                            prefix='Field',
+                        ),
+                        raw_cpp_type_str='int',
                     ),
                 ),
             },
@@ -80,7 +80,7 @@ def test_field_external(simple_gen):
     }
 
 
-def test_field_with_default(simple_gen):
+def test_field_with_default(simple_gen, cpp_primitive_type):
     schemas = simple_gen({
         'type': 'object',
         'properties': {'field': {'type': 'integer', 'default': 1}},
@@ -97,16 +97,13 @@ def test_field_with_default(simple_gen):
                 'field': CppStructField(
                     name='field',
                     required=False,
-                    schema=CppPrimitiveType(
-                        raw_cpp_type=type_name.TypeName('int'),
-                        json_schema=None,
-                        default=1,
-                        nullable=False,
-                        user_cpp_type=None,
+                    schema=cpp_primitive_type(
                         validators=CppPrimitiveValidator(
                             namespace='::type',
                             prefix='Field',
                         ),
+                        raw_cpp_type_str='int',
+                        default=1,
                     ),
                 ),
             },
@@ -114,7 +111,7 @@ def test_field_with_default(simple_gen):
     }
 
 
-def test_field_inplace(simple_gen):
+def test_field_inplace(simple_gen, cpp_primitive_type):
     schemas = simple_gen({
         'type': 'object',
         'properties': {'field': {'type': 'integer', 'minimum': 1}},
@@ -131,16 +128,13 @@ def test_field_inplace(simple_gen):
                 'field': CppStructField(
                     name='field',
                     required=False,
-                    schema=CppPrimitiveType(
-                        raw_cpp_type=type_name.TypeName('int'),
-                        json_schema=None,
-                        nullable=False,
-                        user_cpp_type=None,
+                    schema=cpp_primitive_type(
                         validators=CppPrimitiveValidator(
                             min=1,
                             namespace='::type',
                             prefix='Field',
                         ),
+                        raw_cpp_type_str='int',
                     ),
                 ),
             },
diff --git a/chaotic/tests/back/cpp/test_tr_oneof.py b/chaotic/tests/back/cpp/test_tr_oneof.py
index 7ae6111ce156..8b217246b174 100644
--- a/chaotic/tests/back/cpp/test_tr_oneof.py
+++ b/chaotic/tests/back/cpp/test_tr_oneof.py
@@ -2,8 +2,6 @@
 from chaotic.back.cpp.translator import Generator
 from chaotic.back.cpp.translator import GeneratorConfig
 from chaotic.front import ref_resolver
-from chaotic.front.parser import ParserConfig
-from chaotic.front.parser import SchemaParser
 from chaotic.front.types import MappingType
 from chaotic.main import generate_cpp_name_func
 from chaotic.main import NameMapItem
@@ -36,13 +34,8 @@ def test_simple(simple_gen):
     assert foo_schema.variants[2].raw_cpp_type == type_name.TypeName('double')
 
 
-def test_empty_mapping(clean):
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_empty_mapping(clean, schema_parser):
+    parser = schema_parser
 
     parser.parse_schema(
         '/definitions/A',
@@ -101,13 +94,8 @@ def test_empty_mapping(clean):
     assert list(foo_schema.variants.keys()) == ['A', 'B']
 
 
-def test_str_mapping(clean):
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_str_mapping(clean, schema_parser):
+    parser = schema_parser
 
     parser.parse_schema(
         '/definitions/A',
@@ -170,13 +158,8 @@ def test_str_mapping(clean):
     assert foo_schema.variants['bbb'].cpp_name == '::B'
 
 
-def test_int_mapping(clean):
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_int_mapping(clean, schema_parser):
+    parser = schema_parser
 
     parser.parse_schema(
         '/definitions/A',
diff --git a/chaotic/tests/back/cpp/test_tr_ref.py b/chaotic/tests/back/cpp/test_tr_ref.py
index ac14e1a1a02c..c0741d515350 100644
--- a/chaotic/tests/back/cpp/test_tr_ref.py
+++ b/chaotic/tests/back/cpp/test_tr_ref.py
@@ -4,18 +4,11 @@
 from chaotic.back.cpp.types import CppRef
 from chaotic.back.cpp.types import CppStruct
 from chaotic.front import ref_resolver
-from chaotic.front.parser import ParserConfig
-from chaotic.front.parser import SchemaParser
 from chaotic.front.types import SchemaObject
 
 
-def test_simple_ref(clean, cpp_name_func):
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_simple_ref(clean, cpp_name_func, schema_parser):
+    parser = schema_parser
 
     parser.parse_schema(
         '/definitions/Type',
diff --git a/chaotic/tests/back/cpp/test_tr_string.py b/chaotic/tests/back/cpp/test_tr_string.py
index 28617124637d..de27623edfde 100644
--- a/chaotic/tests/back/cpp/test_tr_string.py
+++ b/chaotic/tests/back/cpp/test_tr_string.py
@@ -2,17 +2,14 @@
 from chaotic.back.cpp import types as cpp_types
 
 
-def test_simple(simple_gen):
+def test_simple(simple_gen, cpp_primitive_type):
     types = simple_gen({'type': 'string'})
     assert types == {
-        '::type': cpp_types.CppPrimitiveType(
-            raw_cpp_type=type_name.TypeName('std::string'),
-            user_cpp_type=None,
-            json_schema=None,
-            nullable=False,
+        '::type': cpp_primitive_type(
             validators=cpp_types.CppPrimitiveValidator(
                 prefix='type',
             ),
+            raw_cpp_type_str='std::string',
         ),
     }
 
diff --git a/chaotic/tests/back/cpp/test_types.py b/chaotic/tests/back/cpp/test_types.py
index 8ec0c6757c3a..4cc8025ee8a4 100644
--- a/chaotic/tests/back/cpp/test_types.py
+++ b/chaotic/tests/back/cpp/test_types.py
@@ -7,13 +7,13 @@ def test_camel_to_snake_case_smoke():
     assert types.camel_to_snake_case('unsigned') == 'unsigned'
 
 
-def test_get_include_by_cpp_type_smoke():
-    assert types.CppType.get_include_by_cpp_type('geometry::Distance') == [
+def test_get_includes_by_cpp_type_smoke():
+    assert types.CppType.get_includes_by_cpp_type('geometry::Distance') == [
         'userver/chaotic/io/geometry/distance.hpp',
     ]
-    assert types.CppType.get_include_by_cpp_type('std::vector<xxx>') == [
+    assert types.CppType.get_includes_by_cpp_type('std::vector<xxx>') == [
         'userver/chaotic/io/std/vector.hpp',
     ]
-    assert types.CppType.get_include_by_cpp_type(
+    assert types.CppType.get_includes_by_cpp_type(
         'userver::utils::StrongTypedef<xxx, std::string>',
-    ) == ['userver/chaotic/io/xxx.hpp']
+    ) == ['userver/utils/strong_typedef.hpp', 'userver/chaotic/io/xxx.hpp']
diff --git a/chaotic/tests/compilers/test_dynamic_configs.py b/chaotic/tests/compilers/test_dynamic_configs.py
index b22cb91d6dc2..249a7d3bf996 100644
--- a/chaotic/tests/compilers/test_dynamic_configs.py
+++ b/chaotic/tests/compilers/test_dynamic_configs.py
@@ -3,7 +3,6 @@
 from typing import Any
 
 from chaotic import error
-from chaotic.back.cpp import type_name
 from chaotic.back.cpp import types
 from chaotic.compilers import dynamic_config
 
@@ -21,17 +20,14 @@ def parse_variable_content(
     return compiler.extract_variable_type()
 
 
-def test_smoke():
+def test_smoke(cpp_primitive_type):
     var = parse_variable_content({'schema': {'type': 'integer'}, 'default': 1})
-    expected = types.CppPrimitiveType(
-        raw_cpp_type=type_name.TypeName('int'),
-        nullable=False,
-        user_cpp_type=None,
-        json_schema=None,
+    expected = cpp_primitive_type(
         validators=types.CppPrimitiveValidator(
             namespace='::taxi_config::var',
             prefix='VariableTypeRaw',
         ),
+        raw_cpp_type_str='int',
     )
     assert var.without_json_schema() == expected
 
@@ -89,7 +85,10 @@ def test_strong_typedef_dependencies():
         })
         assert False
     except error.BaseError as exc:
-        assert 'Include file "userver/chaotic/io/xxx.hpp" not found' in exc.msg
+        assert (
+            'Include file "userver/utils/strong_typedef.hpp" not found' in exc.msg
+            or 'Include file "userver/chaotic/io/xxx.hpp" not found' in exc.msg
+        )
 
 
 def test_default_isomorphic():
diff --git a/chaotic/tests/conftest.py b/chaotic/tests/conftest.py
index 7544f7e704b8..5e69870315b6 100644
--- a/chaotic/tests/conftest.py
+++ b/chaotic/tests/conftest.py
@@ -1,6 +1,23 @@
+from typing import Any
+from typing import Optional
+
 import pytest
 
+from chaotic.back.cpp import type_name
+from chaotic.back.cpp.types import CppPrimitiveType
+from chaotic.back.cpp.types import CppPrimitiveValidator
 from chaotic.front import parser
+from chaotic.front.types import Schema
+
+
+@pytest.fixture
+def schema_parser():
+    config = parser.ParserConfig(erase_prefix='')
+    return parser.SchemaParser(
+        config=config,
+        full_filepath='full',
+        full_vfilepath='vfull',
+    )
 
 
 @pytest.fixture
@@ -16,3 +33,31 @@ def func(input_: dict):
         return schema_parser.parsed_schemas()
 
     return func
+
+
+@pytest.fixture
+def cpp_primitive_type():
+    """Factory fixture for creating CppPrimitiveType instances with common defaults."""
+
+    def create(
+        validators: CppPrimitiveValidator,
+        raw_cpp_type_str: str,
+        user_cpp_type: Optional[str] = None,
+        json_schema: Optional[Schema] = None,
+        nullable: bool = False,
+        default: Any = None,
+    ):
+        kwargs = {
+            'raw_cpp_type': type_name.TypeName(raw_cpp_type_str),
+            'user_cpp_type': user_cpp_type,
+            'json_schema': json_schema,
+            'nullable': nullable,
+            'validators': validators,
+        }
+
+        if default is not None:
+            kwargs['default'] = default
+
+        return CppPrimitiveType(**kwargs)
+
+    return create
diff --git a/chaotic/tests/front/test_all_of.py b/chaotic/tests/front/test_all_of.py
index e8feefddaee3..666a12da842c 100644
--- a/chaotic/tests/front/test_all_of.py
+++ b/chaotic/tests/front/test_all_of.py
@@ -1,15 +1,15 @@
+import pytest
+
 from chaotic.front.parser import ParserError
 from chaotic.front.types import AllOf
 from chaotic.front.types import SchemaObject
 
 
 def test_of_none(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'allOf': []})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/allOf'
-        assert exc.msg == 'Empty allOf'
+    assert exc.value.infile_path == '/definitions/type/allOf'
+    assert exc.value.msg == 'Empty allOf'
 
 
 # stupid, but valid
@@ -52,9 +52,7 @@ def test_2_empty(simple_parse):
 
 
 def test_non_object(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'allOf': [{'type': 'integer'}]})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/allOf/0'
-        assert exc.msg == 'Non-object type in allOf: integer'
+    assert exc.value.infile_path == '/definitions/type/allOf/0'
+    assert exc.value.msg == 'Non-object type in allOf: integer'
diff --git a/chaotic/tests/front/test_array.py b/chaotic/tests/front/test_array.py
index 3904f405e36c..693426f8e8ac 100644
--- a/chaotic/tests/front/test_array.py
+++ b/chaotic/tests/front/test_array.py
@@ -1,13 +1,13 @@
+import pytest
+
 from chaotic.front.parser import ParserError
 
 
 def test_array_missing_items(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'array'})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/items'
-        assert exc.msg == '"items" is missing'
+    assert exc.value.infile_path == '/definitions/type/items'
+    assert exc.value.msg == '"items" is missing'
 
 
 def test_int_array(simple_parse):
diff --git a/chaotic/tests/front/test_basic.py b/chaotic/tests/front/test_basic.py
index 5b835b085d06..bb6c859e617d 100644
--- a/chaotic/tests/front/test_basic.py
+++ b/chaotic/tests/front/test_basic.py
@@ -1,45 +1,34 @@
+import pytest
+
 from chaotic.front import ref_resolver
-from chaotic.front.parser import ParserConfig
 from chaotic.front.parser import ParserError
-from chaotic.front.parser import SchemaParser
 
 
 def test_generic_error(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'integer', 'unknown_field': '1'})
-        assert False
-    except ParserError as exc:
-        assert exc.full_filepath == 'full'
-        assert exc.schema_type == 'jsonschema'
+    assert exc.value.full_filepath == 'full'
+    assert exc.value.schema_type == 'jsonschema'
 
 
 def test_unknown_field(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'integer', 'unknown_field': '1'})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/unknown_field'
-        assert exc.msg == (
-            'Unknown field: "unknown_field", known fields: '
-            '["default", "enum", "exclusiveMaximum", "exclusiveMinimum", '
-            '"format", "maximum", "minimum", "nullable", "type"]'
-        )
+    assert exc.value.infile_path == '/definitions/type/unknown_field'
+    assert exc.value.msg == (
+        'Unknown field: "unknown_field", known fields: '
+        '["default", "deprecated", "enum", "exclusiveMaximum", "exclusiveMinimum", '
+        '"format", "maximum", "minimum", "nullable", "type"]'
+    )
 
 
-def test_duplicate_path(simple_parse):
-    try:
-        config = ParserConfig(erase_prefix='')
-        parser = SchemaParser(
-            config=config,
-            full_filepath='full',
-            full_vfilepath='vfull',
-        )
+def test_duplicate_path(schema_parser):
+    with pytest.raises(ParserError) as exc:
+        parser = schema_parser
         parser.parse_schema('/definitions/type', {'type': 'integer'})
         parser.parse_schema('/definitions/type', {'type': 'number'})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type'
-        assert exc.msg == 'Duplicate path: vfull#/definitions/type'
+    assert exc.value.infile_path == '/definitions/type'
+    assert exc.value.msg == 'Duplicate path: vfull#/definitions/type'
 
 
 def test_x_unknown_field(simple_parse):
@@ -51,41 +40,37 @@ def test_x_known_field(simple_parse):
 
 
 def test_wrong_field_type(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'intxxxx'})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/type'
-        assert exc.msg == 'Unknown type "intxxxx"'
+    assert exc.value.infile_path == '/definitions/type/type'
+    assert exc.value.msg == 'Unknown type "intxxxx"'
 
 
 def test_no_schema_type(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'enum': [1, 2, 3]})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type'
-        assert exc.msg == '"type" is missing'
+    assert exc.value.infile_path == '/definitions/type'
+    assert exc.value.msg == '"type" is missing'
 
 
 def test_schema_type_string(simple_parse):
     simple_parse({'type': 'string'})
 
 
-def test_ref(simple_parse):
-    try:
-        config = ParserConfig(erase_prefix='')
-        parser = SchemaParser(
-            config=config,
-            full_filepath='full',
-            full_vfilepath='vfull',
-        )
+def test_title(simple_parse):
+    simple_parse({'type': 'string', 'title': 'something'})
+
+
+def test_ref(schema_parser):
+    with pytest.raises(Exception) as exc_info:
+        parser = schema_parser
         parser.parse_schema(
             '/definitions/type1',
             {'$ref': '#/definitions/type'},
         )
         rr = ref_resolver.RefResolver()
         rr.sort_schemas(parser.parsed_schemas())
-        assert False
-    except Exception as exc:  # pylint: disable=broad-exception-caught
-        assert str(exc) == ('$ref to unknown type "vfull#/definitions/type", known refs:\n- vfull#/definitions/type1')
+
+    assert str(exc_info.value) == (
+        '$ref to unknown type "vfull#/definitions/type", known refs:\n- vfull#/definitions/type1'
+    )
diff --git a/chaotic/tests/front/test_number.py b/chaotic/tests/front/test_number.py
index f1ed67d45738..a47e2d73b0a3 100644
--- a/chaotic/tests/front/test_number.py
+++ b/chaotic/tests/front/test_number.py
@@ -45,12 +45,10 @@ def test_number_minmax_exclusive(simple_parse):
 
 
 def test_number_extra_enum(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'number', 'enum': [1.0]})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/enum'
-        assert 'Unknown field: "enum"' in exc.msg
+    assert exc.value.infile_path == '/definitions/type/enum'
+    assert 'Unknown field: "enum"' in exc.value.msg
 
 
 def test_integer_min_max(simple_parse):
@@ -75,12 +73,10 @@ def test_integer_minmax_exclusive(simple_parse):
 
 
 def test_integer_min_max_number(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'integer', 'minimum': 1.1})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/minimum'
-        assert exc.msg == 'field "minimum" has wrong type'
+    assert exc.value.infile_path == '/definitions/type/minimum'
+    assert exc.value.msg == 'field "minimum" has wrong type'
 
 
 def test_integer_enum(simple_parse):
@@ -91,18 +87,14 @@ def test_integer_enum(simple_parse):
 
 
 def test_integer_enum_wrong_type(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'integer', 'enum': ['1']})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/enum'
-        assert exc.msg == 'field "enum" contains non-integers (1)'
+    assert exc.value.infile_path == '/definitions/type/enum'
+    assert exc.value.msg == 'field "enum" contains non-integers (1)'
 
 
 def test_integer_min_wrong_str(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'type': 'integer', 'minimum': '1'})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/minimum'
-        assert exc.msg == 'field "minimum" has wrong type'
+    assert exc.value.infile_path == '/definitions/type/minimum'
+    assert exc.value.msg == 'field "minimum" has wrong type'
diff --git a/chaotic/tests/front/test_object.py b/chaotic/tests/front/test_object.py
index 615980e1b83b..9777818d76d8 100644
--- a/chaotic/tests/front/test_object.py
+++ b/chaotic/tests/front/test_object.py
@@ -1,3 +1,5 @@
+import pytest
+
 from chaotic.front.parser import ParserError
 from chaotic.front.types import Boolean
 from chaotic.front.types import Integer
@@ -17,57 +19,49 @@ def test_very_empty(simple_parse):
 
 
 def test_unknown_required(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'type': 'object',
             'properties': {},
             'additionalProperties': False,
             'required': ['unknown'],
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/required'
-        assert exc.msg == ('Field "unknown" is set in "required", but missing in "properties"')
+    assert exc.value.infile_path == '/definitions/type/required'
+    assert exc.value.msg == ('Field "unknown" is set in "required", but missing in "properties"')
 
 
 def test_unknown_fields(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'type': 'object',
             'unknown_field': 'x',
             'properties': {},
             'additionalProperties': False,
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/unknown_field'
-        assert 'Unknown field: "unknown_field"' in exc.msg
+    assert exc.value.infile_path == '/definitions/type/unknown_field'
+    assert 'Unknown field: "unknown_field"' in exc.value.msg
 
 
 def test_error_in_property(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'type': 'object',
             'properties': {'field': {'type': 'xxxx'}},
             'additionalProperties': False,
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/properties/field/type'
-        assert exc.msg == 'Unknown type "xxxx"'
+    assert exc.value.infile_path == '/definitions/type/properties/field/type'
+    assert exc.value.msg == 'Unknown type "xxxx"'
 
 
 def test_error_in_extra(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'type': 'object',
             'properties': {},
             'additionalProperties': {'type': 'xxx'},
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/additionalProperties/type'
-        assert exc.msg == 'Unknown type "xxx"'
+    assert exc.value.infile_path == '/definitions/type/additionalProperties/type'
+    assert exc.value.msg == 'Unknown type "xxx"'
 
 
 def test_property_and_additional(simple_parse):
diff --git a/chaotic/tests/front/test_one_of.py b/chaotic/tests/front/test_one_of.py
index f803a44b594c..fbcf6fc67fc2 100644
--- a/chaotic/tests/front/test_one_of.py
+++ b/chaotic/tests/front/test_one_of.py
@@ -1,8 +1,6 @@
 import pytest
 
-from chaotic.front.parser import ParserConfig
 from chaotic.front.parser import ParserError
-from chaotic.front.parser import SchemaParser
 from chaotic.front.types import Boolean
 from chaotic.front.types import DiscMapping
 from chaotic.front.types import Integer
@@ -15,14 +13,9 @@
 
 
 @pytest.fixture(name='parse_after_refs')
-def _parse_after_refs():
+def _parse_after_refs(schema_parser):
     def func(input_: dict):
-        config = ParserConfig(erase_prefix='')
-        parser = SchemaParser(
-            config=config,
-            full_filepath='full',
-            full_vfilepath='vfull',
-        )
+        parser = schema_parser
         parser.parse_schema(
             '/definitions/type1',
             {
@@ -108,12 +101,10 @@ def func(input_: dict):
 
 
 def test_of_none(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'oneOf': []})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/oneOf'
-        assert exc.msg == 'Empty oneOf'
+    assert exc.value.infile_path == '/definitions/type/oneOf'
+    assert exc.value.msg == 'Empty oneOf'
 
 
 # stupid, but valid
@@ -145,8 +136,20 @@ def test_wo_discriminator_2(simple_parse):
     }
 
 
+def test_wo_discriminator_nullable(simple_parse):
+    parsed = simple_parse({'oneOf': [{'type': 'integer'}], 'nullable': True})
+    assert parsed.schemas['vfull#/definitions/type'].nullable
+
+
+def test_wo_discriminator_nullable_wrong_type(simple_parse):
+    with pytest.raises(ParserError) as exc:
+        simple_parse({'oneOf': [{'type': 'integer'}], 'nullable': 1})
+    assert exc.value.infile_path == '/definitions/type/oneOf/nullable'
+    assert exc.value.msg == 'field "nullable" has wrong type'
+
+
 def test_wd_no_ref_or_object(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'oneOf': [
                 {'type': 'integer'},
@@ -158,14 +161,12 @@ def test_wd_no_ref_or_object(simple_parse):
             ],
             'discriminator': {'propertyName': 'foo'},
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/oneOf/0'
-        assert exc.msg == 'Not a $ref in oneOf with discriminator'
+    assert exc.value.infile_path == '/definitions/type/oneOf/0'
+    assert exc.value.msg == 'Not a $ref in oneOf with discriminator'
 
 
 def test_wd_wrong_property(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'oneOf': [
                 {
@@ -176,14 +177,12 @@ def test_wd_wrong_property(simple_parse):
             ],
             'discriminator': {'propertyName': 'foo'},
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/oneOf/0'
-        assert exc.msg == 'Not a $ref in oneOf with discriminator'
+    assert exc.value.infile_path == '/definitions/type/oneOf/0'
+    assert exc.value.msg == 'Not a $ref in oneOf with discriminator'
 
 
 def test_wd_wrong_property2(parse_after_refs):
-    try:
+    with pytest.raises(ParserError) as exc:
         parse_after_refs({
             'oneOf': [
                 {'$ref': '#/definitions/type1'},
@@ -192,22 +191,18 @@ def test_wd_wrong_property2(parse_after_refs):
             ],
             'discriminator': {'propertyName': 'foo'},
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/oneOf/2'
-        assert exc.msg == 'No discriminator property "foo"'
+    assert exc.value.infile_path == '/definitions/type/oneOf/2'
+    assert exc.value.msg == 'No discriminator property "foo"'
 
 
 def test_wd_wrong_type(parse_after_refs):
-    try:
+    with pytest.raises(ParserError) as exc:
         parse_after_refs({
             'oneOf': [{'$ref': '#/definitions/type_int'}],
             'discriminator': {'propertyName': 'foo'},
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/oneOf/0'
-        assert exc.msg == 'oneOf $ref to non-object'
+    assert exc.value.infile_path == '/definitions/type/oneOf/0'
+    assert exc.value.msg == 'oneOf $ref to non-object (Integer)'
 
 
 def test_wd_ok(parse_after_refs):
@@ -311,7 +306,7 @@ def test_wd_ok_with_int_mapping(parse_after_refs):
 
 
 def test_wd_non_uniform_mapping(parse_after_refs):
-    try:
+    with pytest.raises(ParserError) as exc:
         parse_after_refs({
             'oneOf': [
                 {'$ref': '#/definitions/type3'},
@@ -325,13 +320,12 @@ def test_wd_non_uniform_mapping(parse_after_refs):
                 },
             },
         })
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/discriminator/mapping'
-        assert exc.msg.startswith('Not uniform mapping')
+    assert exc.value.infile_path == '/definitions/type/discriminator/mapping'
+    assert exc.value.msg.startswith('Not uniform mapping')
 
 
 def test_wd_ok_with_mapping_missing_ref(parse_after_refs):
-    try:
+    with pytest.raises(ParserError) as exc:
         parse_after_refs({
             'oneOf': [
                 {'$ref': '#/definitions/type1'},
@@ -342,14 +336,12 @@ def test_wd_ok_with_mapping_missing_ref(parse_after_refs):
                 'mapping': {'t2': '#/definitions/type2'},
             },
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/discriminator/mapping'
-        assert exc.msg == 'Missing $ref in mapping: vfull#/definitions/type1'
+    assert exc.value.infile_path == '/definitions/type/discriminator/mapping'
+    assert exc.value.msg == 'Missing $ref in mapping: vfull#/definitions/type1'
 
 
 def test_wd_ok_with_mapping_invalid_ref(parse_after_refs):
-    try:
+    with pytest.raises(ParserError) as exc:
         parse_after_refs({
             'oneOf': [
                 {'$ref': '#/definitions/type1'},
@@ -364,14 +356,12 @@ def test_wd_ok_with_mapping_invalid_ref(parse_after_refs):
                 },
             },
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/discriminator/mapping'
-        assert exc.msg == ("$ref(s) outside of oneOf: ['vfull#/definitions/wrong']")
+    assert exc.value.infile_path == '/definitions/type/discriminator/mapping'
+    assert exc.value.msg == ("$ref(s) outside of oneOf: ['vfull#/definitions/wrong']")
 
 
 def test_wd_invalidtype_mapping_value(parse_after_refs):
-    try:
+    with pytest.raises(ParserError) as exc:
         parse_after_refs({
             'oneOf': [
                 {'$ref': '#/definitions/type1'},
@@ -382,14 +372,12 @@ def test_wd_invalidtype_mapping_value(parse_after_refs):
                 'mapping': {'t1': 1, 't2': '#/definitions/type2'},
             },
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/discriminator/mapping/t1'
-        assert exc.msg == 'Not a string in mapping'
+    assert exc.value.infile_path == '/definitions/type/discriminator/mapping/t1'
+    assert exc.value.msg == 'Not a string in mapping'
 
 
 def test_wd_extra_field(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({
             'oneOf': [
                 {
@@ -400,7 +388,17 @@ def test_wd_extra_field(simple_parse):
             ],
             'discriminator': {'foo': 1, 'propertyName': 'foo'},
         })
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type/discriminator/foo'
-        assert exc.msg == ('Unknown field: "foo", known fields: ["mapping", "propertyName"]')
+    assert exc.value.infile_path == '/definitions/type/discriminator/foo'
+    assert exc.value.msg == ('Unknown field: "foo", known fields: ["mapping", "propertyName"]')
+
+
+def test_wd_nullable(parse_after_refs):
+    schema = parse_after_refs({
+        'oneOf': [
+            {'$ref': '#/definitions/type1'},
+            {'$ref': '#/definitions/type2'},
+        ],
+        'discriminator': {'propertyName': 'foo'},
+        'nullable': True,
+    })
+    assert schema['vfull#/definitions/type'].nullable
diff --git a/chaotic/tests/front/test_ref.py b/chaotic/tests/front/test_ref.py
index 1ab19cadc95e..5a763b77a2af 100644
--- a/chaotic/tests/front/test_ref.py
+++ b/chaotic/tests/front/test_ref.py
@@ -1,5 +1,7 @@
 import collections
 
+import pytest
+
 from chaotic.front import ref_resolver
 from chaotic.front import types
 from chaotic.front.parser import ParserConfig
@@ -10,13 +12,8 @@
 from chaotic.front.types import Ref
 
 
-def test_ref_ok():
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_ref_ok(schema_parser):
+    parser = schema_parser
 
     parser.parse_schema('/definitions/type1', {'type': 'integer'})
     parser.parse_schema('/definitions/type2', {'$ref': '#/definitions/type1'})
@@ -32,13 +29,8 @@ def test_ref_ok():
     }
 
 
-def test_ref_from_items_ok():
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_ref_from_items_ok(schema_parser):
+    parser = schema_parser
 
     parser.parse_schema('/definitions/type1', {'type': 'integer'})
     parser.parse_schema(
@@ -59,48 +51,37 @@ def test_ref_from_items_ok():
     }
 
 
-def test_ref_invalid():
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
+def test_ref_invalid(schema_parser):
+    parser = schema_parser
+
+    parser.parse_schema('/definitions/type1', {'type': 'integer'})
+    parser.parse_schema(
+        '/definitions/type2',
+        {'$ref': '#/definitions/other_type'},
     )
+    rr = ref_resolver.RefResolver()
 
-    try:
-        parser.parse_schema('/definitions/type1', {'type': 'integer'})
-        parser.parse_schema(
-            '/definitions/type2',
-            {'$ref': '#/definitions/other_type'},
-        )
-        rr = ref_resolver.RefResolver()
+    with pytest.raises(Exception) as exc:
         rr.sort_schemas(parser.parsed_schemas())
-        assert False
-    except Exception as exc:  # pylint: disable=broad-exception-caught
-        assert str(exc) == (
-            '$ref to unknown type "vfull#/definitions/other_type", '
-            'known refs:\n- vfull#/definitions/type1\n'
-            '- vfull#/definitions/type2'
-        )
+
+    assert str(exc.value) == (
+        '$ref to unknown type "vfull#/definitions/other_type", '
+        'known refs:\n- vfull#/definitions/type1\n'
+        '- vfull#/definitions/type2'
+    )
 
 
 def test_extra_fields(simple_parse):
-    try:
+    with pytest.raises(ParserError) as exc:
         simple_parse({'$ref': '123', 'field': 1})
-        assert False
-    except ParserError as exc:
-        assert exc.infile_path == '/definitions/type'
-        assert exc.msg == "Unknown field(s) ['field']"
+    assert exc.value.infile_path == '/definitions/type'
+    assert exc.value.msg == "Unknown field(s) ['field']"
 
 
-def test_sibling_file():
+def test_sibling_file(schema_parser):
     config = ParserConfig(erase_prefix='')
     schemas = []
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+    parser = schema_parser
     parser.parse_schema('/definitions/type1', {'type': 'integer'})
     schemas.append(parser.parsed_schemas())
 
@@ -137,13 +118,8 @@ def test_sibling_file():
     }
 
 
-def test_forward_reference():
-    config = ParserConfig(erase_prefix='')
-    parser = SchemaParser(
-        config=config,
-        full_filepath='full',
-        full_vfilepath='vfull',
-    )
+def test_forward_reference(schema_parser):
+    parser = schema_parser
     parser.parse_schema('/definitions/type1', {'$ref': '#/definitions/type2'})
     parser.parse_schema('/definitions/type2', {'type': 'integer'})
     parser.parse_schema('/definitions/type3', {'$ref': '#/definitions/type4'})
@@ -184,20 +160,38 @@ def test_forward_reference():
     })
 
 
-def test_cycle():
+def test_cycle(schema_parser):
+    parser = schema_parser
+    parser.parse_schema('/definitions/type1', {'$ref': '#/definitions/type2'})
+    parser.parse_schema('/definitions/type2', {'$ref': '#/definitions/type1'})
+
+    rr = ref_resolver.RefResolver()
+
+    with pytest.raises(ref_resolver.ResolverError) as exc:
+        rr.sort_schemas(parser.parsed_schemas())
+
+    assert str(exc.value) == '$ref cycle: vfull#/definitions/type1, vfull#/definitions/type2'
+
+
+def test_self_ref(schema_parser):
+    parser = schema_parser
+    parser.parse_schema('/definitions/type1', {'$ref': '#/definitions/type1'})
+
+    rr = ref_resolver.RefResolver()
+
+    with pytest.raises(ref_resolver.ResolverError) as exc:
+        rr.sort_schemas(parser.parsed_schemas())
+
+    assert str(exc.value) == '$ref cycle: vfull#/definitions/type1'
+
+
+def test_no_fragment():
     config = ParserConfig(erase_prefix='')
     parser = SchemaParser(
         config=config,
         full_filepath='full',
         full_vfilepath='vfull',
     )
-    parser.parse_schema('/definitions/type1', {'$ref': '#/definitions/type2'})
-    parser.parse_schema('/definitions/type2', {'$ref': '#/definitions/type1'})
-
-    rr = ref_resolver.RefResolver()
-    try:
-        rr.sort_schemas(parser.parsed_schemas())
-    except ref_resolver.ResolverError as exc:
-        assert str(exc) == '$ref cycle: vfull#/definitions/type1, vfull#/definitions/type2'
-    else:
-        assert False
+    with pytest.raises(ParserError) as exc_info:
+        parser.parse_schema('/definitions/type1', {'$ref': '/definitions/type2'})
+    assert exc_info.value.msg == 'Error in $ref (/definitions/type2): there should be exactly one "#" inside'
diff --git a/clickhouse/CMakeLists.txt b/clickhouse/CMakeLists.txt
index ac2096b7fb45..0b609b571561 100644
--- a/clickhouse/CMakeLists.txt
+++ b/clickhouse/CMakeLists.txt
@@ -16,6 +16,7 @@ userver_module(
         # HACK: common source between unittest and dbtest targets.
         "${CMAKE_CURRENT_SOURCE_DIR}/src/storages/tests/utils_test.cpp"
     DBTEST_DATABASES clickhouse
+    DEPENDS core
 )
 
 target_compile_options(${PROJECT_NAME} PUBLIC "-Wno-error=pedantic")
diff --git a/cmake/ChaoticGen.cmake b/cmake/ChaoticGen.cmake
index 1f7b2088efe9..3119cc15fce4 100644
--- a/cmake/ChaoticGen.cmake
+++ b/cmake/ChaoticGen.cmake
@@ -131,7 +131,6 @@ function(userver_target_generate_chaotic TARGET)
 
     list(APPEND CHAOTIC_ARGS "-o" "${PARSE_OUTPUT_DIR}/${PARSE_OUTPUT_PREFIX}")
     list(APPEND CHAOTIC_ARGS "--relative-to" "${PARSE_RELATIVE_TO}")
-    list(APPEND CHAOTIC_ARGS "--clang-format" "${CLANG_FORMAT}")
 
     _userver_initialize_codegen_flag()
 
@@ -150,6 +149,7 @@ function(userver_target_generate_chaotic TARGET)
         OUTPUT ${SCHEMAS}
         COMMAND ${CMAKE_COMMAND} -E env "USERVER_PYTHON=${USERVER_CHAOTIC_PYTHON_BINARY}" "${CHAOTIC_BIN}"
                 ${CHAOTIC_EXTRA_ARGS} ${CHAOTIC_ARGS} ${PARSE_SCHEMAS}
+                --clang-format "${CLANG_FORMAT}"
         DEPENDS ${PARSE_SCHEMAS}
         WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
         VERBATIM ${CODEGEN}
@@ -198,23 +198,23 @@ function(userver_target_generate_openapi_client TARGET)
     endif()
 
     set(SCHEMAS
-        "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/client.hpp"
-        "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/client_impl.hpp"
-        "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/component.hpp"
-        "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/requests.hpp"
-        "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/responses.hpp"
-        "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/exceptions.hpp"
-        "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/client.cpp"
-        "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/client_impl.cpp"
-        "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/component.cpp"
-        "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/requests.cpp"
-        "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/responses.cpp"
-        "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/exceptions.cpp"
+        "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/client.hpp"
+        "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/client_impl.hpp"
+        "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/component.hpp"
+        "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/requests.hpp"
+        "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/responses.hpp"
+        "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/exceptions.hpp"
+        "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/client.cpp"
+        "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/client_impl.cpp"
+        "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/component.cpp"
+        "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/requests.cpp"
+        "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/responses.cpp"
+        "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/exceptions.cpp"
     )
     foreach(SCHEMA ${PARSE_SCHEMAS})
         string(REGEX REPLACE "^.*/([^/]*)\\.([^.]*)\$" "\\1" SCHEMA "${SCHEMA}")
-        set(SCHEMAS ${SCHEMAS} "${PARSE_OUTPUT_DIR}/include/client/${PARSE_NAME}/${SCHEMA}.hpp"
-                    "${PARSE_OUTPUT_DIR}/src/client/${PARSE_NAME}/${SCHEMA}.cpp"
+        set(SCHEMAS ${SCHEMAS} "${PARSE_OUTPUT_DIR}/include/clients/${PARSE_NAME}/${SCHEMA}.hpp"
+                    "${PARSE_OUTPUT_DIR}/src/clients/${PARSE_NAME}/${SCHEMA}.cpp"
         )
     endforeach()
 
diff --git a/cmake/DownloadUsingCPM.cmake b/cmake/DownloadUsingCPM.cmake
index a754d0ac0be1..4f16f389076d 100644
--- a/cmake/DownloadUsingCPM.cmake
+++ b/cmake/DownloadUsingCPM.cmake
@@ -73,3 +73,10 @@ function(mark_targets_as_system directory)
         endforeach()
     endforeach()
 endfunction()
+
+function(_userver_print_cpm_packages)
+    message(STATUS "Dependencies from CPM:")
+    foreach(PACKAGE ${CPM_PACKAGES})
+        message(STATUS "- ${PACKAGE}")
+    endforeach()
+endfunction()
diff --git a/cmake/GetUserverVersion.cmake b/cmake/GetUserverVersion.cmake
index 2826b3355477..f4e3d5edf733 100644
--- a/cmake/GetUserverVersion.cmake
+++ b/cmake/GetUserverVersion.cmake
@@ -21,8 +21,9 @@ else()
     message(STATUS "Git not found")
 endif()
 
-set(USERVER_MAJOR_VERSION 2)
-set(USERVER_MINOR_VERSION 12-rc)
+file(READ ${USERVER_ROOT_DIR}/version.txt VERSION)
+string(REGEX MATCH ^[0-9]+ USERVER_MAJOR_VERSION "${VERSION}")
+string(REGEX MATCH [-0-9a-z]+$ USERVER_MINOR_VERSION "${VERSION}")
 
 set(USERVER_VERSION "${USERVER_MAJOR_VERSION}.${USERVER_MINOR_VERSION}")
 string(REPLACE "-" "_" USERVER_VERSION_STR "${USERVER_VERSION}")
diff --git a/cmake/ModuleHelpers.cmake b/cmake/ModuleHelpers.cmake
index 740097b8e8c8..e702d1e42aca 100644
--- a/cmake/ModuleHelpers.cmake
+++ b/cmake/ModuleHelpers.cmake
@@ -3,20 +3,46 @@ include_guard(GLOBAL)
 cmake_policy(SET CMP0054 NEW)
 
 macro(_userver_module_begin)
-    set(options)
+    set(options
+        CPM_DOWNLOAD_ONLY
+    )
     set(oneValueArgs # Target name, also used for package name by default
         NAME VERSION
     )
     set(multiValueArgs
         DEBIAN_NAMES FORMULA_NAMES RPM_NAMES PACMAN_NAMES PKG_NAMES
         # For version detection of manually installed packages and unknown package managers.
-        PKG_CONFIG_NAMES
+	PKG_CONFIG_NAMES
+	# For CPM options
+	CPM_NAME
+        CPM_VERSION
+        CPM_GITHUB_REPOSITORY
+        CPM_URL
+        CPM_OPTIONS
+        CPM_SOURCE_SUBDIR
+        CPM_GIT_TAG
     )
 
     cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}")
 
     set(name "${ARG_NAME}")
 
+    string(TOUPPER "${ARG_CPM_NAME}" ARG_CPM_NAME)
+    string(REPLACE "-" "_" ARG_CPM_NAME "${ARG_CPM_NAME}")
+
+    if(ARG_CPM_NAME)
+        option(
+            USERVER_DOWNLOAD_PACKAGE_${ARG_CPM_NAME}
+            "Download and setup ${ARG_CPM_NAME} if no library of matching version was found"
+            ${USERVER_DOWNLOAD_PACKAGES}
+        )
+        option(
+            USERVER_FORCE_DOWNLOAD_${ARG_CPM_NAME}
+            "Download ${ARG_CPM_NAME} even if there is an installed system package"
+            ${USERVER_FORCE_DOWNLOAD_PACKAGES}
+        )
+    endif()
+
     if(ARG_VERSION)
         if(NOT ${name}_FIND_VERSION OR "${${name}_FIND_VERSION}" VERSION_LESS "${ARG_VERSION}")
             set("${name}_FIND_VERSION" "${ARG_VERSION}")
@@ -78,6 +104,12 @@ endmacro()
 macro(_userver_module_find_part)
     # Also uses ARGs left over from _userver_find_module_begin
 
+    # TODO: return() doesn't work inside of macro
+    # if(USERVER_FORCE_DOWNLOAD_${ARG_CPM_NAME})
+    #     message(STATUS "Skipping ${ARG_CPM_NAME} system package search due to USERVER_FORCE_DOWNLOAD_${ARG_CPM_NAME}=TRUE")
+    #     return()
+    # endif()
+
     set(options)
     set(oneValueArgs PART_TYPE)
     set(multiValueArgs NAMES PATHS PATH_SUFFIXES)
@@ -261,12 +293,25 @@ macro(_userver_module_end)
         list(APPEND required_vars "${programs_variable}")
     endif()
     if(required_vars)
-        find_package_handle_standard_args(
-            "${current_package_name}"
-            REQUIRED_VARS ${required_vars}
-            FAIL_MESSAGE "${FULL_ERROR_MESSAGE}"
-        )
-        mark_as_advanced(${required_vars})
+        foreach(_CURRENT_VAR ${required_vars})
+            if(NOT ${_CURRENT_VAR})
+                set(NEED_CPM TRUE)
+                if(USERVER_DOWNLOAD_PACKAGE_${ARG_CPM_NAME})
+                    set(${_CURRENT_VAR})
+                endif()
+            endif()
+        endforeach()
+
+        if(NEED_CPM AND USERVER_DOWNLOAD_PACKAGE_${ARG_CPM_NAME})
+            _userver_cpm_addpackage("${current_package_name}")
+        else()
+            find_package_handle_standard_args(
+                "${current_package_name}"
+                REQUIRED_VARS ${required_vars}
+                FAIL_MESSAGE "${FULL_ERROR_MESSAGE}"
+            )
+            mark_as_advanced(${required_vars})
+        endif()
     else()
         # Forward to another CMake module, add nice error messages if missing.
         set(wrapped_package_name "${current_package_name}")
@@ -323,6 +368,29 @@ macro(_userver_module_end)
     endif()
 endmacro()
 
+macro(_userver_cpm_addpackage name)
+    include(DownloadUsingCPM)
+
+    set(EXTRA_ARGS)
+    if(ARG_CPM_DOWNLOAD_ONLY)
+        set(EXTRA_ARGS ${EXTRA_ARGS} DOWNLOAD_ONLY)
+    endif()
+    cpmaddpackage(
+        NAME ${name}
+        VERSION ${ARG_CPM_VERSION}
+        GITHUB_REPOSITORY ${ARG_CPM_GITHUB_REPOSITORY}
+        URL ${ARG_CPM_URL}
+        OPTIONS ${ARG_CPM_OPTIONS}
+        SOURCE_SUBDIR ${ARG_CPM_SOURCE_SUBDIR}
+        GIT_TAG ${ARG_CPM_GIT_TAG}
+        ${EXTRA_ARGS}
+    )
+    if(NOT ARG_CPM_DOWNLOAD_ONLY)
+        mark_targets_as_system("${${name}_SOURCE_DIR}")
+    endif()
+    set(${name}_FOUND 1)
+endmacro()
+
 function(_userver_macos_set_default_dir variable command_args)
     set(default_value "")
     if(CMAKE_SYSTEM_NAME MATCHES "Darwin" AND NOT DEFINED ${variable})
diff --git a/cmake/PrepareInstall.cmake b/cmake/PrepareInstall.cmake
index 828e3dcd921d..3c5b3326de5c 100644
--- a/cmake/PrepareInstall.cmake
+++ b/cmake/PrepareInstall.cmake
@@ -60,6 +60,7 @@ function(_userver_export_targets)
         CONFIGURATIONS RELEASE
         NAMESPACE userver::
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/userver/release
+        COMPONENT universal
     )
     install(
         EXPORT userver-targets_d
@@ -67,6 +68,7 @@ function(_userver_export_targets)
         CONFIGURATIONS DEBUG
         NAMESPACE userver::
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/userver/debug
+        COMPONENT universal
     )
 endfunction()
 
@@ -74,6 +76,7 @@ function(_userver_directory_install)
     if(NOT USERVER_INSTALL)
         return()
     endif()
+    set(option)
     set(oneValueArgs COMPONENT DESTINATION PATTERN)
     set(multiValueArgs FILES DIRECTORY PROGRAMS)
     cmake_parse_arguments(ARG "${option}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}")
@@ -145,3 +148,64 @@ function(_userver_make_install_config)
         DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/userver"
     )
 endfunction()
+
+function(_userver_install_component)
+    if(NOT USERVER_INSTALL)
+        return()
+    endif()
+
+    set(oneValueArgs MODULE)
+    set(multiValueArgs DEPENDS)
+    cmake_parse_arguments(ARG "${option}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}")
+
+    string(TOUPPER "${ARG_MODULE}" MODULE_UPPER)
+    if(CPACK_COMPONENTS_GROUPING STREQUAL ONE_PER_GROUP)
+        if(NOT CPACK_DEBIAN_${MODULE_UPPER}_PACKAGE_DEPENDS)
+	    message(FATAL_ERROR "File with per-component dependencies is missing (component ${ARG_MODULE}). Either use CPACK_COMPONENTS_GROUPING=ALL_COMPONENTS_IN_ONE to build a single all-in-one package, or create dependency file ${USERVER_ROOT_DIR}/scripts/docs/en/deps/${DEPENDENCIES_FILESTEM}/${ARG_MODULE}.")
+        endif()
+    endif()
+
+    execute_process(
+        COMMAND cat "${USERVER_ROOT_DIR}/scripts/docs/en/deps/${DEPENDENCIES_FILESTEM}/${ARG_MODULE}"
+        COMMAND tr "\n" " "
+        COMMAND sed "s/ \\(.\\)/, \\1/g"
+        OUTPUT_VARIABLE MODULE_DEPENDS
+    )
+    file(APPEND "${CMAKE_BINARY_DIR}/cpack.variables.inc" "
+        set(CPACK_DEBIAN_${MODULE_UPPER}_PACKAGE_NAME libuserver-${ARG_MODULE}-dev)
+        set(CPACK_DEBIAN_${MODULE_UPPER}_PACKAGE_CONFLICTS libuserver-all-dev)
+        set(CPACK_COMPONENT_${MODULE_UPPER}_DEPENDS ${ARG_DEPENDS})
+        set(CPACK_DEBIAN_${MODULE_UPPER}_PACKAGE_DEPENDS \"${MODULE_DEPENDS}\")
+    ")
+
+    file(APPEND "${CMAKE_BINARY_DIR}/cpack.inc" "
+        cpack_add_component_group(${ARG_MODULE} EXPANDED)
+        cpack_add_component(${ARG_MODULE} GROUP ${ARG_MODULE} INSTALL_TYPES Full)
+    ")
+endfunction()
+
+function(_userver_prepare_components)
+    file(REMOVE "${CMAKE_BINARY_DIR}/cpack.inc")
+    file(REMOVE "${CMAKE_BINARY_DIR}/cpack.variables.inc")
+
+    # DEB dependencies:
+    execute_process(COMMAND lsb_release -cs OUTPUT_VARIABLE OS_CODENAME)
+    if(OS_CODENAME MATCHES "^bookworm")
+        set(DEPENDENCIES_FILESTEM "debian-12")
+    elseif(OS_CODENAME MATCHES "^bullseye")
+        set(DEPENDENCIES_FILESTEM "debian-11")
+    elseif(OS_CODENAME MATCHES "^noble")
+        set(DEPENDENCIES_FILESTEM "ubuntu-24.04")
+    elseif(OS_CODENAME MATCHES "^jammy")
+        set(DEPENDENCIES_FILESTEM "ubuntu-22.04")
+    elseif(OS_CODENAME MATCHES "^impish")
+        set(DEPENDENCIES_FILESTEM "ubuntu-21.04")
+    elseif(OS_CODENAME MATCHES "^focal")
+        set(DEPENDENCIES_FILESTEM "ubuntu-20.04")
+    elseif(OS_CODENAME MATCHES "^bionic")
+        set(DEPENDENCIES_FILESTEM "ubuntu-18.04")
+    endif()
+    set(DEPENDENCIES_FILESTEM ${DEPENDENCIES_FILESTEM} CACHE INTERNAL "")
+endfunction()
+
+_userver_prepare_components()
diff --git a/cmake/SetupAbseil.cmake b/cmake/SetupAbseil.cmake
index fb669c056f75..596beddee6dd 100644
--- a/cmake/SetupAbseil.cmake
+++ b/cmake/SetupAbseil.cmake
@@ -31,6 +31,9 @@ cpmaddpackage(
     GITHUB_REPOSITORY
     abseil/abseil-cpp
     SYSTEM
+    PATCHES
+    abseil_pr_1707.patch
+    abseil_pr_1739.patch
     OPTIONS
     "ABSL_PROPAGATE_CXX_STD ON"
     "ABSL_ENABLE_INSTALL ON"
diff --git a/cmake/SetupBoost.cmake b/cmake/SetupBoost.cmake
new file mode 100644
index 000000000000..b5af70ac0447
--- /dev/null
+++ b/cmake/SetupBoost.cmake
@@ -0,0 +1,73 @@
+include_guard(GLOBAL)
+
+option(USERVER_DOWNLOAD_PACKAGE_BOOST "Download and setup Boost if no library of matching version was found"
+    ${USERVER_DOWNLOAD_PACKAGES}
+)
+option(USERVER_FORCE_DOWNLOAD_BOOST "Download Boost even if there is an installed system package"
+    ${USERVER_FORCE_DOWNLOAD_PACKAGES}
+)
+
+set(BOOST_VERSION 1.89.0)
+set(BOOST_INCLUDE_LIBRARIES_FIND_PACKAGE
+    atomic
+    program_options
+    filesystem
+    regex
+    locale
+    iostreams
+    context
+    coroutine
+)
+set(BOOST_INCLUDE_LIBRARIES
+    ${BOOST_INCLUDE_LIBRARIES_FIND_PACKAGE}
+    coroutine2
+    stacktrace
+    uuid
+    lockfree
+    endian
+    assert
+    predef
+)
+string(REGEX REPLACE ";" "\\\\\\\\;" BOOST_INCLUDE_LIBRARIES_LIST "${BOOST_INCLUDE_LIBRARIES}")
+
+if(NOT USERVER_FORCE_DOWNLOAD_BOOST AND NOT BOOST_CPM)
+    if(USERVER_DOWNLOAD_PACKAGE_BOOST)
+        set(MAYBE_REQUIRED)
+    else()
+        set(MAYBE_REQUIRED REQUIRED)
+    endif()
+    find_package(
+        Boost ${MAYBE_REQUIRED} CONFIG
+        COMPONENTS ${BOOST_INCLUDE_LIBRARIES_FIND_PACKAGE} stacktrace_basic
+        OPTIONAL_COMPONENTS stacktrace_backtrace stacktrace_windbg coroutine2 config assert
+    )
+
+    if(Boost_FOUND)
+        return()
+    endif()
+endif()
+
+include(DownloadUsingCPM)
+set(BOOST_CPM TRUE CACHE BOOL "")
+
+cpmaddpackage(
+    NAME Boost
+    VERSION ${BOOST_VERSION}
+    URL https://github.com/boostorg/boost/releases/download/boost-${BOOST_VERSION}/boost-${BOOST_VERSION}-cmake.tar.xz
+    URL_HASH SHA256=67acec02d0d118b5de9eb441f5fb707b3a1cdd884be00ca24b9a73c995511f74
+    OPTIONS
+        "BOOST_ENABLE_CMAKE ON"
+        "BOOST_INCLUDE_LIBRARIES ${BOOST_INCLUDE_LIBRARIES_LIST}"
+        "BOOST_SKIP_INSTALL_RULES ON"
+	"BUILD_SHARED_LIBS OFF"
+	"BOOST_RUNTIME_LINK static"
+	"BUILD_TESTING OFF"
+	"BOOST_LOCKFREE_BUILD_TESTS OFF"
+    EXCLUDE_FROM_ALL
+)
+
+# set version variable as find_package() does
+set(Boost_VERSION_STRING ${BOOST_VERSION} CACHE STRING "")
+
+# We have fresh version of boost, DWCAS should work
+set(USERVER_IMPL_DWCAS_CHECKED TRUE CACHE INTERNAL "TRUE iff checked that DWCAS works")
diff --git a/cmake/SetupCURL.cmake b/cmake/SetupCURL.cmake
index 0eb5f2b57fcf..c640c35c88d4 100644
--- a/cmake/SetupCURL.cmake
+++ b/cmake/SetupCURL.cmake
@@ -61,6 +61,8 @@ cpmaddpackage(
     "BUILD_CURL_EXE OFF"
     "BUILD_SHARED_LIBS OFF"
     "CURL_DISABLE_TESTS ON"
+    "CURL_DISABLE_LDAP ON"
+    "HAVE_DLOPEN TRUE"
     ${CURL_LTO_OPTION}
 )
 
diff --git a/cmake/SetupGTest.cmake b/cmake/SetupGTest.cmake
index c92275400232..3988026f626a 100644
--- a/cmake/SetupGTest.cmake
+++ b/cmake/SetupGTest.cmake
@@ -5,8 +5,11 @@ endif()
 option(USERVER_DOWNLOAD_PACKAGE_GTEST "Download and setup gtest if no gtest of matching version was found"
        ${USERVER_DOWNLOAD_PACKAGES}
 )
+option(USERVER_FORCE_DOWNLOAD_GTEST "Download gtest even if there is an installed system package"
+       ${USERVER_FORCE_DOWNLOAD_PACKAGES}
+)
 
-if(NOT USERVER_FORCE_DOWNLOAD_PACKAGES)
+if(NOT USERVER_FORCE_DOWNLOAD_GTEST)
     find_package(GTest QUIET)
     if(NOT GTest_FOUND AND NOT USERVER_DOWNLOAD_PACKAGE_GTEST)
         message(
diff --git a/cmake/SetupGrpc.cmake b/cmake/SetupGrpc.cmake
index ec0f0afea6d3..c826a13200f3 100644
--- a/cmake/SetupGrpc.cmake
+++ b/cmake/SetupGrpc.cmake
@@ -73,6 +73,7 @@ cpmaddpackage(
     GITHUB_REPOSITORY
     grpc/grpc
     SYSTEM
+    PATCHES grpc_pr_36805.patch
     OPTIONS
     "BUILD_SHARED_LIBS OFF"
     "CARES_BUILD_TOOLS OFF"
diff --git a/cmake/SetupOpenssl.cmake b/cmake/SetupOpenssl.cmake
new file mode 100644
index 000000000000..08b6b1b6c77f
--- /dev/null
+++ b/cmake/SetupOpenssl.cmake
@@ -0,0 +1,72 @@
+include_guard(GLOBAL)
+
+option(USERVER_DOWNLOAD_PACKAGE_OPENSSL "Download and setup OpenSSL if no library of matching version was found"
+       ${USERVER_DOWNLOAD_PACKAGES}
+)
+option(USERVER_FORCE_DOWNLOAD_OPENSSL "Download OpenSSL even if there is an installed system package"
+       ${USERVER_FORCE_DOWNLOAD_PACKAGES}
+)
+
+if(NOT USERVER_FORCE_DOWNLOAD_OPENSSL AND NOT OpenSSL_CPM)
+    if(USERVER_DOWNLOAD_PACKAGE_OPENSSL)
+        find_package(OpenSSL)
+    else()
+        find_package(OpenSSL REQUIRED)
+    endif()
+
+    if(OpenSSL_FOUND)
+        return()
+    endif()
+endif()
+set(OpenSSL_CPM TRUE CACHE BOOL "")
+ 
+include(DownloadUsingCPM)
+
+set(OPENSSL_INSTALL_DIR ${CMAKE_BINARY_DIR}/openssl)
+execute_process(COMMAND mkdir -p ${OPENSSL_INSTALL_DIR}/usr/local/include)
+
+# Flags are copied from Ubuntu's debian/rules
+set(CONFIGURE_FLAGS no-idea no-mdc2 no-rc5 no-zlib no-ssl3 enable-unit-test no-ssl3-method enable-rfc3779 enable-cms no-capieng)
+set(OPENSSL_VERSION 3.5.2)
+
+cpmaddpackage(
+     NAME OpenSSL
+     URL https://github.com/openssl/openssl/releases/download/openssl-${OPENSSL_VERSION}/openssl-${OPENSSL_VERSION}.tar.gz
+     URL_HASH SHA512=db2c7a88bea432f96d867a98af15f850f371d4136c657338de93cb88a39a3578c025b5df7310e195a02fc715ad5a2422a319a44f0247c6a7e2ba8b36aad77651
+)
+
+# We use custom target to be able to set build dependency
+# for *external* libcurl from CPM
+add_custom_target(
+    OpenSSL
+        test -e ${OPENSSL_INSTALL_DIR}/.installed || CFLAGS=${CMAKE_C_FLAGS} ./config --libdir=/usr/local/lib ${CONFIGURE_FLAGS}
+    COMMAND
+        test -e ${OPENSSL_INSTALL_DIR}/.installed || make -j8
+    COMMAND
+        test -e ${OPENSSL_INSTALL_DIR}/.installed || make DESTDIR=${OPENSSL_INSTALL_DIR} install_sw
+    COMMAND
+        touch ${OPENSSL_INSTALL_DIR}/.installed
+    WORKING_DIRECTORY ${OpenSSL_SOURCE_DIR}
+    COMMENT "Compiling OpenSSL library"
+)
+
+
+add_library(Crypto STATIC IMPORTED GLOBAL)
+add_dependencies(Crypto OpenSSL)
+set_property(TARGET Crypto PROPERTY IMPORTED_LOCATION ${OPENSSL_INSTALL_DIR}/usr/local/lib/libcrypto.a)
+target_include_directories(Crypto INTERFACE ${OPENSSL_INSTALL_DIR}/usr/local/include)
+
+
+add_library(SSL STATIC IMPORTED GLOBAL)
+add_dependencies(SSL OpenSSL)
+set_property(TARGET SSL PROPERTY IMPORTED_LOCATION ${OPENSSL_INSTALL_DIR}/usr/local/lib/libssl.a)
+target_include_directories(SSL INTERFACE ${OPENSSL_INSTALL_DIR}/usr/local/include)
+
+add_library(OpenSSL::Crypto ALIAS Crypto)
+add_library(OpenSSL::SSL ALIAS SSL)
+
+# Light emulation of find_package(OpenSSL) for libcurl
+set(OpenSSL_FOUND TRUE CACHE BOOL "" FORCE)
+set(OPENSSL_FOUND TRUE CACHE BOOL "" FORCE)
+set(OPENSSL_CRYPTO_LIBRARY OpenSSL::Crypto CACHE STRING "" FORCE)
+set(OPENSSL_INCLUDE_DIR ${OPENSSL_INSTALL_DIR}/usr/local/include CACHE FILEPATH "" FORCE)
diff --git a/cmake/SetupProtobuf.cmake b/cmake/SetupProtobuf.cmake
index 2987e2d31b0a..85346f6d7d52 100644
--- a/cmake/SetupProtobuf.cmake
+++ b/cmake/SetupProtobuf.cmake
@@ -4,7 +4,12 @@ option(USERVER_FORCE_DOWNLOAD_PROTOBUF "Download Protobuf even if there is an in
 )
 
 function(_userver_set_protobuf_version_category)
-    if(Protobuf_VERSION VERSION_GREATER_EQUAL 5.26.0
+    if(Protobuf_VERSION VERSION_GREATER_EQUAL 6.30.0
+       AND Protobuf_VERSION VERSION_LESS 7.0.0
+       OR Protobuf_VERSION VERSION_GREATER_EQUAL 30.0.0
+    )
+        set_property(GLOBAL PROPERTY userver_protobuf_version_category 6)
+    elseif(Protobuf_VERSION VERSION_GREATER_EQUAL 5.26.0
        AND Protobuf_VERSION VERSION_LESS 6.0.0
        OR Protobuf_VERSION VERSION_GREATER_EQUAL 26.0.0
     )
diff --git a/cmake/UserverGenerateDynamicConfigsDocs.cmake b/cmake/UserverGenerateDynamicConfigsDocs.cmake
index c80a0303c308..3cbd3d3c4522 100644
--- a/cmake/UserverGenerateDynamicConfigsDocs.cmake
+++ b/cmake/UserverGenerateDynamicConfigsDocs.cmake
@@ -4,7 +4,8 @@ function(_userver_add_target_gen_dynamic_configs_docs)
     add_custom_target(
         userver-gen-dynamic-configs-docs
         COMMENT "Generate dynamic_configs .md docs"
-	COMMAND 
+	COMMAND
+	    ${USERVER_PYTHON_PATH}
 	    ${CMAKE_CURRENT_SOURCE_DIR}/scripts/docs/dynamic_config_yaml_to_md.py
 	    -o ${CMAKE_CURRENT_BINARY_DIR}/docs-dynamic-configs
 	    ${YAML_FILENAMES}
diff --git a/cmake/UserverModule.cmake b/cmake/UserverModule.cmake
index 4b537c95da5e..86067c334f14 100644
--- a/cmake/UserverModule.cmake
+++ b/cmake/UserverModule.cmake
@@ -23,6 +23,7 @@ function(userver_module MODULE)
         UBENCH_LINK_LIBRARIES
         UBENCH_DATABASES
         UBENCH_ENV
+        DEPENDS
     )
     cmake_parse_arguments(ARG "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})
     if(ARG_UNPARSED_ARGUMENTS)
@@ -89,6 +90,8 @@ function(userver_module MODULE)
                 DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/userver"
             )
         endif()
+
+        _userver_install_component(MODULE ${MODULE} DEPENDS ${ARG_DEPENDS})
     endif()
 
     # 1. userver-${MODULE}-unittest
diff --git a/cmake/UserverPack.cmake b/cmake/UserverPack.cmake
index 2b702528d61d..af281aa9419b 100644
--- a/cmake/UserverPack.cmake
+++ b/cmake/UserverPack.cmake
@@ -6,6 +6,13 @@ set(CPACK_PACKAGE_DESCRIPTION
     services and utilities."
 )
 
+option(USERVER_INSTALL_MULTIPACKAGE "Whether create per-component packages" OFF)
+if(USERVER_INSTALL_MULTIPACKAGE)
+    set(CPACK_COMPONENTS_GROUPING ONE_PER_GROUP)
+else()
+    set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)
+endif()
+
 set(CPACK_PACKAGE_NAME "libuserver-all-dev")
 set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
 set(CPACK_PACKAGE_VERSION "${USERVER_VERSION}")
@@ -26,27 +33,9 @@ set(CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS
     WORLD_EXECUTE
 )
 
-# DEB dependencies:
-execute_process(COMMAND lsb_release -cs OUTPUT_VARIABLE OS_CODENAME)
-if(OS_CODENAME MATCHES "^bookworm")
-    set(DEPENDENCIES_FILE "debian-12.md")
-elseif(OS_CODENAME MATCHES "^bullseye")
-    set(DEPENDENCIES_FILE "debian-11.md")
-elseif(OS_CODENAME MATCHES "^noble")
-    set(DEPENDENCIES_FILE "ubuntu-24.04.md")
-elseif(OS_CODENAME MATCHES "^jammy")
-    set(DEPENDENCIES_FILE "ubuntu-22.04.md")
-elseif(OS_CODENAME MATCHES "^impish")
-    set(DEPENDENCIES_FILE "ubuntu-21.04.md")
-elseif(OS_CODENAME MATCHES "^focal")
-    set(DEPENDENCIES_FILE "ubuntu-20.04.md")
-elseif(OS_CODENAME MATCHES "^bionic")
-    set(DEPENDENCIES_FILE "ubuntu-18.04.md")
-endif()
-
-if(DEPENDENCIES_FILE)
+if(DEPENDENCIES_FILESTEM)
     execute_process(
-        COMMAND cat "${USERVER_ROOT_DIR}/scripts/docs/en/deps/${DEPENDENCIES_FILE}"
+        COMMAND cat "${USERVER_ROOT_DIR}/scripts/docs/en/deps/${DEPENDENCIES_FILESTEM}.md"
         COMMAND tr "\n" " "
         COMMAND sed "s/ \\(.\\)/, \\1/g"
         OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_DEPENDS
@@ -55,5 +44,16 @@ else()
     set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6")
 endif()
 
+if(CPACK_COMPONENTS_GROUPING STREQUAL ONE_PER_GROUP)
+    set(CPACK_DEB_COMPONENT_INSTALL ON)
+    set(CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS ON)
+endif()
+
+# Must go just before CPack
+include("${CMAKE_BINARY_DIR}/cpack.variables.inc")
+
 # CPack setup is ready. Including it:
 include(CPack)
+
+# Must go after all modules
+include("${CMAKE_BINARY_DIR}/cpack.inc")
diff --git a/cmake/UserverRequireDWCAS.cmake b/cmake/UserverRequireDWCAS.cmake
index f280b0ec8926..12d502a119b4 100644
--- a/cmake/UserverRequireDWCAS.cmake
+++ b/cmake/UserverRequireDWCAS.cmake
@@ -38,6 +38,8 @@ function(userver_target_require_dwcas target visibility)
     # boost::atomic::value() since Boost 1.74.0.
     if("${Boost_VERSION_STRING}" VERSION_GREATER_EQUAL "${BOOST_DWCAS_MIN_VERSION}")
         message(STATUS "DWCAS: Using boost::atomic")
+        list(APPEND TEST_LIBRARIES "Boost::atomic")
+        get_target_property(BOOST_ATOMIC_INCLUDE_DIR Boost::atomic INTERFACE_INCLUDE_DIRECTORIES)
     else()
         message(WARNING "DWCAS: Using std::atomic")
         target_compile_definitions(${target} ${visibility} USERVER_USE_STD_DWCAS=1)
@@ -92,8 +94,9 @@ function(userver_target_require_dwcas target visibility)
     try_run(
         RUN_RESULT COMPILE_RESULT "${CMAKE_CURRENT_BINARY_DIR}/require_dwcas"
         "${USERVER_ROOT_DIR}/cmake/UserverRequireDWCAS.cpp"
-        CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${Boost_INCLUDE_DIRS}"
-        COMPILE_DEFINITIONS ${TEST_DEFINITIONS} LINK_LIBRARIES ${TEST_LIBRARIES}
+        CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${BOOST_ATOMIC_INCLUDE_DIR};${Boost_INCLUDE_DIRS}"
+        COMPILE_DEFINITIONS ${TEST_DEFINITIONS}
+        LINK_LIBRARIES ${TEST_LIBRARIES}
         COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT
     )
 
diff --git a/cmake/UserverSetupEnvironment.cmake b/cmake/UserverSetupEnvironment.cmake
index 7f1d52c4edbe..351a34627001 100644
--- a/cmake/UserverSetupEnvironment.cmake
+++ b/cmake/UserverSetupEnvironment.cmake
@@ -77,6 +77,12 @@ function(_userver_setup_environment_impl)
         PARENT_SCOPE
     )
 
+    if (NOT DEFINED CMAKE_CXX_SCAN_FOR_MODULES)
+        # For now, we don't use C++ modules, so we can save ourselves the overhead
+        # of scanning every source file
+        set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
+    endif()
+
     add_compile_options("-pipe" "-g" "-fPIC")
     add_compile_definitions("PIC=1")
 
diff --git a/cmake/UserverSql.cmake b/cmake/UserverSql.cmake
index fcf8e0bd13e4..00c5e7d36fdd 100644
--- a/cmake/UserverSql.cmake
+++ b/cmake/UserverSql.cmake
@@ -20,7 +20,7 @@ _userver_prepare_sql()
 
 function(userver_add_sql_library TARGET)
     set(OPTIONS)
-    set(ONE_VALUE_ARGS OUTPUT_DIR NAMESPACE QUERY_LOG_MODE)
+    set(ONE_VALUE_ARGS SOURCE_DIR OUTPUT_DIR NAMESPACE QUERY_LOG_MODE)
     set(MULTI_VALUE_ARGS SQL_FILES)
     cmake_parse_arguments(ARG "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})
     if(NOT ARG_NAMESPACE)
@@ -30,12 +30,19 @@ function(userver_add_sql_library TARGET)
         set(ARG_QUERY_LOG_MODE "full")
     endif()
     set(FILENAME "sql_queries")
+    if(NOT ARG_SOURCE_DIR)
+        set(ARG_SOURCE_DIR ".")
+    endif()
+    if(NOT IS_ABSOLUTE "${ARG_SOURCE_DIR}")
+        set(ARG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${ARG_SOURCE_DIR}")
+    endif()
 
     set(SQL_FILES)
     foreach(WILDCARD ${ARG_SQL_FILES})
-        file(GLOB FILES ${WILDCARD})
+        file(GLOB_RECURSE FILES RELATIVE ${ARG_SOURCE_DIR} "${ARG_SOURCE_DIR}/${WILDCARD}")
         list(APPEND SQL_FILES ${FILES})
     endforeach()
+    list(TRANSFORM SQL_FILES PREPEND "${ARG_SOURCE_DIR}/")
 
     get_property(USERVER_SQL_PYTHON_BINARY GLOBAL PROPERTY userver_sql_python_binary)
     get_property(USERVER_SQL_SCRIPTS_PATH GLOBAL PROPERTY userver_scripts_sql)
@@ -50,7 +57,8 @@ function(userver_add_sql_library TARGET)
         OUTPUT ${output_files}
         COMMAND
             ${USERVER_SQL_PYTHON_BINARY} ${USERVER_SQL_SCRIPTS_PATH}/generator.py --namespace ${ARG_NAMESPACE}
-            --output-dir ${ARG_OUTPUT_DIR} --query-log-mode ${ARG_QUERY_LOG_MODE} --testsuite-output-dir
+            --source-dir ${ARG_SOURCE_DIR} --output-dir ${ARG_OUTPUT_DIR}
+            --query-log-mode ${ARG_QUERY_LOG_MODE} --testsuite-output-dir
             ${TESTSUITE_OUTPUT_DIR} ${SQL_FILES} ${CODEGEN}
         DEPENDS ${SQL_FILES}
     )
diff --git a/cmake/abseil_pr_1707.patch b/cmake/abseil_pr_1707.patch
new file mode 100644
index 000000000000..31f44ade0dfd
--- /dev/null
+++ b/cmake/abseil_pr_1707.patch
@@ -0,0 +1,33 @@
+commit 6dee153242d7becebe026a9bed52f4114441719d
+Author: Soo-Hwan Na <whiteshell2544@naver.com>
+Date:   Wed Jul 10 09:20:07 2024 -0700
+
+    PR #1707: Fixup absl_random compile breakage in Apple ARM64 targets
+    
+    Imported from GitHub PR https://github.com/abseil/abseil-cpp/pull/1707
+    
+    Switched to append a full string of "-Xarch_x86_64 -maes" instead of " -Xarch_x86_64" "-maes", for example. Now cmake correctly appends -Xarch_x86_64 to each x64 specific compile option, removing the error caused in recent clang releases:
+    
+    clang++: error: unsupported option '-msse4.1' for target 'arm64-apple-darwin23.5.0'
+    
+    Merge 83d17537ee70158d627681a0f0c15f15f30ef838 into f46495ea96f68fc3f6c394f099b2992743f6ff7f
+    
+    Merging this change closes #1707
+    
+    COPYBARA_INTEGRATE_REVIEW=https://github.com/abseil/abseil-cpp/pull/1707 from Royna2544:patch-1 83d17537ee70158d627681a0f0c15f15f30ef838
+    PiperOrigin-RevId: 651046496
+    Change-Id: Ifdb3848febeead4fb562a2d9f0fdca2e0aea185d
+
+diff --git a/absl/copts/AbseilConfigureCopts.cmake b/absl/copts/AbseilConfigureCopts.cmake
+index 1afb9610..e0007ef8 100644
+--- a/absl/copts/AbseilConfigureCopts.cmake
++++ b/absl/copts/AbseilConfigureCopts.cmake
+@@ -42,7 +42,7 @@ if(APPLE AND CMAKE_CXX_COMPILER_ID MATCHES [[Clang]])
+     string(TOUPPER "${_arch}" _arch_uppercase)
+     string(REPLACE "X86_64" "X64" _arch_uppercase ${_arch_uppercase})
+     foreach(_flag IN LISTS ABSL_RANDOM_HWAES_${_arch_uppercase}_FLAGS)
+-      list(APPEND ABSL_RANDOM_RANDEN_COPTS "-Xarch_${_arch}" "${_flag}")
++      list(APPEND ABSL_RANDOM_RANDEN_COPTS "-Xarch_${_arch} ${_flag}")
+     endforeach()
+   endforeach()
+   # If a compiler happens to deal with an argument for a currently unused
diff --git a/cmake/abseil_pr_1739.patch b/cmake/abseil_pr_1739.patch
new file mode 100644
index 000000000000..ca0c47dcfb7b
--- /dev/null
+++ b/cmake/abseil_pr_1739.patch
@@ -0,0 +1,38 @@
+From faf1b03a591f06933da02976119da5743f428e4f Mon Sep 17 00:00:00 2001
+From: Christopher Fore <csfore@posteo.net>
+Date: Mon, 5 Aug 2024 10:48:19 -0400
+Subject: [PATCH] container/internal: Explicitly include <cstdint>
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+GCC 15 will no longer include <cstdint> by default, resulting in build
+failures in projects that do not explicitly include it.
+
+Error:
+absl/container/internal/container_memory.h:66:27: error: ‘uintptr_t’ does not name a type
+   66 |   assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
+      |                           ^~~~~~~~~
+absl/container/internal/container_memory.h:31:1: note: ‘uintptr_t’ is defined in header ‘<cstdint>’; this is probably fixable by adding ‘#include <cstdint>’
+   30 | #include "absl/utility/utility.h"
+  +++ |+#include <cstdint>
+   31 |
+
+See-also: https://gcc.gnu.org/pipermail/gcc-cvs/2024-August/407124.html
+Signed-off-by: Christopher Fore <csfore@posteo.net>
+---
+ absl/container/internal/container_memory.h | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/absl/container/internal/container_memory.h b/absl/container/internal/container_memory.h
+index ba8e08a2d22..e7031797018 100644
+--- a/absl/container/internal/container_memory.h
++++ b/absl/container/internal/container_memory.h
+@@ -17,6 +17,7 @@
+ 
+ #include <cassert>
+ #include <cstddef>
++#include <cstdint>
+ #include <cstring>
+ #include <memory>
+ #include <new>
diff --git a/cmake/embedded_config.cmake b/cmake/embedded_config.cmake
index e226a44d20d4..727626def2af 100644
--- a/cmake/embedded_config.cmake
+++ b/cmake/embedded_config.cmake
@@ -1,6 +1,6 @@
 cmake_policy(SET CMP0053 NEW)
 
-set(NAMESPACE userver)
+set(NAMESPACE USERVER_NAMESPACE)
 set(FILE_IN ${CMAKE_CURRENT_BINARY_DIR}/embedded.h.in)
 set(TEMPLATE
     "
@@ -35,6 +35,7 @@ APPLE_PREFIX \"@NAME@_end:\\n\"
 \".byte 0\\n\"
 APPLE_PREFIX \"@NAME@_size:\\n\"
 \".int \" APPLE_PREFIX \"@NAME@_end - \" APPLE_PREFIX \"@NAME@_begin\\n\"
+\".previous\\n\"
 );
 
 extern \"C\" const char @NAME@_begin[];
@@ -43,7 +44,7 @@ extern \"C\" const int @NAME@_size;
 
 
 __attribute__((constructor)) void @NAME@_call() {
-  utils::RegisterResource(\"@NAME@\", std::string_view{@NAME@_begin, static_cast<size_t>(@NAME@_size)});
+  ${NAMESPACE}::utils::RegisterResource(\"@NAME@\", std::string_view{@NAME@_begin, static_cast<size_t>(@NAME@_size)});
 }
 "
 )
diff --git a/cmake/grpc_pr_36805.patch b/cmake/grpc_pr_36805.patch
new file mode 100644
index 000000000000..9a50fabef48e
--- /dev/null
+++ b/cmake/grpc_pr_36805.patch
@@ -0,0 +1,30 @@
+commit e55f69cedd0ef7344e0bcb64b5ec9205e6aa4f04
+Author: Amy Huang <akhuang@google.com>
+Date:   Wed Jun 5 09:41:28 2024 -0700
+
+    [Fix] new clang -Wmissing-template-arg-list-after-template-kw warning (#36805)
+    
+    Clang now requires a template argument list after the use of the template keyword. Edit this
+    instance to remove the template keyword since there are no template arguments.
+    
+    See https://github.com/llvm/llvm-project/pull/80801.
+    
+    Closes #36805
+    
+    COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/36805 from amykhuang:master 6f385be2a0f014d1a27fb32e427938c4ced57f83
+    PiperOrigin-RevId: 640554705
+
+diff --git a/src/core/lib/promise/detail/basic_seq.h b/src/core/lib/promise/detail/basic_seq.h
+index 663609d41..5f4199e5d 100644
+--- a/src/core/lib/promise/detail/basic_seq.h
++++ b/src/core/lib/promise/detail/basic_seq.h
+@@ -99,8 +99,7 @@ class BasicSeqIter {
+           }
+           cur_ = next;
+           state_.~State();
+-          Construct(&state_,
+-                    Traits::template CallSeqFactory(f_, *cur_, std::move(arg)));
++          Construct(&state_, Traits::CallSeqFactory(f_, *cur_, std::move(arg)));
+           return PollNonEmpty();
+         });
+   }
diff --git a/cmake/modules/FindPythonDev.cmake b/cmake/modules/FindPythonDev.cmake
index 28c5922e11e8..77babfbf125c 100644
--- a/cmake/modules/FindPythonDev.cmake
+++ b/cmake/modules/FindPythonDev.cmake
@@ -11,19 +11,14 @@ _userver_module_begin(
     python
 )
 
+# minimum version is bound by testsuite
 _userver_module_find_include(
     NAMES
     Python.h
     PATHS
     /usr/include/python3m
-    /usr/include/python3.6m
-    /usr/include/python3.7m
-    /usr/include/python3.8m
     /usr/include/python3.9m
     /usr/include/python3
-    /usr/include/python3.6
-    /usr/include/python3.7
-    /usr/include/python3.8
     /usr/include/python3.9
     /usr/include/python3.10
     /usr/include/python3.11
diff --git a/cmake/modules/Findc-ares.cmake b/cmake/modules/Findc-ares.cmake
index 22cb379ee89a..d077dccfba44 100644
--- a/cmake/modules/Findc-ares.cmake
+++ b/cmake/modules/Findc-ares.cmake
@@ -13,6 +13,16 @@ _userver_module_begin(
     c-ares
     PKG_CONFIG_NAMES
     libcares
+
+    CPM_NAME c-ares
+    CPM_GITHUB_REPOSITORY c-ares/c-ares
+    CPM_VERSION 1.34.5
+    CPM_OPTIONS
+        "CARES_STATIC ON"
+        "CARES_SHARED OFF"
+        "CARES_INSTALL OFF"
+        "CARES_BUILD_TOOLS OFF"
+        "CARES_STATIC_PIC ON"
 )
 
 _userver_module_find_include(NAMES ares.h)
diff --git a/cmake/modules/Findlibev.cmake b/cmake/modules/Findlibev.cmake
index 68022a78f1f0..f030286fcfe9 100644
--- a/cmake/modules/Findlibev.cmake
+++ b/cmake/modules/Findlibev.cmake
@@ -9,6 +9,10 @@ _userver_module_begin(
     libev-devel
     PACMAN_NAMES
     libev
+
+    CPM_NAME libev
+    CPM_URL http://dist.schmorp.de/libev/libev-4.33.tar.gz
+    CPM_DOWNLOAD_ONLY
 )
 
 _userver_module_find_include(NAMES ev.h libev/ev.h)
@@ -17,6 +21,52 @@ _userver_module_find_library(NAMES ev)
 
 _userver_module_end()
 
+function(_userver_execute_process)
+    execute_process(
+        ${ARGV}
+        RESULT_VARIABLE RET
+    )
+    if(NOT ("${RET}" EQUAL 0))
+        message(FATAL_ERROR "Command failed with return code ${RET} (${ARGV})")
+    endif()
+endfunction()
+
 if(NOT TARGET libev::libev)
-    add_library(libev::libev ALIAS libev)
+    if(TARGET libev)
+        add_library(libev::libev ALIAS libev)
+    elseif(libev_ADDED)
+        # nghttp2 doesn't use find_package(), but calls find_path() and find_library()
+        # so we have to provide libev.a at the _configure_ time, not at build time, =(
+        if(NOT EXISTS ${libev_BINARY_DIR}/.built)
+            _userver_execute_process(
+                COMMAND ${CMAKE_COMMAND} -E copy_directory ${libev_SOURCE_DIR} ${libev_BINARY_DIR}
+            )
+            _userver_execute_process(
+                COMMAND ./configure
+                WORKING_DIRECTORY ${libev_BINARY_DIR}
+            )
+            _userver_execute_process(
+                COMMAND make
+                WORKING_DIRECTORY ${libev_BINARY_DIR}
+            )
+            _userver_execute_process(
+                COMMAND rm -rf ${libev_BINARY_DIR}/.libs/libev.so
+            )
+            _userver_execute_process(
+                COMMAND touch ${libev_BINARY_DIR}/.built
+            )
+        endif()
+
+        add_library(libev STATIC IMPORTED)
+        target_include_directories(libev INTERFACE ${libev_BINARY_DIR})
+        set_target_properties(libev PROPERTIES IMPORTED_LOCATION ${libev_BINARY_DIR}/.libs/libev.a)
+
+        # For nghttp2 installed from CPM
+        list(APPEND CMAKE_INCLUDE_PATH ${libev_BINARY_DIR})
+        list(APPEND CMAKE_LIBRARY_PATH ${libev_BINARY_DIR}/.libs)
+
+        add_library(libev::libev ALIAS libev)
+    else()
+        message(FATAL_ERROR "libev cmake target not found, don't know how to link")
+    endif()
 endif()
diff --git a/cmake/modules/Findlibmariadb.cmake b/cmake/modules/Findlibmariadb.cmake
index f513785d9963..840526fe40cc 100644
--- a/cmake/modules/Findlibmariadb.cmake
+++ b/cmake/modules/Findlibmariadb.cmake
@@ -7,6 +7,8 @@ _userver_module_begin(
     libmariadb-dev
     FORMULA_NAMES
     mariadb
+    PACMAN_NAMES
+    mariadb-libs
     PKG_CONFIG_NAMES
     mariadb
 )
diff --git a/cmake/modules/Findlibnghttp2.cmake b/cmake/modules/Findlibnghttp2.cmake
index 968f850663bf..03811d16fb3f 100644
--- a/cmake/modules/Findlibnghttp2.cmake
+++ b/cmake/modules/Findlibnghttp2.cmake
@@ -7,6 +7,16 @@ _userver_module_begin(
     nghttp2
     PACMAN_NAMES
     libnghttp2
+
+    CPM_NAME libnghttp2
+    CPM_GITHUB_REPOSITORY nghttp2/nghttp2
+    CPM_VERSION 1.66.0
+    CPM_GIT_TAG v1.66.0
+    CPM_OPTIONS
+        "BUILD_STATIC_LIBS ON"
+        "BUILD_SHARED_LIBS OFF"
+        "ENABLE_APP OFF"
+        "ENABLE_EXAMPLES OFF"
 )
 
 _userver_module_find_include(NAMES nghttp2/nghttp2.h)
@@ -16,5 +26,11 @@ _userver_module_find_library(NAMES nghttp2)
 _userver_module_end()
 
 if(NOT TARGET libnghttp2::nghttp2)
-    add_library(libnghttp2::nghttp2 ALIAS libnghttp2)
+    if(TARGET libnghttp2)
+        add_library(libnghttp2::nghttp2 ALIAS libnghttp2)
+    elseif(TARGET nghttp2_static)
+        add_library(libnghttp2::nghttp2 ALIAS nghttp2_static)
+    else()
+        message(FATAL_ERROR "libnghttp2{,_static} cmake target not found, don't know how to link")
+    endif()
 endif()
diff --git a/cmake/modules/Findyaml-cpp.cmake b/cmake/modules/Findyaml-cpp.cmake
index 042f615f3196..3e10058d8c40 100644
--- a/cmake/modules/Findyaml-cpp.cmake
+++ b/cmake/modules/Findyaml-cpp.cmake
@@ -7,6 +7,10 @@ _userver_module_begin(
     yaml-cpp
     PACMAN_NAMES
     yaml-cpp
+
+    CPM_NAME yaml-cpp
+    CPM_GITHUB_REPOSITORY jbeder/yaml-cpp
+    CPM_GIT_TAG yaml-cpp-0.7.0
 )
 
 _userver_module_find_include(NAMES yaml-cpp/yaml.h yaml-cpp/node.h PATH_SUFFIXES include)
diff --git a/cmake/modules/Findzstd.cmake b/cmake/modules/Findzstd.cmake
index 29b5865ab2c2..13ef2650f5e5 100644
--- a/cmake/modules/Findzstd.cmake
+++ b/cmake/modules/Findzstd.cmake
@@ -9,6 +9,8 @@ _userver_module_begin(
     libzstd-dev
     PACMAN_NAMES
     zstd
+
+    # TODO: CPM
 )
 
 _userver_module_find_include(NAMES zdict.h zstd.h zstd_errors.h PATH_SUFFIXES include)
@@ -18,7 +20,11 @@ _userver_module_find_library(NAMES zstd PATH_SUFFIXES lib)
 _userver_module_end()
 
 if(NOT TARGET zstd::zstd)
-    add_library(zstd::zstd ALIAS zstd)
+    if(TARGET libzstd_static)
+        add_library(zstd::zstd ALIAS libzstd_static)
+    else()
+        add_library(zstd::zstd ALIAS zstd)
+    endif()
 endif()
 if(NOT TARGET ZSTD::ZSTD)
     add_library(ZSTD::ZSTD ALIAS zstd)
diff --git a/conanfile.py b/conanfile.py
index 5c084f9db151..d0ba854da730 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,7 +1,6 @@
 # pylint: disable=no-member
 import os
 import platform
-import re
 
 from conan import ConanFile
 from conan.errors import ConanInvalidConfiguration
@@ -12,6 +11,7 @@
 from conan.tools.files import copy
 from conan.tools.files import load
 from conan.tools.scm import Git
+from conan.tools.system import package_manager
 
 required_conan_version = '>=2.8.0'  # pylint: disable=invalid-name
 
@@ -104,13 +104,11 @@ def set_version(self):
             self,
             os.path.join(
                 os.path.dirname(os.path.realpath(__file__)),
-                'cmake/GetUserverVersion.cmake',
+                'version.txt',
             ),
         )
-        major_version = re.search(r'set\(USERVER_MAJOR_VERSION (.*)\)', content).group(1).strip()
-        minor_version = re.search(r'set\(USERVER_MINOR_VERSION (.*)\)', content).group(1).strip()
 
-        self.version = f'{major_version}.{minor_version}'  # pylint: disable=attribute-defined-outside-init
+        self.version = content.strip()  # pylint: disable=attribute-defined-outside-init
 
     def layout(self):
         cmake_layout(self)
@@ -152,7 +150,9 @@ def requirements(self):
             )
             self.requires('googleapis/cci.20230501')
         if self.options.with_postgresql:
-            self.requires('libpq/14.5')
+            # `run=True` required to find `pg_config` binary during `psycopg2` python module build
+            # without system package. We use system package.
+            self.requires('libpq/14.9')
         if self.options.with_mongodb or self.options.with_kafka:
             self.requires('cyrus-sasl/2.1.28')
         if self.options.with_mongodb:
@@ -249,6 +249,12 @@ def generate(self):
         CMakeDeps(self).generate()
 
     def build(self):
+        # pg_config is required to build psycopg2 from source without system package.
+        # However, this approach fails on later stage, when venv for tests is built.
+        # libpq = self.dependencies["libpq"]
+        # if libpq:
+        #     os.environ["PATH"] = os.environ["PATH"] + ":" + libpq.package_folder+ "/bin"
+
         cmake = CMake(self)
         cmake.configure()
         cmake.build()
@@ -261,3 +267,12 @@ def package_info(self):
         # https://docs.conan.io/2/examples/tools/cmake/cmake_toolchain/use_package_config_cmake.html
         self.cpp_info.set_property('cmake_find_mode', 'none')
         self.cpp_info.builddirs.append(os.path.join('lib', 'cmake', 'userver'))
+
+    def system_requirements(self):
+        if self.options.with_postgresql:
+            # pg_config is required to build psycopg2 python module from source at
+            # testsuite venv creation during functional testing of user code.
+            package_manager.Apt(self).install(['libpq-dev'])
+            package_manager.Yum(self).install(['libpq-devel'])
+            package_manager.PacMan(self).install(['libpq-dev'])
+            package_manager.Zypper(self).install(['libpq-devel'])
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 8cb558eb936d..659b6194f1db 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -37,16 +37,13 @@ file(GLOB_RECURSE INTERNAL_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/internal/*.cpp
 
 list(REMOVE_ITEM SOURCES ${INTERNAL_SOURCES})
 
-find_package(Boost REQUIRED CONFIG COMPONENTS program_options filesystem locale regex iostreams)
 find_package_required(ZLIB "zlib1g-dev")
 
 find_package(Iconv REQUIRED)
 
-_userver_macos_set_default_dir(OPENSSL_ROOT_DIR "brew;--prefix;openssl")
-find_package_required(OpenSSL "libssl-dev")
 
-find_package(libnghttp2 REQUIRED)
 find_package(libev REQUIRED)
+find_package(libnghttp2 REQUIRED)
 
 if(USERVER_CONAN)
     find_package(c-ares REQUIRED)
@@ -98,15 +95,26 @@ endif()
 
 target_link_libraries(
     ${PROJECT_NAME}
-    PUBLIC userver-universal Boost::locale CURL::libcurl
-    PRIVATE Boost::filesystem
-            Boost::program_options
-            Boost::iostreams
-            Iconv::Iconv
-            OpenSSL::Crypto
-            OpenSSL::SSL
-            ZLIB::ZLIB
+    PUBLIC
+	userver-universal
+	Boost::locale
+	CURL::libcurl
+    PRIVATE
+	Boost::filesystem
+	Boost::program_options
+	Boost::iostreams
+	Iconv::Iconv
+	OpenSSL::SSL
+	OpenSSL::Crypto
+	ZLIB::ZLIB
 )
+if(TARGET Boost::endian)
+    # Boost from CPM
+    target_link_libraries(
+	${PROJECT_NAME}
+	PUBLIC userver-universal Boost::endian Boost::lockfree
+    )
+endif()
 
 add_subdirectory(${USERVER_THIRD_PARTY_DIRS}/llhttp llhttp)
 
@@ -130,17 +138,24 @@ if(CMAKE_SYSTEM_NAME MATCHES "Darwin" AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64"
     endif()
 endif()
 
-option(USERVER_FEATURE_UBOOST_CORO "Use vendored boost context instead of a system one"
-       "${USERVER_UBOOST_CORO_DEFAULT}"
-)
+if("${Boost_VERSION_STRING}" VERSION_LESS "1.88.0")
+    option(USERVER_FEATURE_UBOOST_CORO "Use vendored boost context instead of a system one"
+           "${USERVER_UBOOST_CORO_DEFAULT}"
+    )
+else()
+    message(STATUS "Found a modern Boost version (${Boost_VERSION_STRING}), not using vendored Boost::context and Boost::coroutine2")
+    set(USERVER_FEATURE_UBOOST_CORO OFF)
+endif()
 
 if(USERVER_FEATURE_UBOOST_CORO)
     add_subdirectory(${USERVER_THIRD_PARTY_DIRS}/uboost_coro uboost_coro_build)
     target_link_libraries(${PROJECT_NAME} PRIVATE userver-uboost-coro)
     target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/uboost_coro/include)
 else()
-    find_package(Boost REQUIRED CONFIG COMPONENTS context coroutine)
     target_link_libraries(${PROJECT_NAME} PRIVATE Boost::context)
+    if(NOT USERVER_CONAN AND (TARGET Boost::coroutine2))
+        target_link_libraries(${PROJECT_NAME} PRIVATE Boost::coroutine2)
+    endif()
     target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/sys_coro/include)
 endif()
 
@@ -319,3 +334,5 @@ _userver_directory_install(
     DIRECTORY "${USERVER_ROOT_DIR}/testsuite/include_tests/"
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/userver/testsuite/include_tests/
 )
+
+_userver_install_component(MODULE core DEPENDS chaotic)
diff --git a/core/dynamic_configs/EGRESS_HTTP_PROXY_ENABLED.yaml b/core/dynamic_configs/EGRESS_HTTP_PROXY_ENABLED.yaml
new file mode 100644
index 000000000000..35ff566e5c41
--- /dev/null
+++ b/core/dynamic_configs/EGRESS_HTTP_PROXY_ENABLED.yaml
@@ -0,0 +1,4 @@
+default: false
+description: ''
+schema:
+    type: boolean
diff --git a/core/dynamic_configs/EGRESS_NO_PROXY_TARGETS.yaml b/core/dynamic_configs/EGRESS_NO_PROXY_TARGETS.yaml
new file mode 100644
index 000000000000..24e07b0c0514
--- /dev/null
+++ b/core/dynamic_configs/EGRESS_NO_PROXY_TARGETS.yaml
@@ -0,0 +1,15 @@
+default:
+    targets: []
+description: ''
+schema:
+    type: object
+    additionalProperties: false
+    required:
+      - targets
+    properties:
+        targets:
+            type: array
+            items:
+                type: string
+                pattern: '^([^\/]+)(:\d+)?$'
+            x-taxi-cpp-type: std::unordered_set
diff --git a/core/functional_tests/CMakeLists.txt b/core/functional_tests/CMakeLists.txt
index 7b06961cb8d6..fca7a32ff14d 100644
--- a/core/functional_tests/CMakeLists.txt
+++ b/core/functional_tests/CMakeLists.txt
@@ -29,6 +29,9 @@ add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-static-service)
 add_subdirectory(tracing)
 add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-tracing)
 
+add_subdirectory(trx_tracker)
+add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-trx-tracker)
+
 add_subdirectory(uctl)
 add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-uctl)
 
diff --git a/core/functional_tests/metrics/tests/static/metrics_values.txt b/core/functional_tests/metrics/tests/static/metrics_values.txt
index 694908a4c240..2b11b4aa5eb9 100644
--- a/core/functional_tests/metrics/tests/static/metrics_values.txt
+++ b/core/functional_tests/metrics/tests/static/metrics_values.txt
@@ -4,7 +4,7 @@ alerts.config_parse_error:	GAUGE	0
 alerts.dynamic_debug_invalid_location:	GAUGE	0
 alerts.log_reopening_error:	GAUGE	0
 
-# Info on cahces
+# Info on caches
 cache.any.documents.parse_failures.v2: cache_name=dynamic-config-client-updater	RATE	0
 cache.any.documents.parse_failures.v2: cache_name=sample-cache	RATE	0
 cache.any.documents.parse_failures: cache_name=dynamic-config-client-updater	GAUGE	0
@@ -114,7 +114,13 @@ engine.coro-pool.stack-usage.is-monitor-active:	GAUGE	0
 engine.coro-pool.stack-usage.max-usage-percent:	GAUGE	0
 engine.ev-threads.cpu-load-percent: ev_thread_name=event-worker_0	GAUGE	0
 engine.ev-threads.cpu-load-percent: ev_thread_name=event-worker_1	GAUGE	0
+
+# Duration of time the service is running
 engine.load-ms:	GAUGE	0
+
+# Service startup took this amount of time 
+engine.pre-load-ms:	GAUGE	0
+
 engine.task-processors-load-percent: task_processor=fs-task-processor, thread=0	GAUGE	0
 engine.task-processors-load-percent: task_processor=fs-task-processor, thread=1	GAUGE	0
 engine.task-processors-load-percent: task_processor=main-task-processor, thread=0	GAUGE	0
@@ -188,6 +194,10 @@ engine.task-processors.worker-threads: task_processor=fs-task-processor	GAUGE	0
 engine.task-processors.worker-threads: task_processor=main-task-processor	GAUGE	0
 engine.task-processors.worker-threads: task_processor=monitor-task-processor	GAUGE	0
 
+# How many times heavy operations (like http calls) were called with open DB transaction
+# See userver/utils/trx_tracker.hpp
+engine.heavy-operations-in-transactions:	RATE	0
+
 # How long the engine is running. It does not account components state (i.e. `components::State::IsAnyComponentInFatalState()`),
 # the engine could be fine, the components could be in components::ComponentHealth::kFatal state.
 engine.uptime-seconds:	GAUGE	0
diff --git a/core/functional_tests/trx_tracker/CMakeLists.txt b/core/functional_tests/trx_tracker/CMakeLists.txt
new file mode 100644
index 000000000000..d01c6df66c24
--- /dev/null
+++ b/core/functional_tests/trx_tracker/CMakeLists.txt
@@ -0,0 +1,8 @@
+project(userver-core-tests-trx-tracker CXX)
+
+file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*pp")
+add_executable(${PROJECT_NAME} ${SOURCES} "main.cpp")
+target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
+target_link_libraries(${PROJECT_NAME} userver::core)
+
+userver_chaos_testsuite_add()
diff --git a/core/functional_tests/trx_tracker/main.cpp b/core/functional_tests/trx_tracker/main.cpp
new file mode 100644
index 000000000000..9d946e30ed59
--- /dev/null
+++ b/core/functional_tests/trx_tracker/main.cpp
@@ -0,0 +1,21 @@
+#include <userver/clients/dns/component.hpp>
+#include <userver/clients/http/component.hpp>
+#include <userver/components/minimal_server_component_list.hpp>
+#include <userver/server/handlers/server_monitor.hpp>
+#include <userver/server/handlers/tests_control.hpp>
+#include <userver/testsuite/testsuite_support.hpp>
+#include <userver/utest/using_namespace_userver.hpp>
+#include <userver/utils/daemon_run.hpp>
+
+#include "src/handler.hpp"
+
+int main(int argc, char* argv[]) {
+    const auto component_list = components::MinimalServerComponentList()
+                                    .Append<handlers::Handler>()
+                                    .Append<server::handlers::ServerMonitor>()
+                                    .Append<clients::dns::Component>()
+                                    .Append<components::HttpClient>()
+                                    .Append<components::TestsuiteSupport>()
+                                    .Append<server::handlers::TestsControl>();
+    return utils::DaemonMain(argc, argv, component_list);
+}
diff --git a/core/functional_tests/trx_tracker/src/handler.hpp b/core/functional_tests/trx_tracker/src/handler.hpp
new file mode 100644
index 000000000000..c4f2018f6e19
--- /dev/null
+++ b/core/functional_tests/trx_tracker/src/handler.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <userver/server/handlers/http_handler_base.hpp>
+#include <userver/testsuite/testpoint.hpp>
+#include <userver/utest/using_namespace_userver.hpp>
+#include <userver/utils/trx_tracker.hpp>
+
+namespace handlers {
+
+class Handler final : public server::handlers::HttpHandlerBase {
+public:
+    static constexpr std::string_view kName = "handler";
+
+    Handler(const components::ComponentConfig& config, const components::ComponentContext& context)
+        : HttpHandlerBase(config, context) {}
+
+    std::string HandleRequestThrow(const server::http::HttpRequest& /*request*/, server::request::RequestContext&)
+        const override {
+        utils::trx_tracker::TransactionLock lock;
+        lock.Lock();
+        // Tespoint shouldn't actually trigger heavy operation
+        // in transaction check despite being implemented
+        // using http request
+        TESTPOINT("tp", formats::json::Value{});
+        // Other heavy operation in transaction check
+        // should actually trigger
+        utils::trx_tracker::CheckNoTransactions();
+        return "";
+    }
+};
+
+}  // namespace handlers
diff --git a/core/functional_tests/trx_tracker/static_config.yaml b/core/functional_tests/trx_tracker/static_config.yaml
new file mode 100644
index 000000000000..ac3d0a481d07
--- /dev/null
+++ b/core/functional_tests/trx_tracker/static_config.yaml
@@ -0,0 +1,53 @@
+components_manager:
+    task_processors:
+        main-task-processor:
+            worker_threads: 4
+
+        fs-task-processor:
+            worker_threads: 2
+
+        monitor-task-processor:
+            thread_name: mon-worker
+            worker_threads: 2
+
+    default_task_processor: main-task-processor
+
+    components:
+        logging:
+            fs-task-processor: fs-task-processor
+            loggers:
+                default:
+                    file_path: '@stderr'
+                    level: debug
+                    overflow_behavior: discard
+
+        server:
+            listener:
+                port: 8080
+                task_processor: main-task-processor
+            listener-monitor:
+                port: 8081
+                task_processor: main-task-processor
+
+        handler:
+            path: /handler
+            method: GET
+            task_processor: main-task-processor
+
+        handler-server-monitor:
+            path: /service/monitor
+            method: GET
+            task_processor: monitor-task-processor
+
+        http-client:
+            fs-task-processor: fs-task-processor
+            user-agent: $server-name
+            user-agent#fallback: 'userver-based-service 1.0'
+        testsuite-support:
+        tests-control:
+            path: /tests/{action}
+            method: POST
+            task_processor: main-task-processor
+            testpoint-timeout: 10s
+            testpoint-url: $mockserver/testpoint
+            throttling_enabled: false
diff --git a/core/functional_tests/trx_tracker/tests/conftest.py b/core/functional_tests/trx_tracker/tests/conftest.py
new file mode 100644
index 000000000000..699ab947e59b
--- /dev/null
+++ b/core/functional_tests/trx_tracker/tests/conftest.py
@@ -0,0 +1 @@
+pytest_plugins = ['pytest_userver.plugins.core']
diff --git a/core/functional_tests/trx_tracker/tests/test_ignore_testpoint.py b/core/functional_tests/trx_tracker/tests/test_ignore_testpoint.py
new file mode 100644
index 000000000000..8ce9dd87d4ee
--- /dev/null
+++ b/core/functional_tests/trx_tracker/tests/test_ignore_testpoint.py
@@ -0,0 +1,18 @@
+HEAVY_OPERAIONS_IN_TRANSACTIONS = 'engine.heavy-operations-in-transactions'
+
+
+async def test_trx_tracker_ignore_testpoint(service_client, monitor_client, testpoint):
+    @testpoint('tp')
+    def tp(data):
+        pass
+
+    response = await service_client.get('/handler')
+    assert response.status == 200
+
+    # Check that testpoint was called
+    assert tp.times_called == 1
+
+    # Check that only manual heavy operation in
+    # transaction check was triggered
+    metrics = await monitor_client.metrics(prefix=HEAVY_OPERAIONS_IN_TRANSACTIONS)
+    assert metrics.value_at(path=HEAVY_OPERAIONS_IN_TRANSACTIONS) == 1
diff --git a/core/functional_tests/websocket/tests/test_websocket.py b/core/functional_tests/websocket/tests/test_websocket.py
index 004a95af7c76..56f0eb2ca449 100644
--- a/core/functional_tests/websocket/tests/test_websocket.py
+++ b/core/functional_tests/websocket/tests/test_websocket.py
@@ -16,6 +16,19 @@ async def test_echo(websocket_client):
         assert response == 'hello'
 
 
+async def test_echo_with_continuation(websocket_client):
+    async with websocket_client.get('chat') as chat:
+        # Send first fragment (not final, text frame)
+        await chat.write_frame(fin=False, opcode=0x1, data=b'First')
+        # Send intermediate fragment (not final, continuation frame)
+        await chat.write_frame(fin=False, opcode=0x0, data=b' second')
+        # Send last fragment (final, continuation frame)
+        await chat.write_frame(fin=True, opcode=0x0, data=b' third')
+
+        response = await chat.recv()
+        assert response == 'First second third'
+
+
 async def test_close_by_server(websocket_client):
     async with websocket_client.get('chat') as chat:
         await chat.send('close')
@@ -142,3 +155,28 @@ async def test_ping_pong_close(websocket_client):
                 break
 
         assert connection_closed_by_ping
+
+
+async def test_upgrade_header_with_tab_then_reconnect(service_port):
+    reader, writer = await asyncio.open_connection('localhost', service_port)
+
+    # request with tab in Upgrade header
+    bad_request = (
+        'GET /chat HTTP/1.1\r\n'
+        'Sec-WebSocket-Version: 13\r\n'
+        'Sec-WebSocket-Key: fQU/VaAZ3+lpmSjWKevurQ==\r\n'
+        'Connection: Upgrade\r\n'
+        'Upgrade:\twebsocket\r\n'
+        '\r\n'
+    )
+
+    writer.write(bad_request.encode('ascii'))
+    await writer.drain()
+    writer.close()
+    await writer.wait_closed()
+
+    # 2. Check new connection can be established
+    async with websockets.connect(f'ws://localhost:{service_port}/chat') as chat:
+        await chat.send('ping')
+        resp = await chat.recv()
+        assert resp == 'ping'
diff --git a/core/include/userver/cache/expirable_lru_cache.hpp b/core/include/userver/cache/expirable_lru_cache.hpp
index 464466551743..5f23f0ccd7df 100644
--- a/core/include/userver/cache/expirable_lru_cache.hpp
+++ b/core/include/userver/cache/expirable_lru_cache.hpp
@@ -121,6 +121,8 @@ class ExpirableLruCache final {
      */
     std::optional<Value> GetOptionalNoUpdate(const Key& key);
 
+    std::optional<impl::ExpirableValue<Value>> GetOptionalNoUpdateWithLastUpdateTime(const Key& key);
+
     void Put(const Key& key, const Value& value);
 
     void Put(const Key& key, Value&& value);
@@ -286,21 +288,28 @@ std::optional<Value> ExpirableLruCache<Key, Value, Hash, Equal>::GetOptionalUnex
 }
 
 template <typename Key, typename Value, typename Hash, typename Equal>
-std::optional<Value> ExpirableLruCache<Key, Value, Hash, Equal>::GetOptionalNoUpdate(const Key& key) {
-    auto now = utils::datetime::SteadyNow();
-    auto old_value = lru_.Get(key);
-
+std::optional<impl::ExpirableValue<Value>>
+ExpirableLruCache<Key, Value, Hash, Equal>::GetOptionalNoUpdateWithLastUpdateTime(const Key& key) {
+    const auto now = utils::datetime::SteadyNow();
+    const auto old_value = lru_.Get(key);
     if (old_value) {
         if (!IsExpired(old_value->update_time, now)) {
             impl::CacheHit(stats_);
-
-            return old_value->value;
+            return old_value;
         } else {
             impl::CacheStale(stats_);
         }
     }
     impl::CacheMiss(stats_);
+    return std::nullopt;
+}
 
+template <typename Key, typename Value, typename Hash, typename Equal>
+std::optional<Value> ExpirableLruCache<Key, Value, Hash, Equal>::GetOptionalNoUpdate(const Key& key) {
+    auto value_with_update_time = GetOptionalNoUpdateWithLastUpdateTime(key);
+    if (value_with_update_time.has_value()) {
+        return value_with_update_time->value;
+    }
     return std::nullopt;
 }
 
diff --git a/core/include/userver/clients/http/client.hpp b/core/include/userver/clients/http/client.hpp
index eefe720fcdd0..032334c09566 100644
--- a/core/include/userver/clients/http/client.hpp
+++ b/core/include/userver/clients/http/client.hpp
@@ -62,7 +62,11 @@ class DestinationStatistics;
 /// @snippet clients/http/client_test.cpp  Sample HTTP Client usage
 class Client final {
 public:
-    Client(ClientSettings settings, engine::TaskProcessor& fs_task_processor, impl::PluginPipeline&& plugin_pipeline);
+    Client(
+        ClientSettings settings,
+        engine::TaskProcessor& fs_task_processor,
+        std::vector<utils::NotNull<clients::http::Plugin*>> plugins
+    );
 
     ~Client();
 
@@ -172,7 +176,7 @@ class Client final {
 
     clients::dns::Resolver* resolver_{nullptr};
     utils::NotNull<const tracing::TracingManagerBase*> tracing_manager_;
-    impl::PluginPipeline plugin_pipeline_;
+    std::vector<utils::NotNull<clients::http::Plugin*>> plugins_;
 };
 
 }  // namespace clients::http
diff --git a/core/include/userver/clients/http/plugin.hpp b/core/include/userver/clients/http/plugin.hpp
index 7d0f908af1e8..72369f656cbc 100644
--- a/core/include/userver/clients/http/plugin.hpp
+++ b/core/include/userver/clients/http/plugin.hpp
@@ -91,7 +91,7 @@ namespace impl {
 
 class PluginPipeline final {
 public:
-    PluginPipeline(const std::vector<utils::NotNull<Plugin*>>& plugins);
+    explicit PluginPipeline(const std::vector<utils::NotNull<Plugin*>>& plugins);
 
     void HookPerformRequest(RequestState& request);
 
@@ -104,7 +104,7 @@ class PluginPipeline final {
     bool HookOnRetry(RequestState& request);
 
 private:
-    const std::vector<utils::NotNull<Plugin*>> plugins_;
+    utils::NotNull<const std::vector<utils::NotNull<Plugin*>>*> plugins_;
 };
 
 }  // namespace impl
diff --git a/core/include/userver/clients/http/request.hpp b/core/include/userver/clients/http/request.hpp
index 4dc922a243e2..687956445035 100644
--- a/core/include/userver/clients/http/request.hpp
+++ b/core/include/userver/clients/http/request.hpp
@@ -89,7 +89,7 @@ class Request final {
         RequestStats&& req_stats,
         const std::shared_ptr<DestinationStatistics>& dest_stats,
         clients::dns::Resolver* resolver,
-        impl::PluginPipeline& plugin_pipeline,
+        const std::vector<utils::NotNull<clients::http::Plugin*>>& plugins,
         const tracing::TracingManagerBase& tracing_manager
     );
     /// @endcond
@@ -250,6 +250,9 @@ class Request final {
         return *this;
     }
 
+    /// Override list of plugins from @ref components::HttpClient for specific request
+    Request& SetPluginsList(const std::vector<utils::NotNull<Plugin*>>& plugins) &;
+
     /// Override log URL. Useful for "there's a secret in the query".
     /// @warning The query might be logged by other intermediate HTTP agents
     ///          (nginx, L7 balancer, etc.).
diff --git a/core/include/userver/clients/http/response_future.hpp b/core/include/userver/clients/http/response_future.hpp
index 49015207f1a4..13d12d4ecf77 100644
--- a/core/include/userver/clients/http/response_future.hpp
+++ b/core/include/userver/clients/http/response_future.hpp
@@ -13,6 +13,7 @@
 #include <userver/engine/deadline.hpp>
 #include <userver/engine/future.hpp>
 #include <userver/engine/impl/context_accessor.hpp>
+#include <userver/utils/impl/source_location.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -44,10 +45,10 @@ class ResponseFuture final {
     /// @brief Stops the current task execution until the request finishes
     /// @throws clients::http::CancelException if the current task is being cancelled
     /// @returns std::future_status::ready or std::future_status::timeout
-    std::future_status Wait();
+    std::future_status Wait(utils::impl::SourceLocation location = utils::impl::SourceLocation::Current());
 
     /// @brief Wait for the response and return it
-    std::shared_ptr<Response> Get();
+    std::shared_ptr<Response> Get(utils::impl::SourceLocation location = utils::impl::SourceLocation::Current());
 
     void SetCancellationPolicy(CancellationPolicy cp);
 
diff --git a/core/include/userver/components/manager_controller_component.hpp b/core/include/userver/components/manager_controller_component.hpp
index 5a5458b5fb54..5a3bf391fa0d 100644
--- a/core/include/userver/components/manager_controller_component.hpp
+++ b/core/include/userver/components/manager_controller_component.hpp
@@ -49,6 +49,7 @@ class Manager;
 /// preheat_stacktrace_collector | whether to collect a dummy stacktrace at server start up (usable to avoid loading debug info at random point at runtime) | true
 /// userver_experiments.*NAME* | whether to enable certain userver experiments; these are gradually enabled by userver team, for internal use only | false
 /// graceful_shutdown_interval | at shutdown, first hang for this duration with /ping 5xx to give the balancer a chance to redirect new requests to other hosts | 0s
+/// enable_trx_tracker | Enable checking of heavy operations (like http calls) while having active database transactions. | true
 ///
 /// ## Static task_processor options:
 /// Name | Description | Default value
diff --git a/core/include/userver/concurrent/queue.hpp b/core/include/userver/concurrent/queue.hpp
index 2d7b4d820893..6ae1853dda92 100644
--- a/core/include/userver/concurrent/queue.hpp
+++ b/core/include/userver/concurrent/queue.hpp
@@ -278,14 +278,12 @@ class GenericQueue final : public std::enable_shared_from_this<GenericQueue<T, Q
     template <typename Token>
     [[nodiscard]] bool Push(Token& token, T&& value, engine::Deadline deadline) {
         const std::size_t value_size = QueuePolicy::GetElementSize(value);
-        UASSERT(value_size > 0);
         return producer_side_.Push(token, std::move(value), deadline, value_size);
     }
 
     template <typename Token>
     [[nodiscard]] bool PushNoblock(Token& token, T&& value) {
         const std::size_t value_size = QueuePolicy::GetElementSize(value);
-        UASSERT(value_size > 0);
         return producer_side_.PushNoblock(token, std::move(value), value_size);
     }
 
diff --git a/core/include/userver/congestion_control/component.hpp b/core/include/userver/congestion_control/component.hpp
index b1a62f00a4c9..dae0aa80b3b3 100644
--- a/core/include/userver/congestion_control/component.hpp
+++ b/core/include/userver/congestion_control/component.hpp
@@ -14,6 +14,8 @@ USERVER_NAMESPACE_BEGIN
 
 namespace congestion_control {
 
+class Controller;
+
 // clang-format off
 
 /// @ingroup userver_components
@@ -52,6 +54,7 @@ class Component final : public components::ComponentBase {
 
     server::congestion_control::Limiter& GetServerLimiter();
     server::congestion_control::Sensor& GetServerSensor();
+    const congestion_control::Controller& GetServerController() const;
 
 private:
     void OnConfigUpdate(const dynamic_config::Snapshot& cfg);
diff --git a/core/include/userver/dump/aggregates.hpp b/core/include/userver/dump/aggregates.hpp
index c22c4b86a89e..bfe2652be03f 100644
--- a/core/include/userver/dump/aggregates.hpp
+++ b/core/include/userver/dump/aggregates.hpp
@@ -33,7 +33,7 @@ constexpr bool AreAllDumpable(std::index_sequence<Indices...>) {
 
 template <typename T>
 constexpr bool IsDumpableAggregate() {
-    if constexpr (std::is_aggregate_v<T> && !meta::kIsDetected<IsNotDumpedAggregate, T>) {
+    if constexpr (std::is_aggregate_v<T> && !meta::IsDetected<IsNotDumpedAggregate, T>) {
         constexpr auto kSize = boost::pfr::tuple_size_v<T>;
         static_assert(
             AreAllDumpable<T>(std::make_index_sequence<kSize>{}),
diff --git a/core/include/userver/dump/meta_containers.hpp b/core/include/userver/dump/meta_containers.hpp
index 0c4b64dc6231..ba0c08f9ebba 100644
--- a/core/include/userver/dump/meta_containers.hpp
+++ b/core/include/userver/dump/meta_containers.hpp
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include <userver/dump/meta.hpp>
+#include <userver/utils/meta.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -53,7 +54,7 @@ using InsertResult = decltype(dump::Insert(std::declval<T&>(), std::declval<meta
 /// Check if a range is a container
 template <typename T>
 inline constexpr bool kIsContainer = meta::kIsRange<T> && std::is_default_constructible_v<T> && meta::kIsSizable<T> &&
-                                     meta::kIsDetected<impl::InsertResult, T>;
+                                     meta::IsDetected<impl::InsertResult, T>;
 
 }  // namespace dump
 
diff --git a/core/include/userver/dynamic_config/source.hpp b/core/include/userver/dynamic_config/source.hpp
index 5106bbd23f6b..dde5e393a1a3 100644
--- a/core/include/userver/dynamic_config/source.hpp
+++ b/core/include/userver/dynamic_config/source.hpp
@@ -174,7 +174,7 @@ class Source final {
     /// the first time immediately invokes the function with the current config
     /// snapshot (this invocation will be executed synchronously).
     ///
-    /// @note Сallbacks occur only if one of the passed config is changed. This is
+    /// @note Callbacks occur only if one of the passed config is changed. This is
     /// true under any components::DynamicConfigClientUpdater options.
     ///
     /// @warning To use this function, configs must have the `operator==`.
diff --git a/core/include/userver/engine/io/tls_wrapper.hpp b/core/include/userver/engine/io/tls_wrapper.hpp
index f07d7163e4f8..6757b647f14d 100644
--- a/core/include/userver/engine/io/tls_wrapper.hpp
+++ b/core/include/userver/engine/io/tls_wrapper.hpp
@@ -8,6 +8,7 @@
 
 #include <userver/crypto/certificate.hpp>
 #include <userver/crypto/private_key.hpp>
+#include <userver/crypto/ssl_ctx.hpp>
 #include <userver/engine/deadline.hpp>
 #include <userver/engine/io/common.hpp>
 #include <userver/engine/io/socket.hpp>
@@ -40,13 +41,7 @@ class [[nodiscard]] TlsWrapper final : public RwBase {
     );
 
     /// Starts a TLS server on an opened socket
-    static TlsWrapper StartTlsServer(
-        Socket&& socket,
-        const crypto::CertificatesChain& cert_chain,
-        const crypto::PrivateKey& key,
-        Deadline deadline,
-        const std::vector<crypto::Certificate>& extra_cert_authorities = {}
-    );
+    static TlsWrapper StartTlsServer(Socket&& socket, const crypto::SslCtx& ctx, Deadline deadline);
 
     ~TlsWrapper() override;
 
@@ -72,6 +67,14 @@ class [[nodiscard]] TlsWrapper final : public RwBase {
     /// received any more, received bytes count otherwise.
     [[nodiscard]] size_t RecvSome(void* buf, size_t len, Deadline deadline);
 
+    /// @brief Receives up to len bytes from the socket
+    /// @returns
+    /// - nullopt on data absence
+    /// - optional{0} if socket is closed by peer.
+    /// - optional{data_bytes_available} otherwise,
+    ///    1 <= data_bytes_available <= len
+    [[nodiscard]] std::optional<size_t> RecvNoblock(void* buf, size_t len);
+
     /// @brief Receives exactly len bytes from the socket.
     /// @note Can return less than len if socket is closed by peer.
     [[nodiscard]] size_t RecvAll(void* buf, size_t len, Deadline deadline);
@@ -85,6 +88,14 @@ class [[nodiscard]] TlsWrapper final : public RwBase {
     ///   socket extraction if interrupted.
     [[nodiscard]] Socket StopTls(Deadline deadline);
 
+    /// @brief Receives up to len bytes from the stream
+    /// @returns
+    /// - nullopt on data absence
+    /// - optional{0} if socket is closed by peer.
+    /// - optional{data_bytes_available} otherwise,
+    ///    1 <= data_bytes_available <= len
+    [[nodiscard]] std::optional<size_t> ReadNoblock(void* buf, size_t len) override { return RecvNoblock(buf, len); }
+
     /// @brief Receives at least one byte from the socket.
     /// @returns 0 if connection is closed on one side and no data could be
     /// received any more, received bytes count otherwise.
diff --git a/core/include/userver/engine/task/task_with_result.hpp b/core/include/userver/engine/task/task_with_result.hpp
index 7cf2c79d00a8..5eee39c1cf11 100644
--- a/core/include/userver/engine/task/task_with_result.hpp
+++ b/core/include/userver/engine/task/task_with_result.hpp
@@ -54,11 +54,11 @@ class [[nodiscard]] TaskWithResult : public Task {
         EnsureValid();
 
         Wait();
+        const utils::FastScopeGuard invalidate([this]() noexcept { Invalidate(); });
         if (GetState() == State::kCancelled) {
             throw TaskCancelledException(CancellationReason());
         }
 
-        const utils::FastScopeGuard invalidate([this]() noexcept { Invalidate(); });
         return utils::impl::CastWrappedCall<T>(GetPayload()).Retrieve();
     }
 
diff --git a/core/include/userver/fs/temp_file.hpp b/core/include/userver/fs/temp_file.hpp
index 4b73ca2b14ed..6032bf8ae565 100644
--- a/core/include/userver/fs/temp_file.hpp
+++ b/core/include/userver/fs/temp_file.hpp
@@ -40,7 +40,7 @@ class TempFile final {
     TempFile() = delete;
     TempFile(TempFile&& other) noexcept = default;
     TempFile& operator=(TempFile&& other) noexcept = default;
-    ~TempFile();
+    ~TempFile() noexcept;
 
     /// Take ownership of an existing file
     static TempFile Adopt(std::string path, engine::TaskProcessor& fs_task_processor);
diff --git a/core/include/userver/logging/component.hpp b/core/include/userver/logging/component.hpp
index 48b63d8e72f3..1296e9c0808f 100644
--- a/core/include/userver/logging/component.hpp
+++ b/core/include/userver/logging/component.hpp
@@ -54,9 +54,9 @@ namespace components {
 ///
 /// ### Logs output
 /// You can specify where logs are written in the `file_path` option:
-/// - Use <tt>file_path: '@stdout'</tt> to write your logs to standard output stream;
-/// - Use <tt>file_path: '@stderr'</tt> to write your logs to standard error stream;
-/// - Use <tt>file_path: '@null'</tt> to suppress sending of logs;
+/// - Use <tt>file_path: '\@stdout'</tt> to write your logs to standard output stream;
+/// - Use <tt>file_path: '\@stderr'</tt> to write your logs to standard error stream;
+/// - Use <tt>file_path: '\@null'</tt> to suppress sending of logs;
 /// - Use <tt>file_path: /absolute/path/to/log/file.log</tt> to write your logs to file. Use USR1 signal or @ref server::handlers::OnLogRotate to reopen files after log rotation;
 /// - Use <tt>file_path: 'unix:/absolute/path/to/logs.sock'</tt> to write your logs to unix socket. Socket must be created before the service starts and closed by listener after service is shut down.
 ///
diff --git a/core/include/userver/logging/logger.hpp b/core/include/userver/logging/logger.hpp
index b46eca0a07d9..36061518e69c 100644
--- a/core/include/userver/logging/logger.hpp
+++ b/core/include/userver/logging/logger.hpp
@@ -44,13 +44,13 @@ LoggerPtr MakeStdoutLogger(const std::string& name, Format format, Level level =
 /// @see components::Logging
 LoggerPtr MakeFileLogger(const std::string& name, const std::string& path, Format format, Level level = Level::kInfo);
 
-namespace impl::default_ {
+namespace impl {
 
 bool DoShouldLog(Level) noexcept;
 
 void PrependCommonTags(TagWriter writer, Level logger_level);
 
-}  // namespace impl::default_
+}  // namespace impl
 
 }  // namespace logging
 
diff --git a/core/include/userver/server/component.hpp b/core/include/userver/server/component.hpp
index 4abddae83899..4823dbf03e72 100644
--- a/core/include/userver/server/component.hpp
+++ b/core/include/userver/server/component.hpp
@@ -38,7 +38,7 @@ namespace components {
 /// ---- | ----------- | -------------
 /// logger_access | set to logger name from components::Logging component to write access logs into it; do not set to avoid writing access logs  | -
 /// logger_access_tskv | set to logger name from components::Logging component to write access logs in TSKV format into it; do not set to avoid writing access logs | -
-/// max_response_size_in_flight | set it to the size of response in bytes and the component will drop bigger responses from handlers that allow throttling | -
+/// max_response_size_in_flight | drop incomming requests if the handler allows throttling and the size of waiting for send responses in bytes is greater than this value | -
 /// server-name | value to send in HTTP Server header | value from utils::GetUserverIdentifier()
 /// listener | (*required*) *see below* | -
 /// listener-monitor | *see below* | -
diff --git a/core/include/userver/server/handlers/auth/digest/auth_checker_base.hpp b/core/include/userver/server/handlers/auth/digest/auth_checker_base.hpp
index b7f326ca0422..63339a88237c 100644
--- a/core/include/userver/server/handlers/auth/digest/auth_checker_base.hpp
+++ b/core/include/userver/server/handlers/auth/digest/auth_checker_base.hpp
@@ -15,6 +15,7 @@
 #include <userver/rcu/rcu_map.hpp>
 #include <userver/server/handlers/auth/digest/auth_checker_settings.hpp>
 #include <userver/server/handlers/auth/digest/directives_parser.hpp>
+#include <userver/server/handlers/auth/digest/types.hpp>
 #include <userver/server/http/http_request.hpp>
 #include <userver/server/http/http_response.hpp>
 #include <userver/server/http/http_status.hpp>
@@ -45,9 +46,11 @@ class Hasher final {
     /// algorithm.
     std::string GetHash(std::string_view data) const;
 
+    /// @overload
+    std::string GetHash(std::initializer_list<std::string_view> data) const;
+
 private:
-    using HashAlgorithm = std::function<std::string(std::string_view, crypto::hash::OutputEncoding)>;
-    HashAlgorithm hash_algorithm_;
+    const HashAlgTypes hash_algorithm_;
     const SecdistConfig& secdist_config_;
 };
 
diff --git a/core/include/userver/server/handlers/exceptions.hpp b/core/include/userver/server/handlers/exceptions.hpp
index 0abfde4700ed..d9b9cf1cac97 100644
--- a/core/include/userver/server/handlers/exceptions.hpp
+++ b/core/include/userver/server/handlers/exceptions.hpp
@@ -107,13 +107,13 @@ template <typename T>
 using HasInternalMessage = decltype(std::declval<const T&>().GetInternalMessage());
 
 template <typename T>
-inline constexpr bool kHasInternalMessage = meta::kIsDetected<HasInternalMessage, T>;
+inline constexpr bool kHasInternalMessage = meta::IsDetected<HasInternalMessage, T>;
 
 template <typename T>
 using HasExternalBody = decltype(std::declval<const T&>().GetExternalBody());
 
 template <typename T>
-inline constexpr bool kHasExternalBody = meta::kIsDetected<HasExternalBody, T>;
+inline constexpr bool kHasExternalBody = meta::IsDetected<HasExternalBody, T>;
 
 template <typename T>
 inline constexpr bool kIsMessageBuilder = kHasExternalBody<T>;
@@ -121,7 +121,7 @@ inline constexpr bool kIsMessageBuilder = kHasExternalBody<T>;
 template <typename T>
 struct MessageExtractor {
     static_assert(
-        meta::kIsDetected<HasExternalBody, T>,
+        meta::IsDetected<HasExternalBody, T>,
         "Please use your message builder to build external body for "
         "your error. See server::handlers::CustomHandlerException "
         "for more info"
@@ -134,7 +134,7 @@ struct MessageExtractor {
     }
 
     std::string GetServiceCode() const {
-        if constexpr (meta::kIsDetected<HasServiceCode, T>) {
+        if constexpr (meta::IsDetected<HasServiceCode, T>) {
             return builder.GetServiceCode();
         } else {
             return std::string{};
@@ -171,17 +171,17 @@ struct CustomHandlerExceptionData final {
     formats::json::Value details;
 
 private:
-    void Apply(HandlerErrorCode handler_code_) { handler_code = handler_code_; }
+    void Apply(HandlerErrorCode l_handler_code) { handler_code = l_handler_code; }
 
-    void Apply(ServiceErrorCode service_code_) { service_code = std::move(service_code_.body); }
+    void Apply(ServiceErrorCode l_service_code) { service_code = std::move(l_service_code.body); }
 
-    void Apply(InternalMessage internal_message_) { internal_message = std::move(internal_message_.body); }
+    void Apply(InternalMessage l_internal_message) { internal_message = std::move(l_internal_message.body); }
 
-    void Apply(ExternalBody external_body_) { external_body = std::move(external_body_.body); }
+    void Apply(ExternalBody l_external_body) { external_body = std::move(l_external_body.body); }
 
-    void Apply(ExtraHeaders headers_) { headers = std::move(headers_.headers); }
+    void Apply(ExtraHeaders l_headers) { headers = std::move(l_headers.headers); }
 
-    void Apply(formats::json::Value details_) { details = std::move(details_); }
+    void Apply(formats::json::Value l_details) { details = std::move(l_details); }
 
     template <typename MessageBuilder>
     void Apply(MessageBuilder&& builder) {
diff --git a/core/include/userver/server/http/http_request.hpp b/core/include/userver/server/http/http_request.hpp
index 9cd50ac8a8e0..df636433c151 100644
--- a/core/include/userver/server/http/http_request.hpp
+++ b/core/include/userver/server/http/http_request.hpp
@@ -62,10 +62,15 @@ class HttpRequest final {
     /// @return Minor version of HTTP. For example, for HTTP 1.0 it returns 0
     int GetHttpMinor() const;
 
-    /// @return Request URL
+    /// @brief Get HTTP request target as provided by the client (see
+    /// https://www.rfc-editor.org/rfc/rfc7230#section-5.3). May contain the whole URL, but usually it consists of path
+    /// and query string.
     const std::string& GetUrl() const;
 
-    /// @return Request path
+    /// @brief Get the path part of HTTP request URL.
+    ///
+    /// Unlike @ref server::handlers::HandlerConfig::path, path parameters are not replaced with placeholders, this is
+    /// the original highly cardinal path.
     const std::string& GetRequestPath() const;
 
     /// @cond
diff --git a/core/include/userver/server/request/response_base.hpp b/core/include/userver/server/request/response_base.hpp
index ad2bacf0be69..3c438c64baca 100644
--- a/core/include/userver/server/request/response_base.hpp
+++ b/core/include/userver/server/request/response_base.hpp
@@ -52,23 +52,23 @@ namespace server::request {
 
 class ResponseDataAccounter final {
 public:
-    void StartRequest(size_t size, std::chrono::steady_clock::time_point create_time);
+    void StartRequest(std::size_t size, std::chrono::steady_clock::time_point create_time);
 
-    void StopRequest(size_t size, std::chrono::steady_clock::time_point create_time);
+    void StopRequest(std::size_t size, std::chrono::steady_clock::time_point create_time);
 
-    size_t GetCurrentLevel() const { return current_; }
+    std::size_t GetPendingResponsesSizeInBytes() const { return pending_responses_size_in_bytes_; }
 
-    size_t GetMaxLevel() const { return max_; }
+    std::size_t GetMaxPendingResponsesSizeInBytes() const { return max_pending_responses_size_in_bytes_; }
 
-    void SetMaxLevel(size_t size) { max_ = size; }
+    void SetMaxPendingResponsesSizeInBytes(size_t size) { max_pending_responses_size_in_bytes_ = size; }
 
     std::chrono::milliseconds GetAvgRequestTime() const;
 
 private:
-    std::atomic<size_t> current_{0};
-    std::atomic<size_t> max_{std::numeric_limits<size_t>::max()};
-    concurrent::StripedCounter count_;
-    concurrent::StripedCounter time_sum_;
+    std::atomic<std::size_t> pending_responses_size_in_bytes_{0};
+    std::atomic<std::size_t> max_pending_responses_size_in_bytes_{std::numeric_limits<std::size_t>::max()};
+    concurrent::StripedCounter pending_responses_count_{};
+    concurrent::StripedCounter time_sum_{};
 };
 
 // TODO: merge with HttpResponse
diff --git a/core/include/userver/server/server.hpp b/core/include/userver/server/server.hpp
index 347e22ea00bc..8d3e48640383 100644
--- a/core/include/userver/server/server.hpp
+++ b/core/include/userver/server/server.hpp
@@ -68,7 +68,7 @@ class Server final : public congestion_control::Limitee, public congestion_contr
     std::uint64_t GetTotalRequests() const override;
 
 private:
-    std::unique_ptr<ServerImpl> pimpl;
+    std::unique_ptr<ServerImpl> pimpl_;
 };
 
 }  // namespace server
diff --git a/core/include/userver/storages/query.hpp b/core/include/userver/storages/query.hpp
index adac7e46db82..5ef52ddbb295 100644
--- a/core/include/userver/storages/query.hpp
+++ b/core/include/userver/storages/query.hpp
@@ -51,7 +51,7 @@ class Query {
 
     enum class LogMode : unsigned char {
         kFull,      ///< Output name and optionally statement
-        kNameOnly,  ///< Ouput only name
+        kNameOnly,  ///< Output only name
     };
 
     Query() = default;
@@ -85,12 +85,12 @@ class Query {
 
 private:
     struct DynamicStrings {
-        std::string statement_;
-        std::optional<Name> name_;
+        std::string statement;
+        std::optional<Name> name;
     };
     struct StaticStrings {
-        utils::StringLiteral statement_;
-        std::optional<NameLiteral> name_;
+        utils::StringLiteral statement;
+        std::optional<NameLiteral> name;
     };
     struct NameViewVisitor;
 
diff --git a/core/include/userver/tracing/span.hpp b/core/include/userver/tracing/span.hpp
index d34368fad53f..33d4c3ee9e5e 100644
--- a/core/include/userver/tracing/span.hpp
+++ b/core/include/userver/tracing/span.hpp
@@ -296,9 +296,9 @@ class Span final {
         static OptionalDeleter DoNotDelete() noexcept;
 
     private:
-        explicit OptionalDeleter(bool do_delete) : do_delete(do_delete) {}
+        explicit OptionalDeleter(bool do_delete) : do_delete_(do_delete) {}
 
-        const bool do_delete;
+        const bool do_delete_;
     };
 
     friend class SpanBuilder;
diff --git a/core/include/userver/utils/datetime.hpp b/core/include/userver/utils/datetime.hpp
index cc0f69a0d63e..13a9f7901253 100644
--- a/core/include/userver/utils/datetime.hpp
+++ b/core/include/userver/utils/datetime.hpp
@@ -93,6 +93,15 @@ cctz::civil_second Localize(const std::chrono::system_clock::time_point& tp, con
 /// @snippet utils/datetime_test.cpp  Localize example
 std::time_t Unlocalize(const cctz::civil_second& local_tp, const std::string& timezone);
 
+/// @brief Retrieves a time zone by name
+///
+/// Returns the corresponding time zone if the given timezone name is valid.
+/// Returns std::nullopt if no matching time zone is found.
+///
+/// @param timezone Time zone name (e.g. "UTC", "Europe/Moscow")
+/// @return std::optional containing the time zone or std::nullopt
+std::optional<cctz::time_zone> GetOptionalTimezone(const std::string& timezone);
+
 }  // namespace utils::datetime
 
 USERVER_NAMESPACE_END
diff --git a/core/include/userver/utils/hedged_request.hpp b/core/include/userver/utils/hedged_request.hpp
index 51e46261e030..e0bc57ca1eda 100644
--- a/core/include/userver/utils/hedged_request.hpp
+++ b/core/include/userver/utils/hedged_request.hpp
@@ -96,12 +96,12 @@ struct PlanEntry {
     PlanEntry(TimePoint timepoint, std::size_t request_index, std::size_t attempt_id, Action action)
         : timepoint(timepoint), request_index(request_index), attempt_id(attempt_id), action(action) {}
 
-    bool operator<(const PlanEntry& other) const noexcept { return tie() < other.tie(); }
-    bool operator>(const PlanEntry& other) const noexcept { return tie() > other.tie(); }
-    bool operator==(const PlanEntry& other) const noexcept { return tie() == other.tie(); }
-    bool operator<=(const PlanEntry& other) const noexcept { return tie() <= other.tie(); }
-    bool operator>=(const PlanEntry& other) const noexcept { return tie() >= other.tie(); }
-    bool operator!=(const PlanEntry& other) const noexcept { return tie() != other.tie(); }
+    bool operator<(const PlanEntry& other) const noexcept { return Tie() < other.Tie(); }
+    bool operator>(const PlanEntry& other) const noexcept { return Tie() > other.Tie(); }
+    bool operator==(const PlanEntry& other) const noexcept { return Tie() == other.Tie(); }
+    bool operator<=(const PlanEntry& other) const noexcept { return Tie() <= other.Tie(); }
+    bool operator>=(const PlanEntry& other) const noexcept { return Tie() >= other.Tie(); }
+    bool operator!=(const PlanEntry& other) const noexcept { return Tie() != other.Tie(); }
 
     TimePoint timepoint;
     std::size_t request_index{0};
@@ -109,7 +109,7 @@ struct PlanEntry {
     Action action;
 
 private:
-    std::tuple<const TimePoint&, const size_t&, const size_t&, const Action&> tie() const noexcept {
+    std::tuple<const TimePoint&, const size_t&, const size_t&, const Action&> Tie() const noexcept {
         return std::tie(timepoint, request_index, attempt_id, action);
     }
 };
@@ -144,7 +144,7 @@ struct Context {
     using ReplyType = typename RequestTraits<RequestStrategy>::ReplyType;
 
     Context(std::vector<RequestStrategy> inputs, HedgingSettings settings)
-        : inputs_(std::move(inputs)), settings(std::move(settings)) {
+        : inputs_(std::move(inputs)), settings_(std::move(settings)) {
         const std::size_t size = this->inputs_.size();
         request_states_.resize(size);
     }
@@ -155,8 +155,8 @@ struct Context {
         for (std::size_t request_id = 0; request_id < request_count; ++request_id) {
             plan_.emplace(start_time, request_id, 0, Action::StartTry);
         }
-        plan_.emplace(start_time + settings.timeout_all, 0, 0, Action::Stop);
-        subrequests_.reserve(settings.max_attempts * request_count);
+        plan_.emplace(start_time + settings_.timeout_all, 0, 0, Action::Stop);
+        subrequests_.reserve(settings_.max_attempts * request_count);
     }
 
     std::optional<TimePoint> NextEventTime() const {
@@ -185,7 +185,7 @@ struct Context {
         }
     }
 
-    const HedgingSettings& GetSettings() const { return settings; }
+    const HedgingSettings& GetSettings() const { return settings_; }
 
     size_t GetRequestsCount() const { return inputs_.size(); }
 
@@ -232,7 +232,7 @@ struct Context {
             return;
         }
 
-        if (attempts_made >= settings.max_attempts) {
+        if (attempts_made >= settings_.max_attempts) {
             return;
         }
         auto& strategy = inputs_[request_index];
@@ -248,14 +248,14 @@ struct Context {
         request_state.subrequest_indices.push_back(idx);
         input_by_subrequests_[idx] = request_index;
         attempts_made++;
-        plan_.emplace(now + settings.hedging_delay, request_index, attempts_made, Action::StartTry);
+        plan_.emplace(now + settings_.hedging_delay, request_index, attempts_made, Action::StartTry);
     }
 
     /// Called on getting error in request with @param request_idx
     void OnRetriableReply(std::size_t request_idx, std::chrono::milliseconds retry_delay, TimePoint now) {
         const auto& request_state = request_states_[request_idx];
         if (request_state.finished) return;
-        if (request_state.attempts_made >= settings.max_attempts) return;
+        if (request_state.attempts_made >= settings_.max_attempts) return;
 
         plan_.emplace(now + retry_delay, request_idx, request_state.attempts_made, Action::StartTry);
     }
@@ -266,7 +266,7 @@ struct Context {
 private:
     /// user provided request strategies bulk
     std::vector<RequestStrategy> inputs_;
-    HedgingSettings settings;
+    HedgingSettings settings_;
 
     /// Our plan of what we will do at what time
     std::priority_queue<PlanEntry, std::vector<PlanEntry>, std::greater<>> plan_{};
@@ -297,8 +297,8 @@ struct HedgedRequestBulkFuture {
     engine::impl::ContextAccessor* TryGetContextAccessor() { return task_.TryGetContextAccessor(); }
 
 private:
-    template <typename RequestStrategy_>
-    friend auto HedgeRequestsBulkAsync(std::vector<RequestStrategy_> inputs, HedgingSettings settings);
+    template <typename TRequestStrategy>
+    friend auto HedgeRequestsBulkAsync(std::vector<TRequestStrategy> inputs, HedgingSettings settings);
     using Task = engine::TaskWithResult<std::vector<std::optional<ReplyType>>>;
     HedgedRequestBulkFuture(Task&& task) : task_(std::move(task)) {}
     Task task_;
@@ -324,8 +324,8 @@ struct HedgedRequestFuture {
     engine::impl::ContextAccessor* TryGetContextAccessor() { return task_.TryGetContextAccessor(); }
 
 private:
-    template <typename RequestStrategy_>
-    friend auto HedgeRequestAsync(RequestStrategy_ input, HedgingSettings settings);
+    template <typename TRequestStrategy>
+    friend auto HedgeRequestAsync(TRequestStrategy input, HedgingSettings settings);
     using Task = engine::TaskWithResult<std::optional<ReplyType>>;
     HedgedRequestFuture(Task&& task) : task_(std::move(task)) {}
     Task task_;
diff --git a/core/include/userver/utils/periodic_task.hpp b/core/include/userver/utils/periodic_task.hpp
index 22ba3147ae93..31a4dd0209e5 100644
--- a/core/include/userver/utils/periodic_task.hpp
+++ b/core/include/userver/utils/periodic_task.hpp
@@ -6,22 +6,19 @@
 #include <chrono>
 #include <functional>
 #include <optional>
-#include <random>
 #include <string>
 
-#include <userver/engine/single_consumer_event.hpp>
-#include <userver/engine/task/task_with_result.hpp>
-#include <userver/rcu/rcu.hpp>
+#include <userver/logging/level.hpp>
 #include <userver/utils/assert.hpp>
+#include <userver/utils/fast_pimpl.hpp>
 #include <userver/utils/flags.hpp>
 
-// TODO remove extra include
-#include <userver/engine/condition_variable.hpp>
-#include <userver/testsuite/periodic_task_control.hpp>
-#include <userver/tracing/span.hpp>
-
 USERVER_NAMESPACE_BEGIN
 
+namespace engine {
+class TaskProcessor;
+}  // namespace engine
+
 namespace testsuite {
 class PeriodicTaskControl;
 }  // namespace testsuite
@@ -204,36 +201,10 @@ class PeriodicTask final {
     Settings GetCurrentSettings() const;
 
 private:
-    enum class SuspendState { kRunning, kSuspended };
-
-    void DoStart();
-
-    void Run();
-
-    bool Step();
-
-    bool StepDebug(bool preserve_span);
-
-    bool DoStep();
-
-    std::chrono::milliseconds MutatePeriod(std::chrono::milliseconds period);
-
-    std::string_view GetName() const noexcept;
-
-    std::string name_;
-    std::atomic<bool> is_name_set_{false};
-    Callback callback_;
-    engine::TaskWithResult<void> task_;
-    rcu::Variable<Settings> settings_;
-    engine::SingleConsumerEvent changed_event_;
-    std::atomic<bool> should_force_step_{false};
-    std::optional<std::minstd_rand> mutate_period_random_;
-
-    // For kNow only
-    engine::Mutex step_mutex_;
-    std::atomic<SuspendState> suspend_state_;
-
-    std::optional<USERVER_NAMESPACE::testsuite::PeriodicTaskRegistrationHolder> registration_holder_;
+    class Impl;
+    constexpr static std::size_t kSize = 432;
+    constexpr static std::size_t kAlignment = 16;
+    utils::FastPimpl<Impl, kSize, kAlignment> impl_;
 };
 
 }  // namespace utils
diff --git a/core/include/userver/utils/statistics/busy.hpp b/core/include/userver/utils/statistics/busy.hpp
index 6533f1dca933..5845f60931c4 100644
--- a/core/include/userver/utils/statistics/busy.hpp
+++ b/core/include/userver/utils/statistics/busy.hpp
@@ -41,7 +41,7 @@ class BusyStorage final {
     Duration GetNotCommittedLoad() const noexcept;
 
     struct Impl;
-    std::unique_ptr<Impl> pimpl;
+    std::unique_ptr<Impl> pimpl_;
 };
 
 /// @brief A RAII-style guard to account code block execution time in
diff --git a/core/include/userver/utils/statistics/metric_tag_impl.hpp b/core/include/userver/utils/statistics/metric_tag_impl.hpp
index fc0cc4d0279e..48dbedd0ab03 100644
--- a/core/include/userver/utils/statistics/metric_tag_impl.hpp
+++ b/core/include/userver/utils/statistics/metric_tag_impl.hpp
@@ -63,7 +63,7 @@ class MetricWrapperBase {
 template <typename Metric>
 class MetricWrapper final : public MetricWrapperBase {
     static_assert(
-        meta::kIsDetected<HasDumpMetric, Metric> || kHasWriterSupport<Metric>,
+        meta::IsDetected<HasDumpMetric, Metric> || kHasWriterSupport<Metric>,
         "Provide a `void DumpMetric(utils::statistics::Writer&, const Metric&)`"
         "function in the namespace of `Metric`."
     );
@@ -94,7 +94,7 @@ class MetricWrapper final : public MetricWrapperBase {
     bool HasWriterSupport() const noexcept override { return kHasWriterSupport<Metric>; }
 
     void Reset() override {
-        if constexpr (meta::kIsDetected<HasResetMetric, Metric>) {
+        if constexpr (meta::IsDetected<HasResetMetric, Metric>) {
             ResetMetric(data_);
         }
     }
diff --git a/core/include/userver/utils/statistics/percentile_format_json.hpp b/core/include/userver/utils/statistics/percentile_format_json.hpp
index 1a2183891a0c..1c95566948dd 100644
--- a/core/include/userver/utils/statistics/percentile_format_json.hpp
+++ b/core/include/userver/utils/statistics/percentile_format_json.hpp
@@ -24,7 +24,7 @@ std::string GetPercentileFieldName(double perc);
 template <typename T>
 formats::json::ValueBuilder PercentileToJson(const T& perc, std::initializer_list<double> percents) {
     static_assert(
-        meta::kIsDetected<impl::HasGetPercentileResult, T>,
+        meta::IsDetected<impl::HasGetPercentileResult, T>,
         "T must specify T::GetPercentile(double) returning "
         "json-serializable value"
     );
diff --git a/core/include/userver/utils/trx_tracker.hpp b/core/include/userver/utils/trx_tracker.hpp
new file mode 100644
index 000000000000..24b07eacaeeb
--- /dev/null
+++ b/core/include/userver/utils/trx_tracker.hpp
@@ -0,0 +1,131 @@
+#pragma once
+
+/// @file
+/// @brief Tracking for heavy operations while having active transactions.
+
+#include <optional>
+#include <thread>
+
+#include <userver/utils/impl/source_location.hpp>
+#include <userver/utils/statistics/rate.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+/// @brief Tracking for heavy operations while having active transactions.
+///
+/// Some operations, like http requests, are heavy and can take
+/// too long during an incident. If they are called during an active
+/// database transaction, connection will be held for longer and
+/// connection pool will be exhausted. Transaction tracker prevents this
+/// by holding counter of active transactions in TaskLocalVariable
+/// and checking for active transactions in heavy operations.
+///
+/// ## Example usage:
+///
+/// @snippet utils/trx_tracker_test.cpp  Sample TransactionTracker usage
+namespace utils::trx_tracker {
+
+namespace impl {
+
+/// @brief Global enabler for transaction tracker.
+class GlobalEnabler final {
+public:
+    explicit GlobalEnabler(bool enable = true);
+    ~GlobalEnabler();
+
+    GlobalEnabler(const GlobalEnabler&) = delete;
+    GlobalEnabler& operator=(const GlobalEnabler&) = delete;
+};
+
+/// @brief Check if transaction tracker is enabled.
+bool IsEnabled() noexcept;
+
+/// @brief Unique ID for every task.
+///
+/// Sometimes transactions start and end in different coroutines.
+/// To prevent transaction from incrementing and decrementing different
+/// transaction counters, TransactionLock stores TaskId on Lock and
+/// checks that stored TaskId is the same as current TaskId in Unlock.
+class TaskId final {
+public:
+    TaskId();
+
+    bool operator==(const TaskId& other) const;
+    bool operator!=(const TaskId& other) const;
+
+private:
+    std::thread::id created_thread_id_;
+    std::uint64_t thread_local_counter_;
+};
+
+}  // namespace impl
+
+/// @brief Class for incrementing and decrementing transaction counter.
+class TransactionLock final {
+public:
+    TransactionLock() = default;
+    TransactionLock(const TransactionLock&) = delete;
+    TransactionLock(TransactionLock&&) noexcept;
+    TransactionLock operator=(const TransactionLock&) = delete;
+    TransactionLock& operator=(TransactionLock&&) noexcept;
+
+    /// @brief Decrement transaction counter on destruction.
+    ~TransactionLock();
+
+    /// @brief Manually increment transaction counter.
+    void Lock() noexcept;
+
+    /// @brief Manually decrement transaction counter.
+    void Unlock() noexcept;
+
+private:
+    std::optional<impl::TaskId> task_id_;
+};
+
+/// @brief Check for active transactions.
+void CheckNoTransactions(utils::impl::SourceLocation location = utils::impl::SourceLocation::Current());
+
+/// @overload
+void CheckNoTransactions(std::string_view location);
+
+/// @brief Disable check for active transactions.
+///
+/// To consciously call a heavy operation in active transaction,
+/// check can be disabled by creating an instance of this class.
+/// Checks will be disabled until every instance either has
+/// Reenable() method called or is destroyed.
+class CheckDisabler final {
+public:
+    /// @brief Disable check for active transactions.
+    explicit CheckDisabler();
+
+    /// @brief Reenable check for active transactions on destruction.
+    ~CheckDisabler();
+
+    CheckDisabler(const CheckDisabler&) = delete;
+    CheckDisabler(CheckDisabler&&) = delete;
+    CheckDisabler operator=(const CheckDisabler&) = delete;
+    CheckDisabler operator=(CheckDisabler&&) = delete;
+
+    /// @brief Manually reenable check for active transactions.
+    void Reenable() noexcept;
+
+private:
+    bool reenabled_ = false;
+};
+
+/// @brief Statistics for transaction tracker.
+struct TransactionTrackerStatistics final {
+    /// @brief How many times check for active transactions was triggered.
+    utils::statistics::Rate triggers{0};
+};
+
+/// @brief Get statistics for transaction tracker.
+TransactionTrackerStatistics GetStatistics() noexcept;
+
+/// @brief Reset statistics for transaction tracker.
+void ResetStatistics();
+
+}  // namespace utils::trx_tracker
+
+USERVER_NAMESPACE_END
diff --git a/core/library.yaml b/core/library.yaml
index fb1445ea4fa9..9aab5047ddae 100644
--- a/core/library.yaml
+++ b/core/library.yaml
@@ -8,6 +8,8 @@ description: userver core stuff
 configs:
     names:
       - BAGGAGE_SETTINGS
+      - EGRESS_HTTP_PROXY_ENABLED
+      - EGRESS_NO_PROXY_TARGETS
       - HTTP_CLIENT_CONNECTION_POOL_SIZE
       - HTTP_CLIENT_CONNECT_THROTTLE
       - USERVER_BAGGAGE_ENABLED
diff --git a/core/src/clients/dns/resolver.cpp b/core/src/clients/dns/resolver.cpp
index 6a43d8bb1659..0ab57d1d5e6d 100644
--- a/core/src/clients/dns/resolver.cpp
+++ b/core/src/clients/dns/resolver.cpp
@@ -419,6 +419,8 @@ AddrVector Resolver::Resolve(const std::string& name, engine::Deadline deadline)
     }
 
     UINVARIANT(false, "Unexpected cache result status");
+    // never reaches
+    return LocalhostAddrs();
 }
 
 const Resolver::LookupSourceCounters& Resolver::GetLookupSourceCounters() const {
diff --git a/core/src/clients/http/client.cpp b/core/src/clients/http/client.cpp
index 701562f366b6..5447bedfe091 100644
--- a/core/src/clients/http/client.cpp
+++ b/core/src/clients/http/client.cpp
@@ -49,7 +49,7 @@ const tracing::TracingManagerBase* GetTracingManager(const ClientSettings& setti
 Client::Client(
     ClientSettings settings,
     engine::TaskProcessor& fs_task_processor,
-    impl::PluginPipeline&& plugin_pipeline
+    std::vector<utils::NotNull<clients::http::Plugin*>> plugins
 )
     : deadline_propagation_config_(settings.deadline_propagation),
       cancellation_policy_(settings.cancellation_policy),
@@ -59,7 +59,7 @@ Client::Client(
       user_agent_(utils::GetUserverIdentifier()),
       connect_rate_limiter_(std::make_shared<curl::ConnectRateLimiter>()),
       tracing_manager_(GetTracingManager(settings)),
-      plugin_pipeline_(std::move(plugin_pipeline)) {
+      plugins_(std::move(plugins)) {
     const auto io_threads = settings.io_threads;
     const auto& thread_name_prefix = settings.thread_name_prefix;
 
@@ -125,7 +125,7 @@ Request Client::CreateRequest() {
                 statistics_[idx].CreateRequestStats(),
                 destination_statistics_,
                 resolver_,
-                plugin_pipeline_,
+                plugins_,
                 *tracing_manager_.GetBase()};
         } else {
             auto i = utils::RandRange(multis_.size());
@@ -140,7 +140,7 @@ Request Client::CreateRequest() {
                     statistics_[i].CreateRequestStats(),
                     destination_statistics_,
                     resolver_,
-                    plugin_pipeline_,
+                    plugins_,
                     *tracing_manager_.GetBase()};
             } catch (engine::WaitInterruptedException&) {
                 throw clients::http::CancelException("wait interrupted", {}, ErrorKind::kCancel);
diff --git a/core/src/clients/http/client_crl_test.cpp b/core/src/clients/http/client_crl_test.cpp
index 2efaecbdc819..226888730d16 100644
--- a/core/src/clients/http/client_crl_test.cpp
+++ b/core/src/clients/http/client_crl_test.cpp
@@ -309,19 +309,18 @@ EmOKfeOntrWGKRoDws82ckOkpBkZ0/9gsl8g18u+jFCcSUfmXH7FtGg=
 -----END X509 CRL-----)";
 
 struct TlsServer {
-    TlsServer() : port_(tcp_listener_.socket.Getsockname().Port()) {}
+    TlsServer() : port(tcp_listener.socket.Getsockname().Port()) {}
 
     void ReceiveAndShutdown(std::initializer_list<crypto::Certificate> cas = {}) {
         auto deadline = engine::Deadline::FromDuration(utest::kMaxTestWaitTime);
-        auto socket = tcp_listener_.socket.Accept(deadline);
+        auto socket = tcp_listener.socket.Accept(deadline);
 
-        auto tls_server = engine::io::TlsWrapper::StartTlsServer(
-            std::move(socket),
+        crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
             crypto::LoadCertificatesChainFromString(kServerCertificate),
             crypto::PrivateKey::LoadFromString(kRevokedServerPrivateKey),
-            deadline,
             cas
         );
+        auto tls_server = engine::io::TlsWrapper::StartTlsServer(std::move(socket), ssl_ctx, deadline);
 
         std::array<char, 2048> data{};
         const auto size = tls_server.RecvSome(data.data(), data.size(), deadline);
@@ -340,8 +339,8 @@ struct TlsServer {
         EXPECT_TRUE(socket.IsValid());
     }
 
-    internal::net::TcpListener tcp_listener_;
-    int port_;
+    internal::net::TcpListener tcp_listener;
+    int port;
 };
 
 auto InterceptCrlDistribution() {
@@ -371,7 +370,7 @@ UTEST(HttpClient, HttpsWithNoCrl) {
 
     auto http_client_ptr = utest::CreateHttpClient();
     TlsServer tls_server;
-    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port_);
+    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port);
 
     auto response_future = http_client_ptr->CreateRequest()
                                .post(ssl_url)
@@ -400,7 +399,7 @@ UTEST(HttpClient, HttpsWithCrl) {
 
     auto http_client_ptr = utest::CreateHttpClient();
     TlsServer tls_server;
-    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port_);
+    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port);
 
     auto response_future = http_client_ptr->CreateRequest()
                                .post(ssl_url)
@@ -428,7 +427,7 @@ UTEST(HttpClient, HttpsWithCrlNoVerify) {
 
     auto http_client_ptr = utest::CreateHttpClient();
     TlsServer tls_server;
-    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port_);
+    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port);
 
     auto response_future = http_client_ptr->CreateRequest()
                                .post(ssl_url)
@@ -454,7 +453,7 @@ UTEST(HttpClient, HttpsWithNoServerCa) {
 
     auto http_client_ptr = utest::CreateHttpClient();
     TlsServer tls_server;
-    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port_);
+    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port);
 
     auto response_future = http_client_ptr->CreateRequest()
                                .post(ssl_url)
@@ -478,7 +477,7 @@ UTEST(HttpClient, HttpsWithNoClientCa) {
 
     auto http_client_ptr = utest::CreateHttpClient();
     TlsServer tls_server;
-    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port_);
+    const auto ssl_url = fmt::format("https://[::1]:{}", tls_server.port);
 
     auto response_future = http_client_ptr->CreateRequest()
                                .post(ssl_url)
diff --git a/core/src/clients/http/client_test.cpp b/core/src/clients/http/client_test.cpp
index 3791166de90c..1d564659c2f2 100644
--- a/core/src/clients/http/client_test.cpp
+++ b/core/src/clients/http/client_test.cpp
@@ -132,7 +132,7 @@ using HttpResponse = utest::SimpleServer::Response;
 using HttpRequest = utest::SimpleServer::Request;
 using HttpCallback = utest::SimpleServer::OnRequest;
 
-std::optional<HttpResponse> process_100(const HttpRequest& request) {
+std::optional<HttpResponse> Process100(const HttpRequest& request) {
     const bool requires_continue = (request.find("Expect: 100-continue") != std::string::npos);
 
     if (requires_continue || request.empty()) {
@@ -151,7 +151,7 @@ struct EchoCallback {
     HttpResponse operator()(const HttpRequest& request) const {
         LOG_INFO() << "HTTP Server receive: " << request;
 
-        const auto cont = process_100(request);
+        const auto cont = Process100(request);
         if (cont) {
             return *cont;
         }
@@ -184,7 +184,7 @@ struct ValidatingSharedCallback {
     HttpResponse operator()(const HttpRequest& request) const {
         LOG_INFO() << "HTTP Server receive: " << request;
 
-        const auto cont = process_100(request);
+        const auto cont = Process100(request);
 
         EXPECT_FALSE(!!cont) << "This callback does not work with CONTINUE";
 
@@ -245,7 +245,7 @@ struct AuthCallback {
     }
 };
 
-HttpResponse put_validate_callback(const HttpRequest& request) {
+HttpResponse PutValidateCallback(const HttpRequest& request) {
     LOG_INFO() << "HTTP Server receive: " << request;
 
     EXPECT_NE(request.find("PUT"), std::string::npos) << "PUT request has no PUT in headers: " << request;
@@ -256,7 +256,7 @@ HttpResponse put_validate_callback(const HttpRequest& request) {
         HttpResponse::kWriteAndClose};
 }
 
-HttpResponse sleep_callback_base(const HttpRequest& request, std::chrono::milliseconds sleep_for) {
+HttpResponse SleepCallbackBase(const HttpRequest& request, std::chrono::milliseconds sleep_for) {
     LOG_INFO() << "HTTP Server receive: " << request;
 
     engine::InterruptibleSleepFor(sleep_for);
@@ -268,18 +268,14 @@ HttpResponse sleep_callback_base(const HttpRequest& request, std::chrono::millis
         HttpResponse::kWriteAndClose};
 }
 
-HttpResponse sleep_callback(const HttpRequest& request) {
-    return sleep_callback_base(request, utest::kMaxTestWaitTime);
-}
+HttpResponse SleepCallback(const HttpRequest& request) { return SleepCallbackBase(request, utest::kMaxTestWaitTime); }
 
-HttpResponse sleep_callback_1s(const HttpRequest& request) {
-    return sleep_callback_base(request, std::chrono::seconds(1));
-}
+HttpResponse SleepCallback1s(const HttpRequest& request) { return SleepCallbackBase(request, std::chrono::seconds(1)); }
 
-HttpResponse huge_data_callback(const HttpRequest& request) {
+HttpResponse HugeDataCallback(const HttpRequest& request) {
     LOG_INFO() << "HTTP Server receive: " << request;
 
-    const auto cont = process_100(request);
+    const auto cont = Process100(request);
     if (cont) {
         return *cont;
     }
@@ -314,7 +310,7 @@ std::string AssertHeader(const HttpRequest& request, std::string_view header) {
     return TryGetHeader(request, header);
 }
 
-HttpResponse header_validate_callback(const HttpRequest& request) {
+HttpResponse HeaderValidateCallback(const HttpRequest& request) {
     LOG_INFO() << "HTTP Server receive: " << request;
     AssertHeader(request, kTestHeader);
     return {
@@ -323,7 +319,7 @@ HttpResponse header_validate_callback(const HttpRequest& request) {
         HttpResponse::kWriteAndClose};
 }
 
-HttpResponse user_agent_validate_callback(const HttpRequest& request) {
+HttpResponse UserAgentValidateCallback(const HttpRequest& request) {
     LOG_INFO() << "HTTP Server receive: " << request;
     auto header_value = AssertHeader(request, http::headers::kUserAgent);
 
@@ -335,7 +331,7 @@ HttpResponse user_agent_validate_callback(const HttpRequest& request) {
         HttpResponse::kWriteAndClose};
 }
 
-HttpResponse no_user_agent_validate_callback(const HttpRequest& request) {
+HttpResponse NoUserAgentValidateCallback(const HttpRequest& request) {
     LOG_INFO() << "HTTP Server receive: " << request;
     auto header_value = TryGetHeader(request, http::headers::kUserAgent);
     EXPECT_EQ(header_value, utils::GetUserverIdentifier()) << "In request: " << request;
@@ -507,6 +503,8 @@ std::string DifferentUrlsRetryStreamResponseBody(
     }
 
     UINVARIANT(false, "No alive servers");
+    // Never reaches
+    return {};
 }
 
 }  // namespace sample
@@ -597,7 +595,7 @@ UTEST(HttpClient, PostEcho) {
 
 UTEST(HttpClient, StatsOnTimeout) {
     const int kRetries = 5;
-    const utest::SimpleServer http_server{&sleep_callback};
+    const utest::SimpleServer http_server{&SleepCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     auto request = http_client_ptr->CreateRequest()
@@ -675,7 +673,7 @@ UTEST(HttpClient, CancelRetries) {
         if (server_requests > kMinRetries) {
             enough_retries_event.Send();
         }
-        return sleep_callback_1s(request);
+        return SleepCallback1s(request);
     };
 
     const utest::SimpleServer http_server{callback};
@@ -733,7 +731,7 @@ UTEST(HttpClient, CancelRetries) {
 }
 
 UTEST(HttpClient, PostShutdownWithPendingRequest) {
-    const utest::SimpleServer http_server{&sleep_callback};
+    const utest::SimpleServer http_server{&SleepCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     for (unsigned i = 0; i < kRepetitions; ++i)
@@ -751,7 +749,7 @@ UTEST(HttpClient, PostShutdownWithPendingRequestHuge) {
     // The test produces too much logs otherwise
     auto log_level_scope = LogLevelScope(logging::Level::kError);
 
-    const utest::SimpleServer http_server{&sleep_callback};
+    const utest::SimpleServer http_server{&SleepCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     std::string request = kTestData;
@@ -785,7 +783,7 @@ UTEST(HttpClient, PutEcho) {
 }
 
 UTEST(HttpClient, PutValidateHeader) {
-    const utest::SimpleServer http_server{&put_validate_callback};
+    const utest::SimpleServer http_server{&PutValidateCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     auto request = http_client_ptr->CreateRequest()
@@ -800,7 +798,7 @@ UTEST(HttpClient, PutValidateHeader) {
 }
 
 UTEST(HttpClient, PutShutdownWithPendingRequest) {
-    const utest::SimpleServer http_server{&sleep_callback};
+    const utest::SimpleServer http_server{&SleepCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     for (unsigned i = 0; i < kRepetitions; ++i)
@@ -818,7 +816,7 @@ UTEST(HttpClient, PutShutdownWithPendingRequestHuge) {
     // The test produces too much logs otherwise
     auto log_level_scope = LogLevelScope(logging::Level::kError);
 
-    const utest::SimpleServer http_server{&sleep_callback};
+    const utest::SimpleServer http_server{&SleepCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     std::string request = kTestData;
@@ -838,7 +836,7 @@ UTEST(HttpClient, PutShutdownWithPendingRequestHuge) {
 }
 
 UTEST(HttpClient, PutShutdownWithHugeResponse) {
-    const utest::SimpleServer http_server{&huge_data_callback};
+    const utest::SimpleServer http_server{&HugeDataCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     for (unsigned i = 0; i < kRepetitions; ++i)
@@ -972,7 +970,7 @@ UTEST(HttpClient, MethodsMixReuseRequestData) {
 }
 
 UTEST(HttpClient, Headers) {
-    const utest::SimpleServer http_server{&header_validate_callback};
+    const utest::SimpleServer http_server{&HeaderValidateCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     clients::http::Headers headers;
@@ -994,8 +992,8 @@ UTEST(HttpClient, Headers) {
 }
 
 UTEST(HttpClient, HeadersUserAgent) {
-    const utest::SimpleServer http_server{&user_agent_validate_callback};
-    const utest::SimpleServer http_server_no_ua{&no_user_agent_validate_callback};
+    const utest::SimpleServer http_server{&UserAgentValidateCallback};
+    const utest::SimpleServer http_server_no_ua{&NoUserAgentValidateCallback};
     auto http_client_ptr = utest::CreateHttpClient();
 
     auto request = http_client_ptr->CreateRequest()
@@ -1239,7 +1237,7 @@ UTEST(HttpClient, Retry) {
 
 UTEST(HttpClient, TinyTimeout) {
     auto http_client_ptr = utest::CreateHttpClient();
-    const utest::SimpleServer http_server{sleep_callback_1s};
+    const utest::SimpleServer http_server{SleepCallback1s};
 
     for (unsigned i = 0; i < kRepetitions; ++i) {
         auto response_future = http_client_ptr->CreateRequest()
@@ -1325,7 +1323,7 @@ UTEST(HttpClient, RequestReuseBasic) {
 UTEST(HttpClient, RequestReuseSample) {
     const EchoCallback shared_echo_callback{};
     const utest::SimpleServer http_server{shared_echo_callback, utest::SimpleServer::kTcpIpV6};
-    const utest::SimpleServer http_sleep_server{sleep_callback_1s};
+    const utest::SimpleServer http_sleep_server{SleepCallback1s};
 
     std::string data = "Some long long request";
     for (unsigned i = 0; i < kFewRepetitions; ++i) {
@@ -1368,7 +1366,7 @@ UTEST(HttpClient, RequestReuseSample) {
 UTEST(HttpClient, DISABLED_RequestReuseSampleStream) {
     const EchoCallback shared_echo_callback{};
     const utest::SimpleServer http_server{shared_echo_callback, utest::SimpleServer::kTcpIpV6};
-    const utest::SimpleServer http_sleep_server{sleep_callback_1s};
+    const utest::SimpleServer http_sleep_server{SleepCallback1s};
 
     std::string data = "Some long long request";
     for (unsigned i = 0; i < kFewRepetitions; ++i) {
@@ -1394,7 +1392,7 @@ UTEST(HttpClient, DISABLED_RequestReuseSampleStream) {
 UTEST(HttpClient, RequestReuseDifferentUrlAndTimeout) {
     const EchoCallback shared_echo_callback;
     const utest::SimpleServer http_echo_server{shared_echo_callback, utest::SimpleServer::kTcpIpV6};
-    const utest::SimpleServer http_sleep_server{sleep_callback_1s};
+    const utest::SimpleServer http_sleep_server{SleepCallback1s};
 
     auto http_client_ptr = utest::CreateHttpClient();
 
diff --git a/core/src/clients/http/client_wait_test.cpp b/core/src/clients/http/client_wait_test.cpp
index 419e3169077d..7edf88311e02 100644
--- a/core/src/clients/http/client_wait_test.cpp
+++ b/core/src/clients/http/client_wait_test.cpp
@@ -2,6 +2,7 @@
 
 #include <userver/engine/sleep.hpp>
 #include <userver/engine/wait_any.hpp>
+#include <userver/logging/log.hpp>
 
 #include <userver/http/http_version.hpp>
 #include <userver/utest/http_client.hpp>
diff --git a/core/src/clients/http/destination_statistics_test.cpp b/core/src/clients/http/destination_statistics_test.cpp
index 5dae97b2370d..464fdd1556a4 100644
--- a/core/src/clients/http/destination_statistics_test.cpp
+++ b/core/src/clients/http/destination_statistics_test.cpp
@@ -1,7 +1,9 @@
 #include <clients/http/destination_statistics.hpp>
 
 #include <unordered_set>
+
 #include <userver/engine/sleep.hpp>
+#include <userver/logging/log.hpp>
 
 #include <userver/clients/http/client.hpp>
 #include <userver/utest/http_client.hpp>
diff --git a/core/src/clients/http/form_test.cpp b/core/src/clients/http/form_test.cpp
index d440dc8e79e8..b568b1fde97f 100644
--- a/core/src/clients/http/form_test.cpp
+++ b/core/src/clients/http/form_test.cpp
@@ -47,7 +47,7 @@ bool ReceivedFull(const HttpRequest& request) {
     return request.find(end_boundary) != std::string::npos;
 }
 
-void validate_filesend(
+void ValidateFilesend(
     const HttpRequest& request,
     std::string key,
     std::string filename,
@@ -82,22 +82,22 @@ void validate_filesend(
     EXPECT_LT(filename_pos, test_data_pos) << "Nested filename appears after test data: " << request;
 }
 
-HttpResponse validating_callback1(const HttpRequest& request) {
+HttpResponse ValidatingCallback1(const HttpRequest& request) {
     if (!ReceivedFull(request)) {
         return {{}, HttpResponse::kTryReadMore};
     }
-    validate_filesend(request, kKey, kFileNameTxt, kImageJpeg, kTestData);
+    ValidateFilesend(request, kKey, kFileNameTxt, kImageJpeg, kTestData);
 
     return {kOkCloseResponse, HttpResponse::kWriteAndClose};
 }
 
-HttpResponse validating_callback2(const HttpRequest& request) {
+HttpResponse ValidatingCallback2(const HttpRequest& request) {
     if (!ReceivedFull(request)) {
         return {{}, HttpResponse::kTryReadMore};
     }
 
-    validate_filesend(request, kKey, kFileNameTxt, kImageJpeg, kTestData);
-    validate_filesend(request, kKey2, kFileName2Bmp, kImageBmp, kOtherTestData);
+    ValidateFilesend(request, kKey, kFileNameTxt, kImageJpeg, kTestData);
+    ValidateFilesend(request, kKey2, kFileName2Bmp, kImageBmp, kOtherTestData);
 
     return {kOkCloseResponse, HttpResponse::kWriteAndClose};
 }
@@ -105,7 +105,7 @@ HttpResponse validating_callback2(const HttpRequest& request) {
 }  // namespace
 
 UTEST(CurlFormTest, MultipartFileWithContentType) {
-    const utest::SimpleServer http_server{&validating_callback1};
+    const utest::SimpleServer http_server{&ValidatingCallback1};
 
     auto http_client_ptr = utest::CreateHttpClient();
     clients::http::Form form;
@@ -123,7 +123,7 @@ UTEST(CurlFormTest, MultipartFileWithContentType) {
 }
 
 UTEST(CurlFormTest, FilesWithContentType) {
-    const utest::SimpleServer http_server{&validating_callback2};
+    const utest::SimpleServer http_server{&ValidatingCallback2};
 
     auto http_client_ptr = utest::CreateHttpClient();
     clients::http::Form form;
@@ -143,7 +143,7 @@ UTEST(CurlFormTest, FilesWithContentType) {
 }
 
 UTEST(CurlFormTest, FormMovable) {
-    const utest::SimpleServer http_server{&validating_callback2};
+    const utest::SimpleServer http_server{&ValidatingCallback2};
 
     auto http_client_ptr = utest::CreateHttpClient();
 
diff --git a/core/src/clients/http/plugin.cpp b/core/src/clients/http/plugin.cpp
index a50e8a001d06..0923400006b6 100644
--- a/core/src/clients/http/plugin.cpp
+++ b/core/src/clients/http/plugin.cpp
@@ -1,5 +1,7 @@
 #include <userver/clients/http/plugin.hpp>
 
+#include <boost/range/adaptor/reversed.hpp>
+
 #include <clients/http/request_state.hpp>
 #include <userver/clients/http/request.hpp>
 #include <userver/utils/algo.hpp>
@@ -38,12 +40,12 @@ const std::string& Plugin::GetName() const { return name_; }
 
 namespace impl {
 
-PluginPipeline::PluginPipeline(const std::vector<utils::NotNull<Plugin*>>& plugins) : plugins_(plugins) {}
+PluginPipeline::PluginPipeline(const std::vector<utils::NotNull<Plugin*>>& plugins) : plugins_(&plugins) {}
 
 void PluginPipeline::HookCreateSpan(RequestState& request_state, tracing::Span& span) {
     PluginRequest req(request_state);
 
-    for (const auto& plugin : plugins_) {
+    for (const auto& plugin : *plugins_) {
         plugin->HookCreateSpan(req, span);
     }
 }
@@ -52,8 +54,7 @@ void PluginPipeline::HookOnCompleted(RequestState& request_state, Response& resp
     PluginRequest req(request_state);
 
     // NOLINTNEXTLINE(modernize-loop-convert)
-    for (auto it = plugins_.rbegin(); it != plugins_.rend(); ++it) {
-        const auto& plugin = *it;
+    for (const auto& plugin : *plugins_ | boost::adaptors::reversed) {
         plugin->HookOnCompleted(req, response);
     }
 }
@@ -62,8 +63,7 @@ void PluginPipeline::HookOnError(RequestState& request_state, std::error_code ec
     PluginRequest req(request_state);
 
     // NOLINTNEXTLINE(modernize-loop-convert)
-    for (auto it = plugins_.rbegin(); it != plugins_.rend(); ++it) {
-        const auto& plugin = *it;
+    for (const auto& plugin : *plugins_ | boost::adaptors::reversed) {
         plugin->HookOnError(req, ec);
     }
 }
@@ -71,7 +71,7 @@ void PluginPipeline::HookOnError(RequestState& request_state, std::error_code ec
 bool PluginPipeline::HookOnRetry(RequestState& request_state) {
     PluginRequest req(request_state);
 
-    for (const auto& plugin : plugins_) {
+    for (const auto& plugin : *plugins_) {
         if (!plugin->HookOnRetry(req)) return false;
     }
     return true;
@@ -80,7 +80,7 @@ bool PluginPipeline::HookOnRetry(RequestState& request_state) {
 void PluginPipeline::HookPerformRequest(RequestState& request_state) {
     PluginRequest req(request_state);
 
-    for (const auto& plugin : plugins_) {
+    for (const auto& plugin : *plugins_) {
         plugin->HookPerformRequest(req);
     }
 }
diff --git a/core/src/clients/http/request.cpp b/core/src/clients/http/request.cpp
index a08be63dd4b4..d3daa9267876 100644
--- a/core/src/clients/http/request.cpp
+++ b/core/src/clients/http/request.cpp
@@ -207,17 +207,11 @@ Request::Request(
     RequestStats&& req_stats,
     const std::shared_ptr<DestinationStatistics>& dest_stats,
     clients::dns::Resolver* resolver,
-    impl::PluginPipeline& plugin_pipeline,
+    const std::vector<utils::NotNull<clients::http::Plugin*>>& plugins,
     const tracing::TracingManagerBase& tracing_manager
 )
-    : pimpl_(std::make_shared<RequestState>(
-          std::move(wrapper),
-          std::move(req_stats),
-          dest_stats,
-          resolver,
-          plugin_pipeline,
-          tracing_manager
-      )) {
+    : pimpl_(std::make_shared<
+             RequestState>(std::move(wrapper), std::move(req_stats), dest_stats, resolver, plugins, tracing_manager)) {
     LOG_TRACE() << "Request::Request()";
     // default behavior follow redirects and verify ssl
     pimpl_->follow_redirects(true);
@@ -242,7 +236,7 @@ StreamedResponse Request::async_perform_stream_body(
 }
 
 std::shared_ptr<Response> Request::perform(utils::impl::SourceLocation location) {
-    return async_perform(location).Get();
+    return async_perform(location).Get(location);
 }
 
 Request& Request::url(std::string url) & {
@@ -531,6 +525,11 @@ Request Request::delete_method(std::string url, std::string data) && {
     return std::move(this->delete_method(std::move(url), std::move(data)));
 }
 
+Request& Request::SetPluginsList(const std::vector<utils::NotNull<Plugin*>>& plugins) & {
+    pimpl_->SetPluginsList(plugins);
+    return *this;
+}
+
 Request& Request::SetLoggedUrl(std::string url) & {
     pimpl_->SetLoggedUrl(std::move(url));
     return *this;
diff --git a/core/src/clients/http/request_state.cpp b/core/src/clients/http/request_state.cpp
index c8370235be7d..d06329c9d7cd 100644
--- a/core/src/clients/http/request_state.cpp
+++ b/core/src/clients/http/request_state.cpp
@@ -100,7 +100,7 @@ bool IsSetCookie(std::string_view key) {
 // Not a strict check, but OK for non-header line check
 bool IsHttpStatusLineStart(const char* ptr, size_t size) { return (size > 5 && memcmp(ptr, "HTTP/", 5) == 0); }
 
-char* rfind_not_space(char* ptr, size_t size) {
+char* RfindNotSpace(char* ptr, size_t size) {
     for (char* p = ptr + size - 1; p >= ptr; --p) {
         const char c = *p;
         if (c == '\n' || c == '\r' || c == ' ' || c == '\t') continue;
@@ -215,7 +215,7 @@ RequestState::RequestState(
     RequestStats&& req_stats,
     const std::shared_ptr<DestinationStatistics>& dest_stats,
     clients::dns::Resolver* resolver,
-    impl::PluginPipeline& plugin_pipeline,
+    const std::vector<utils::NotNull<clients::http::Plugin*>>& plugins,
     const tracing::TracingManagerBase& tracing_manager
 )
     : easy_(std::move(wrapper)),
@@ -227,13 +227,13 @@ RequestState::RequestState(
       is_cancelled_(false),
       errorbuffer_(),
       resolver_{resolver},
-      plugin_pipeline_{plugin_pipeline} {
+      plugin_pipeline_(plugins) {
     // Libcurl calls sigaction(2)  way too frequently unless this option is used.
     easy().set_no_signal(true);
     easy().set_error_buffer(errorbuffer_.data());
 
     // define header function
-    easy().set_header_function(&RequestState::on_header);
+    easy().set_header_function(&RequestState::OnHeader);
     easy().set_header_data(this);
 
     // set autodecoding
@@ -278,7 +278,7 @@ void RequestState::ca(crypto::Certificate cert) {
     } else {
         // Legacy non-portable way, broken since 7.87.0
         ca_ = std::move(cert);
-        easy().set_ssl_ctx_function(&RequestState::on_certificate_request);
+        easy().set_ssl_ctx_function(&RequestState::OnCertificateRequest);
         easy().set_ssl_ctx_data(this);
     }
 }
@@ -326,7 +326,7 @@ void RequestState::client_key_cert(crypto::PrivateKey pkey, crypto::Certificate
         cert_id.resize(kCertIdLength, '=');
         easy().set_egd_socket(cert_id);
 
-        easy().set_ssl_ctx_function(&RequestState::on_certificate_request);
+        easy().set_ssl_ctx_function(&RequestState::OnCertificateRequest);
         easy().set_ssl_ctx_data(this);
     }
 }
@@ -401,14 +401,14 @@ void RequestState::SetDeadlinePropagationConfig(const DeadlinePropagationConfig&
     deadline_propagation_config_ = deadline_propagation_config;
 }
 
-size_t RequestState::on_header(void* ptr, size_t size, size_t nmemb, void* userdata) {
+size_t RequestState::OnHeader(void* ptr, size_t size, size_t nmemb, void* userdata) {
     auto* self = static_cast<RequestState*>(userdata);
     const std::size_t data_size = size * nmemb;
-    if (self) self->parse_header(static_cast<char*>(ptr), data_size);
+    if (self) self->ParseHeader(static_cast<char*>(ptr), data_size);
     return data_size;
 }
 
-curl::native::CURLcode RequestState::on_certificate_request(void* /*curl*/, void* sslctx, void* userdata) noexcept {
+curl::native::CURLcode RequestState::OnCertificateRequest(void* /*curl*/, void* sslctx, void* userdata) noexcept {
     auto* ssl = static_cast<SSL_CTX*>(sslctx);
     auto* self = static_cast<RequestState*>(userdata);
 
@@ -441,7 +441,7 @@ curl::native::CURLcode RequestState::on_certificate_request(void* /*curl*/, void
     return curl::native::CURLcode::CURLE_OK;
 }
 
-void RequestState::on_completed(std::shared_ptr<RequestState> holder, std::error_code err) {
+void RequestState::OnCompleted(std::shared_ptr<RequestState> holder, std::error_code err) {
     UASSERT(holder);
     UASSERT(holder->span_storage_);
     auto& span = holder->span_storage_->Get();
@@ -493,7 +493,7 @@ void RequestState::on_completed(std::shared_ptr<RequestState> holder, std::error
         const utils::Overloaded visitor{
             [&holder, &err](FullBufferedData& buffered_data) {
                 { [[maybe_unused]] const auto cleanup = holder->response_move(); }
-                auto promise = std::move(buffered_data.promise_);
+                auto promise = std::move(buffered_data.promise);
                 // The task will wake up and may reuse RequestState.
                 promise.set_exception(holder->PrepareException(err));
             },
@@ -516,7 +516,7 @@ void RequestState::on_completed(std::shared_ptr<RequestState> holder, std::error
 
         const utils::Overloaded visitor{
             [&holder](FullBufferedData& buffered_data) {
-                auto promise = std::move(buffered_data.promise_);
+                auto promise = std::move(buffered_data.promise);
                 // The task will wake up and may reuse RequestState.
                 promise.set_value(holder->response_move());
             },
@@ -530,7 +530,7 @@ void RequestState::on_completed(std::shared_ptr<RequestState> holder, std::error
     // it is unsafe to touch any content of holder after this point!
 }
 
-void RequestState::on_retry(std::shared_ptr<RequestState> holder, std::error_code err) {
+void RequestState::OnRetry(std::shared_ptr<RequestState> holder, std::error_code err) {
     UASSERT(holder);
     UASSERT(holder->span_storage_);
     LOG_TRACE() << "RequestImpl::on_retry" << tracing::impl::LogSpanAsLastNoCurrent{holder->span_storage_->Get()};
@@ -550,7 +550,7 @@ void RequestState::on_retry(std::shared_ptr<RequestState> holder, std::error_cod
 
     if (not_need_retry) {
         // finish if no need to retry
-        RequestState::on_completed(std::move(holder), err);
+        RequestState::OnCompleted(std::move(holder), err);
     } else {
         // calculate backoff before retry
         const auto eb_power = std::clamp(holder->retry_.current - 1, 0, kEBMaxPower);
@@ -559,7 +559,7 @@ void RequestState::on_retry(std::shared_ptr<RequestState> holder, std::error_cod
         holder->UpdateTimeoutFromDeadline(backoff);
         if (holder->remote_timeout_ <= std::chrono::milliseconds::zero()) {
             holder->deadline_expired_ = true;
-            RequestState::on_completed(std::move(holder), err);
+            RequestState::OnCompleted(std::move(holder), err);
             return;
         }
 
@@ -574,19 +574,19 @@ void RequestState::on_retry(std::shared_ptr<RequestState> holder, std::error_cod
         // call on_retry_timer on timer
         auto& holder_ref = *holder;
         holder_ref.retry_.timer->SingleshotAsync(backoff, [holder = std::move(holder)](std::error_code err) {
-            holder->on_retry_timer(err);
+            holder->OnRetryTimer(err);
         });
     }
 }
 
-void RequestState::on_retry_timer(std::error_code err) {
+void RequestState::OnRetryTimer(std::error_code err) {
     // if there is no error with timer call perform, otherwise finish
     if (!err)
-        perform_request([holder = shared_from_this()](std::error_code err) mutable {
-            RequestState::on_retry(std::move(holder), err);
+        PerformRequest([holder = shared_from_this()](std::error_code err) mutable {
+            RequestState::OnRetry(std::move(holder), err);
         });
     else
-        on_completed(shared_from_this(), err);
+        OnCompleted(shared_from_this(), err);
 }
 
 void RequestState::ParseSingleCookie(const char* ptr, size_t size) {
@@ -598,11 +598,11 @@ void RequestState::ParseSingleCookie(const char* ptr, size_t size) {
     }
 }
 
-void RequestState::parse_header(char* ptr, size_t size) try {
+void RequestState::ParseHeader(char* ptr, size_t size) try {
     /* It is a fast path in curl's thread (io thread).  Creation of tmp
      * std::string, boost::trim_right_if(), etc. is too expensive. */
 
-    auto* end = rfind_not_space(ptr, size);
+    auto* end = RfindNotSpace(ptr, size);
     if (ptr == end) {
         const auto status_code = static_cast<Status>(easy().get_response_code());
         response()->SetStatusCode(status_code);
@@ -644,6 +644,10 @@ void RequestState::parse_header(char* ptr, size_t size) try {
     LOG_ERROR() << "Failed to parse header: " << e.what();
 }
 
+void RequestState::SetPluginsList(const std::vector<utils::NotNull<Plugin*>>& plugins) {
+    plugin_pipeline_ = impl::PluginPipeline(plugins);
+}
+
 void RequestState::SetLoggedUrl(std::string url) { log_url_ = std::move(url); }
 
 const std::string& RequestState::GetLoggedOriginalUrl() const noexcept {
@@ -669,11 +673,11 @@ engine::Future<std::shared_ptr<Response>> RequestState::async_perform(utils::imp
     // set place for response body
     easy().set_sink(&response_->sink_string());
 
-    auto future = std::get_if<FullBufferedData>(&data_)->promise_.get_future();
+    auto future = std::get_if<FullBufferedData>(&data_)->promise.get_future();
 
     if (UpdateTimeoutFromDeadlineAndCheck()) {
-        perform_request([holder = shared_from_this()](std::error_code err) mutable {
-            RequestState::on_retry(std::move(holder), err);
+        PerformRequest([holder = shared_from_this()](std::error_code err) mutable {
+            RequestState::OnRetry(std::move(holder), err);
         });
     }
 
@@ -698,15 +702,15 @@ RequestState::async_perform_stream(const std::shared_ptr<Queue>& queue, utils::i
     auto future = std::get_if<StreamData>(&data_)->headers_promise.get_future();
 
     if (UpdateTimeoutFromDeadlineAndCheck()) {
-        perform_request([holder = shared_from_this()](std::error_code err) mutable {
-            RequestState::on_completed(std::move(holder), err);
+        PerformRequest([holder = shared_from_this()](std::error_code err) mutable {
+            RequestState::OnCompleted(std::move(holder), err);
         });
     }
 
     return future;
 }
 
-void RequestState::perform_request(curl::easy::handler_type handler) {
+void RequestState::PerformRequest(curl::easy::handler_type handler) {
     UASSERT_MSG(!cert_ || pkey_, "Setting certificate is useless without setting private key");
 
     UASSERT(response_);
@@ -727,12 +731,12 @@ void RequestState::perform_request(curl::easy::handler_type handler) {
                     // TODO: should retry - TAXICOMMON-4932
                     auto* buffered_data = std::get_if<FullBufferedData>(&data_);
                     if (buffered_data) {
-                        buffered_data->promise_.set_exception(std::current_exception());
+                        buffered_data->promise.set_exception(std::current_exception());
                     }
                 } catch (const BaseException& ex) {
                     auto* buffered_data = std::get_if<FullBufferedData>(&data_);
                     if (buffered_data) {
-                        buffered_data->promise_.set_exception(std::current_exception());
+                        buffered_data->promise.set_exception(std::current_exception());
                     }
                 }
             })
@@ -804,7 +808,7 @@ void RequestState::HandleDeadlineAlreadyPassed() {
 
     const utils::Overloaded visitor{
         [&exc](FullBufferedData& buffered_data) {
-            auto promise = std::move(buffered_data.promise_);
+            auto promise = std::move(buffered_data.promise);
             // The task will wake up and may reuse RequestState.
             promise.set_exception(std::move(exc));
         },
diff --git a/core/src/clients/http/request_state.hpp b/core/src/clients/http/request_state.hpp
index 1b9c4a97ec3c..264f254e6220 100644
--- a/core/src/clients/http/request_state.hpp
+++ b/core/src/clients/http/request_state.hpp
@@ -47,7 +47,7 @@ class RequestState : public std::enable_shared_from_this<RequestState> {
         RequestStats&& req_stats,
         const std::shared_ptr<DestinationStatistics>& dest_stats,
         clients::dns::Resolver* resolver,
-        impl::PluginPipeline& plugin_pipeline,
+        const std::vector<utils::NotNull<clients::http::Plugin*>>& plugins,
         const tracing::TracingManagerBase& tracing_manager
     );
     ~RequestState();
@@ -134,6 +134,7 @@ class RequestState : public std::enable_shared_from_this<RequestState> {
     std::shared_ptr<Response> response() const { return response_; }
     std::shared_ptr<Response> response_move() { return std::move(response_); }
 
+    void SetPluginsList(const std::vector<utils::NotNull<Plugin*>>& plugins);
     void SetLoggedUrl(std::string url);
     void SetEasyTimeout(std::chrono::milliseconds timeout);
 
@@ -143,22 +144,22 @@ class RequestState : public std::enable_shared_from_this<RequestState> {
 
 private:
     /// final callback that calls user callback and set value in promise
-    static void on_completed(std::shared_ptr<RequestState>, std::error_code err);
+    static void OnCompleted(std::shared_ptr<RequestState>, std::error_code err);
     /// retry callback
-    static void on_retry(std::shared_ptr<RequestState>, std::error_code err);
+    static void OnRetry(std::shared_ptr<RequestState>, std::error_code err);
     /// header function curl callback
-    static size_t on_header(void* ptr, size_t size, size_t nmemb, void* userdata);
+    static size_t OnHeader(void* ptr, size_t size, size_t nmemb, void* userdata);
 
     /// certificate function curl callback
-    static curl::native::CURLcode on_certificate_request(void* curl, void* sslctx, void* userdata) noexcept;
+    static curl::native::CURLcode OnCertificateRequest(void* curl, void* sslctx, void* userdata) noexcept;
 
     /// parse one header
-    void parse_header(char* ptr, size_t size);
+    void ParseHeader(char* ptr, size_t size);
     void ParseSingleCookie(const char* ptr, size_t size);
     /// simply run perform_request if there is now errors from timer
-    void on_retry_timer(std::error_code err);
+    void OnRetryTimer(std::error_code err);
     /// run curl async_request, called once per attempt
-    void perform_request(curl::easy::handler_type handler);
+    void PerformRequest(curl::easy::handler_type handler);
 
     void UpdateTimeoutFromDeadline(std::chrono::milliseconds backoff);
     [[nodiscard]] bool UpdateTimeoutFromDeadlineAndCheck(std::chrono::milliseconds backoff = {});
@@ -237,7 +238,7 @@ class RequestState : public std::enable_shared_from_this<RequestState> {
 
     clients::dns::Resolver* resolver_{nullptr};
     std::string proxy_url_;
-    impl::PluginPipeline& plugin_pipeline_;
+    impl::PluginPipeline plugin_pipeline_;
 
     struct StreamData {
         StreamData(Queue::Producer&& queue_producer) : queue_producer(std::move(queue_producer)) {}
@@ -248,7 +249,7 @@ class RequestState : public std::enable_shared_from_this<RequestState> {
     };
 
     struct FullBufferedData {
-        engine::Promise<std::shared_ptr<Response>> promise_;
+        engine::Promise<std::shared_ptr<Response>> promise;
     };
 
     std::variant<FullBufferedData, StreamData> data_;
diff --git a/core/src/clients/http/response_future.cpp b/core/src/clients/http/response_future.cpp
index ddefd9aa05b8..61a98a3a4a30 100644
--- a/core/src/clients/http/response_future.cpp
+++ b/core/src/clients/http/response_future.cpp
@@ -5,6 +5,7 @@
 #include <clients/http/request_state.hpp>
 #include <userver/server/request/task_inherited_data.hpp>
 #include <userver/utils/fast_scope_guard.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -94,7 +95,9 @@ void ResponseFuture::Detach() {
     request_state_.reset();
 }
 
-std::future_status ResponseFuture::Wait() {
+std::future_status ResponseFuture::Wait(utils::impl::SourceLocation location) {
+    utils::trx_tracker::CheckNoTransactions(location);
+
     switch (future_.wait_until(deadline_)) {
         case engine::FutureStatus::kCancelled: {
             const auto stats = request_state_->easy().get_local_stats();
@@ -122,8 +125,8 @@ std::future_status ResponseFuture::Wait() {
     UINVARIANT(false, "Invalid engine::FutureStatus");
 }
 
-std::shared_ptr<Response> ResponseFuture::Get() {
-    const auto future_status = Wait();
+std::shared_ptr<Response> ResponseFuture::Get(utils::impl::SourceLocation location) {
+    const auto future_status = Wait(location);
     if (future_status == std::future_status::ready) {
         if (request_state_->IsDeadlineExpired()) {
             server::request::MarkTaskInheritedDeadlineExpired();
diff --git a/core/src/components/manager.cpp b/core/src/components/manager.cpp
index b575b3b73be2..2a717591c0b4 100644
--- a/core/src/components/manager.cpp
+++ b/core/src/components/manager.cpp
@@ -1,11 +1,9 @@
 #include <components/manager.hpp>
 
 #include <chrono>
-#include <future>
 #include <set>
 #include <stdexcept>
 #include <thread>
-#include <type_traits>
 
 #include <fmt/core.h>
 #include <fmt/ranges.h>
@@ -23,6 +21,7 @@
 #include <userver/logging/component.hpp>
 #include <userver/logging/log.hpp>
 #include <userver/os_signals/component.hpp>
+#include <userver/tracing/span.hpp>
 #include <userver/utils/algo.hpp>
 #include <userver/utils/async.hpp>
 #include <userver/utils/distances.hpp>
@@ -143,12 +142,19 @@ void Manager::TaskProcessorsStorage::WaitForAllTasksBlocking() const noexcept {
     }
 }
 
-Manager::Manager(std::unique_ptr<ManagerConfig>&& config, const ComponentList& component_list)
+Manager::Manager(
+    std::unique_ptr<ManagerConfig>&& config,
+    std::chrono::steady_clock::time_point start_time,
+    const ComponentList& component_list
+)
     : config_(std::move(config)),
       task_processors_storage_(
           std::make_shared<engine::impl::TaskProcessorPools>(config_->coro_pool, config_->event_thread_pool)
       ),
-      start_time_(std::chrono::steady_clock::now()) {
+      start_time_(start_time),
+      pre_load_duration_(
+          std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time_)
+      ) {
     LOG_INFO() << "Starting components manager";
 
     for (auto processor_config : config_->task_processors) {
@@ -260,6 +266,8 @@ std::chrono::steady_clock::time_point Manager::GetStartTime() const { return sta
 
 std::chrono::milliseconds Manager::GetLoadDuration() const { return load_duration_; }
 
+std::chrono::milliseconds Manager::GetPreLoadDuration() const { return pre_load_duration_; }
+
 void Manager::CreateComponentContext(const ComponentList& component_list) {
     std::set<std::string> loading_component_names;
     for (const auto& adder : component_list) {
diff --git a/core/src/components/manager.hpp b/core/src/components/manager.hpp
index aae2c96dccf1..5b2f3f2d9820 100644
--- a/core/src/components/manager.hpp
+++ b/core/src/components/manager.hpp
@@ -38,7 +38,11 @@ using TaskProcessorsMap = utils::impl::TransparentMap<std::string, std::unique_p
 // to the outside world.
 class Manager final {
 public:
-    Manager(std::unique_ptr<ManagerConfig>&& config, const ComponentList& component_list);
+    Manager(
+        std::unique_ptr<ManagerConfig>&& config,
+        std::chrono::steady_clock::time_point start_time,
+        const ComponentList& component_list
+    );
     ~Manager();
 
     const ManagerConfig& GetConfig() const;
@@ -50,6 +54,8 @@ class Manager final {
 
     std::chrono::steady_clock::time_point GetStartTime() const;
 
+    std::chrono::milliseconds GetPreLoadDuration() const;
+
     std::chrono::milliseconds GetLoadDuration() const;
 
 private:
@@ -96,6 +102,7 @@ class Manager final {
 
     engine::TaskProcessor* default_task_processor_{nullptr};
     const std::chrono::steady_clock::time_point start_time_;
+    const std::chrono::milliseconds pre_load_duration_{0};
     std::chrono::milliseconds load_duration_{0};
 
     os_signals::ProcessorComponent* signal_processor_{nullptr};
diff --git a/core/src/components/manager_config.cpp b/core/src/components/manager_config.cpp
index 428dd5206b33..7378b2aad5bc 100644
--- a/core/src/components/manager_config.cpp
+++ b/core/src/components/manager_config.cpp
@@ -237,6 +237,12 @@ additionalProperties: false
             the balancer a chance to redirect new requests to other hosts and
             to give the service a chance to finish handling old requests.
         defaultDescription: 0s
+    enable_trx_tracker:
+        type: boolean
+        description: |
+            Enable checking of heavy operations (like http calls) while having
+            active database transactions.
+        defaultDescription: true
 )");
 }
 
@@ -270,6 +276,7 @@ ManagerConfig Parse(const yaml_config::YamlConfig& value, formats::parse::To<Man
     );
     config.graceful_shutdown_interval =
         value["graceful_shutdown_interval"].As<std::chrono::milliseconds>(config.graceful_shutdown_interval);
+    config.enable_trx_tracker = value["enable_trx_tracker"].As<bool>(config.enable_trx_tracker);
 
     return config;
 }
diff --git a/core/src/components/manager_config.hpp b/core/src/components/manager_config.hpp
index 2a30fc8d3cec..b69fded75f15 100644
--- a/core/src/components/manager_config.hpp
+++ b/core/src/components/manager_config.hpp
@@ -30,6 +30,7 @@ struct ManagerConfig {
     bool mlock_debug_info{true};
     bool disable_phdr_cache{false};
     bool preheat_stacktrace_collector{true};
+    bool enable_trx_tracker{true};
 
     static ManagerConfig FromString(
         const std::string&,
diff --git a/core/src/components/manager_controller_component.cpp b/core/src/components/manager_controller_component.cpp
index cc96eb213ed8..265779a41d94 100644
--- a/core/src/components/manager_controller_component.cpp
+++ b/core/src/components/manager_controller_component.cpp
@@ -8,6 +8,7 @@
 #include <userver/dynamic_config/value.hpp>
 #include <userver/logging/component.hpp>
 #include <userver/utils/algo.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 #include <dynamic_config/variables/USERVER_TASK_PROCESSOR_QOS.hpp>
 
@@ -117,6 +118,11 @@ void ManagerControllerComponent::WriteStatistics(utils::statistics::Writer& writ
                                    .count();
     writer["load-ms"] =
         std::chrono::duration_cast<std::chrono::milliseconds>(components_manager_.GetLoadDuration()).count();
+
+    writer["pre-load-ms"] =
+        std::chrono::duration_cast<std::chrono::milliseconds>(components_manager_.GetPreLoadDuration()).count();
+
+    writer["heavy-operations-in-transactions"] = utils::trx_tracker::GetStatistics().triggers;
 }
 
 void ManagerControllerComponent::OnConfigUpdate(const dynamic_config::Snapshot& cfg) {
diff --git a/core/src/components/run.cpp b/core/src/components/run.cpp
index efd55cd03948..4d9ce5bf5f7e 100644
--- a/core/src/components/run.cpp
+++ b/core/src/components/run.cpp
@@ -4,7 +4,6 @@
 
 #include <csignal>
 #include <cstring>
-#include <iostream>
 #include <variant>
 
 #include <fmt/format.h>
@@ -28,6 +27,7 @@
 #include <userver/utils/strerror.hpp>
 #include <userver/utils/string_literal.hpp>
 #include <userver/utils/traceful_exception.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 #include <components/manager.hpp>
 #include <components/manager_config.hpp>
@@ -186,6 +186,8 @@ void DoRun(
     const ComponentList& component_list,
     RunMode run_mode
 ) {
+    const auto start_time = std::chrono::steady_clock::now();
+
     utils::impl::FinishStaticRegistration();
 
     utils::SignalCatcher signal_catcher{SIGINT, SIGTERM, SIGQUIT, SIGUSR1, SIGUSR2};
@@ -201,6 +203,8 @@ void DoRun(
     utils::impl::UserverExperimentsScope experiments_scope;
     std::optional<impl::Manager> manager;
 
+    const utils::trx_tracker::impl::GlobalEnabler enabler{manager_config.enable_trx_tracker};
+
     try {
         experiments_scope.EnableOnly(manager_config.enabled_experiments);
 
@@ -209,7 +213,7 @@ void DoRun(
             PreheatStacktraceCollector();
         }
 
-        manager.emplace(std::make_unique<ManagerConfig>(std::move(manager_config)), component_list);
+        manager.emplace(std::make_unique<ManagerConfig>(std::move(manager_config)), start_time, component_list);
     } catch (const std::exception& ex) {
         LOG_ERROR() << "Loading failed: " << ex;
         throw;
diff --git a/core/src/concurrent/background_task_storage_benchmark.cpp b/core/src/concurrent/background_task_storage_benchmark.cpp
index ed042d6b1672..5344265ea08d 100644
--- a/core/src/concurrent/background_task_storage_benchmark.cpp
+++ b/core/src/concurrent/background_task_storage_benchmark.cpp
@@ -8,7 +8,7 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void background_task_storage(benchmark::State& state) {
+void BackgroundTaskStorage(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         concurrent::BackgroundTaskStorageCore bts;
 
@@ -21,6 +21,6 @@ void background_task_storage(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(background_task_storage)->Arg(2)->Arg(4)->Arg(6)->Arg(8)->Arg(12)->Arg(16)->Arg(32);
+BENCHMARK(BackgroundTaskStorage)->Arg(2)->Arg(4)->Arg(6)->Arg(8)->Arg(12)->Arg(16)->Arg(32);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/concurrent/impl/striped_intrusive_pool.hpp b/core/src/concurrent/impl/striped_intrusive_pool.hpp
index 89d90f6b6275..54d5918efc75 100644
--- a/core/src/concurrent/impl/striped_intrusive_pool.hpp
+++ b/core/src/concurrent/impl/striped_intrusive_pool.hpp
@@ -28,7 +28,7 @@ namespace concurrent::impl {
 /// `HookExtractor::GetHook` static function should get the hook subobject, given `T` node.
 /// The hook's type must be `SinglyLinkedHook<T>`.
 /// Additionally, `kHookOffset` must be `offsetof` the hook subobject within `T`.
-template <typename T, typename HookExtractor, std::ptrdiff_t kHookOffset>
+template <typename T, typename HookExtractor, std::ptrdiff_t HookOffset>
 class StripedIntrusivePool final {
 public:
     StripedIntrusivePool() = default;
@@ -51,7 +51,7 @@ class StripedIntrusivePool final {
             const auto newval = reinterpret_cast<std::intptr_t>(&node);
             UASSERT_MSG(
                 // Unfortunately, there is no legal way to check this at compile-time.
-                reinterpret_cast<std::byte*>(&GetNext(node)) - reinterpret_cast<std::byte*>(&node) == kHookOffset,
+                reinterpret_cast<std::byte*>(&GetNext(node)) - reinterpret_cast<std::byte*>(&node) == HookOffset,
                 "kHookOffset is invalid"
             );
             GetNext(node).store(reinterpret_cast<T*>(expect), std::memory_order_relaxed);
@@ -83,7 +83,7 @@ class StripedIntrusivePool final {
             const auto expectnot = reinterpret_cast<std::intptr_t>(static_cast<T*>(nullptr));
 
             const int ret = rseq_load_cbeq_store_add_load_store__ptr(
-                RSEQ_MO_RELAXED, RSEQ_PERCPU_CPU_ID, &slot, expectnot, kHookOffset, &head, cpu
+                RSEQ_MO_RELAXED, RSEQ_PERCPU_CPU_ID, &slot, expectnot, HookOffset, &head, cpu
             );
 
             if (rseq_likely(!ret)) {
diff --git a/core/src/concurrent/intrusive_walkable_pool.hpp b/core/src/concurrent/intrusive_walkable_pool.hpp
index 82449155cf17..1697870c5128 100644
--- a/core/src/concurrent/intrusive_walkable_pool.hpp
+++ b/core/src/concurrent/intrusive_walkable_pool.hpp
@@ -20,7 +20,7 @@ namespace concurrent::impl {
 /// - The element type `T` must include `IntrusiveWalkablePoolHook<T>` with `offsetof == kHookOffset`
 /// - The nodes are only destroyed on the pool destruction, so the node count is
 ///   monotonically non-decreasing
-template <typename T, typename HookExtractor, std::ptrdiff_t kHookOffset>
+template <typename T, typename HookExtractor, std::ptrdiff_t HookOffset>
 class IntrusiveWalkablePool final {
 public:
     IntrusiveWalkablePool() = default;
@@ -76,7 +76,7 @@ class IntrusiveWalkablePool final {
     using FreeListHookExtractor =
         CombinedHook<HookExtractor, MemberHook<&IntrusiveWalkablePoolHook<T>::free_list_hook>>;
     static constexpr std::ptrdiff_t kFreeListHookOffset =
-        kHookOffset + offsetof(IntrusiveWalkablePoolHook<T>, free_list_hook);
+        HookOffset + offsetof(IntrusiveWalkablePoolHook<T>, free_list_hook);
 
     IntrusiveStack<T, PermanentListHookExtractor> permanent_list_;
     StripedIntrusivePool<T, FreeListHookExtractor, kFreeListHookOffset> free_list_{};
diff --git a/core/src/concurrent/intrusive_walkable_pool_benchmark.cpp b/core/src/concurrent/intrusive_walkable_pool_benchmark.cpp
index ac530d9209de..4e234c26f317 100644
--- a/core/src/concurrent/intrusive_walkable_pool_benchmark.cpp
+++ b/core/src/concurrent/intrusive_walkable_pool_benchmark.cpp
@@ -19,7 +19,7 @@ struct IntNode final {
 
 }  // namespace
 
-void intrusive_walkable_pool(benchmark::State& state) {
+void IntrusiveWalkablePool(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         concurrent::impl::IntrusiveWalkablePool<  //
             IntNode,
@@ -36,6 +36,6 @@ void intrusive_walkable_pool(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(intrusive_walkable_pool)->Arg(1)->Arg(2)->Arg(4)->Arg(6)->Arg(8)->Arg(12)->Arg(16)->Arg(32);
+BENCHMARK(IntrusiveWalkablePool)->Arg(1)->Arg(2)->Arg(4)->Arg(6)->Arg(8)->Arg(12)->Arg(16)->Arg(32);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/concurrent/mutex_set_benchmark.cpp b/core/src/concurrent/mutex_set_benchmark.cpp
index a8ce7ff1d7fa..500ca05c61ad 100644
--- a/core/src/concurrent/mutex_set_benchmark.cpp
+++ b/core/src/concurrent/mutex_set_benchmark.cpp
@@ -27,7 +27,7 @@ T GetKeyForBenchmark(std::size_t i) {
 }
 
 template <typename T>
-void mutex_set_lock_unlock_no_contention(benchmark::State& state) {
+void MutexSetLockUnlockNoContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         concurrent::MutexSet<T> ms;
 
@@ -64,11 +64,11 @@ void mutex_set_lock_unlock_no_contention(benchmark::State& state) {
     });
 }
 
-BENCHMARK_TEMPLATE(mutex_set_lock_unlock_no_contention, int)->RangeMultiplier(2)->Range(1, 8);
-BENCHMARK_TEMPLATE(mutex_set_lock_unlock_no_contention, std::string)->RangeMultiplier(2)->Range(1, 8);
+BENCHMARK_TEMPLATE(MutexSetLockUnlockNoContention, int)->RangeMultiplier(2)->Range(1, 8);
+BENCHMARK_TEMPLATE(MutexSetLockUnlockNoContention, std::string)->RangeMultiplier(2)->Range(1, 8);
 
 template <typename T>
-void mutex_set_lock_unlock_contention(benchmark::State& state) {
+void MutexSetLockUnlockContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         concurrent::MutexSet<T> ms;
 
@@ -126,11 +126,11 @@ void mutex_set_lock_unlock_contention(benchmark::State& state) {
     });
 }
 
-BENCHMARK_TEMPLATE(mutex_set_lock_unlock_contention, int)->RangeMultiplier(2)->Range(1, 8);
-BENCHMARK_TEMPLATE(mutex_set_lock_unlock_contention, std::string)->RangeMultiplier(2)->Range(1, 8);
+BENCHMARK_TEMPLATE(MutexSetLockUnlockContention, int)->RangeMultiplier(2)->Range(1, 8);
+BENCHMARK_TEMPLATE(MutexSetLockUnlockContention, std::string)->RangeMultiplier(2)->Range(1, 8);
 
 template <typename T>
-void mutex_set_8ways_lock_unlock_contention(benchmark::State& state) {
+void MutexSet8waysLockUnlockContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         constexpr std::size_t kKeysCount = 128;
         concurrent::MutexSet<T> ms(8);
@@ -171,8 +171,8 @@ void mutex_set_8ways_lock_unlock_contention(benchmark::State& state) {
     });
 }
 
-BENCHMARK_TEMPLATE(mutex_set_8ways_lock_unlock_contention, int)->RangeMultiplier(2)->Range(1, 8);
-BENCHMARK_TEMPLATE(mutex_set_8ways_lock_unlock_contention, std::string)->RangeMultiplier(2)->Range(1, 8);
+BENCHMARK_TEMPLATE(MutexSet8waysLockUnlockContention, int)->RangeMultiplier(2)->Range(1, 8);
+BENCHMARK_TEMPLATE(MutexSet8waysLockUnlockContention, std::string)->RangeMultiplier(2)->Range(1, 8);
 
 }  // namespace
 
diff --git a/core/src/congestion_control/component.cpp b/core/src/congestion_control/component.cpp
index 1edad7334d10..3aa74206e21a 100644
--- a/core/src/congestion_control/component.cpp
+++ b/core/src/congestion_control/component.cpp
@@ -1,4 +1,5 @@
 #include <userver/congestion_control/component.hpp>
+#include <userver/congestion_control/controller.hpp>
 
 #include <congestion_control/watchdog.hpp>
 #include <userver/server/congestion_control/sensor.hpp>
@@ -168,6 +169,8 @@ server::congestion_control::Limiter& Component::GetServerLimiter() { return pimp
 
 server::congestion_control::Sensor& Component::GetServerSensor() { return pimpl_->server_sensor; }
 
+const congestion_control::Controller& Component::GetServerController() const { return pimpl_->server_controller; }
+
 yaml_config::Schema Component::GetStaticConfigSchema() {
     return yaml_config::MergeSchemas<components::ComponentBase>(R"(
 type: object
diff --git a/core/src/congestion_control/controllers/linear.cpp b/core/src/congestion_control/controllers/linear.cpp
index 986e56d92452..85c41c473875 100644
--- a/core/src/congestion_control/controllers/linear.cpp
+++ b/core/src/congestion_control/controllers/linear.cpp
@@ -1,5 +1,6 @@
 #include <userver/congestion_control/controllers/linear.hpp>
 
+#include <userver/logging/log.hpp>
 #include <userver/utils/impl/userver_experiments.hpp>
 
 USERVER_NAMESPACE_BEGIN
diff --git a/core/src/congestion_control/controllers/v2.cpp b/core/src/congestion_control/controllers/v2.cpp
index 8c0262177ac9..729308d129fd 100644
--- a/core/src/congestion_control/controllers/v2.cpp
+++ b/core/src/congestion_control/controllers/v2.cpp
@@ -1,4 +1,6 @@
 #include <userver/congestion_control/controllers/v2.hpp>
+
+#include <userver/logging/log.hpp>
 #include <userver/utils/statistics/writer.hpp>
 
 #include <fmt/format.h>
diff --git a/core/src/curl-ev/easy.hpp b/core/src/curl-ev/easy.hpp
index 1ee4672a5c5c..3961da943bf4 100644
--- a/core/src/curl-ev/easy.hpp
+++ b/core/src/curl-ev/easy.hpp
@@ -6,6 +6,8 @@
         C++ wrapper for libcurl's easy interface
 */
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 #pragma once
 
 #include <cstdio>
@@ -748,3 +750,5 @@ class easy final : public std::enable_shared_from_this<easy> {
 #undef IMPLEMENT_CURL_OPTION_GET_LIST
 
 USERVER_NAMESPACE_END
+
+// NOLINTEND(readability-identifier-naming)
diff --git a/core/src/curl-ev/error_code.hpp b/core/src/curl-ev/error_code.hpp
index 65660baa69de..a7105b0b6904 100644
--- a/core/src/curl-ev/error_code.hpp
+++ b/core/src/curl-ev/error_code.hpp
@@ -203,6 +203,8 @@ USERVER_NAMESPACE_BEGIN
 
 namespace curl::errc {
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 inline std::error_code make_error_code(EasyErrorCode e) { return {static_cast<int>(e), GetEasyCategory()}; }
 
 inline std::error_code make_error_code(MultiErrorCode e) { return {static_cast<int>(e), GetMultiCategory()}; }
@@ -215,6 +217,8 @@ inline std::error_code make_error_code(UrlErrorCode e) { return {static_cast<int
 
 inline std::error_code make_error_code(RateLimitErrorCode e) { return {static_cast<int>(e), GetRateLimitCategory()}; }
 
+// NOLINTEND(readability-identifier-naming)
+
 }  // namespace curl::errc
 
 USERVER_NAMESPACE_END
diff --git a/core/src/curl-ev/form.hpp b/core/src/curl-ev/form.hpp
index d5d0a21b673d..f0f9b147f6dc 100644
--- a/core/src/curl-ev/form.hpp
+++ b/core/src/curl-ev/form.hpp
@@ -6,6 +6,8 @@
         C++ wrapper for constructing libcurl forms
 */
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 #pragma once
 
 #include <memory>
@@ -20,7 +22,7 @@ USERVER_NAMESPACE_BEGIN
 
 namespace curl {
 
-class form {
+class form {  // NOLINT(readability-identifier-naming)
 public:
     form();
     form(const form&) = delete;
@@ -75,3 +77,5 @@ class form {
 }  // namespace curl
 
 USERVER_NAMESPACE_END
+
+// NOLINTEND(readability-identifier-naming)
diff --git a/core/src/curl-ev/multi.cpp b/core/src/curl-ev/multi.cpp
index 241a20953c30..74b8f62eafd1 100644
--- a/core/src/curl-ev/multi.cpp
+++ b/core/src/curl-ev/multi.cpp
@@ -6,6 +6,8 @@
         Integration of libcurl's multi interface with Boost.Asio
 */
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 #include <cstring>
 #include <string_view>
 #include <system_error>
@@ -388,3 +390,5 @@ void multi::handle_async() {
 }  // namespace curl
 
 USERVER_NAMESPACE_END
+
+// NOLINTEND(readability-identifier-naming)
diff --git a/core/src/curl-ev/multi.hpp b/core/src/curl-ev/multi.hpp
index 1279a6dfc14e..95a69ef0a4cc 100644
--- a/core/src/curl-ev/multi.hpp
+++ b/core/src/curl-ev/multi.hpp
@@ -6,6 +6,8 @@
         Integration of libcurl's multi interface with Boost.Asio
 */
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 #pragma once
 
 #include <functional>
@@ -32,7 +34,7 @@ namespace curl {
 class easy;
 struct socket_info;
 
-class multi final {
+class multi final {  // NOLINT(readability-identifier-naming)
 public:
     using Callback = std::function<void()>;
     multi(engine::ev::ThreadControl& thread_control, const std::shared_ptr<ConnectRateLimiter>& connect_rate_limiter);
@@ -102,3 +104,5 @@ class multi final {
 }  // namespace curl
 
 USERVER_NAMESPACE_END
+
+// NOLINTEND(readability-identifier-naming)
diff --git a/core/src/curl-ev/native.hpp b/core/src/curl-ev/native.hpp
index 3075a9be861f..126e04bdfc2d 100644
--- a/core/src/curl-ev/native.hpp
+++ b/core/src/curl-ev/native.hpp
@@ -41,6 +41,7 @@ namespace curl::native {
 
 }  // namespace curl::native
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 inline void throw_error(std::error_code ec, const char* s) {
     if (ec) throw std::system_error(ec, s);
 }
diff --git a/core/src/curl-ev/share.hpp b/core/src/curl-ev/share.hpp
index 1a49c523043c..eedf42372667 100644
--- a/core/src/curl-ev/share.hpp
+++ b/core/src/curl-ev/share.hpp
@@ -6,6 +6,8 @@
         C++ wrapper for libcurl's share interface
 */
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 #pragma once
 
 #include <memory>
@@ -16,7 +18,7 @@
 USERVER_NAMESPACE_BEGIN
 
 namespace curl {
-class share final : public std::enable_shared_from_this<share> {
+class share final : public std::enable_shared_from_this<share> {  // NOLINT(readability-identifier-naming)
 public:
     share();
     share(const share&) = delete;
@@ -46,3 +48,5 @@ class share final : public std::enable_shared_from_this<share> {
 }  // namespace curl
 
 USERVER_NAMESPACE_END
+
+// NOLINTEND(readability-identifier-naming)
diff --git a/core/src/curl-ev/socket_info.hpp b/core/src/curl-ev/socket_info.hpp
index 2ef3164deaab..d61865009727 100644
--- a/core/src/curl-ev/socket_info.hpp
+++ b/core/src/curl-ev/socket_info.hpp
@@ -16,7 +16,7 @@ namespace curl {
 
 class easy;
 
-struct socket_info {
+struct socket_info {  // NOLINT(readability-identifier-naming)
     explicit socket_info(engine::ev::ThreadControl& thread_control) : watcher(thread_control) {}
 
     ~socket_info() { UASSERT(!handle); }
diff --git a/core/src/curl-ev/string_list.hpp b/core/src/curl-ev/string_list.hpp
index 7d57c3636f9f..52a1e4ea23f7 100644
--- a/core/src/curl-ev/string_list.hpp
+++ b/core/src/curl-ev/string_list.hpp
@@ -19,7 +19,7 @@ USERVER_NAMESPACE_BEGIN
 
 namespace curl {
 
-class string_list {
+class string_list {  // NOLINT(readability-identifier-naming)
 public:
     string_list() = default;
     string_list(const string_list&) = delete;
diff --git a/core/src/curl-ev/url.hpp b/core/src/curl-ev/url.hpp
index 3757cfebd706..dfd56d300899 100644
--- a/core/src/curl-ev/url.hpp
+++ b/core/src/curl-ev/url.hpp
@@ -46,7 +46,7 @@ USERVER_NAMESPACE_BEGIN
 
 namespace curl {
 
-class url {
+class url {  // NOLINT(readability-identifier-naming)
 public:
     url();
 
diff --git a/core/src/dump/operations_encrypted.cpp b/core/src/dump/operations_encrypted.cpp
index 2cbe32f4d509..b5d3d8df56d3 100644
--- a/core/src/dump/operations_encrypted.cpp
+++ b/core/src/dump/operations_encrypted.cpp
@@ -30,10 +30,10 @@ struct EncryptedWriter::Impl {
     std::string filename;
     Encryption encryption;
     std::unique_ptr<::CryptoPP::AuthenticatedEncryptionFilter> filter;
-    utils::StreamingCpuRelax cpu_relax_;
+    utils::StreamingCpuRelax cpu_relax;
 
     Impl(std::string&& filename, tracing::ScopeTime* scope)
-        : filename(std::move(filename)), cpu_relax_(kCheckTimeAfterBytes, scope) {}
+        : filename(std::move(filename)), cpu_relax(kCheckTimeAfterBytes, scope) {}
 
     std::string GetTempFilename() const { return filename + ".tmp"; }
 };
@@ -75,7 +75,7 @@ EncryptedWriter::~EncryptedWriter() = default;
 void EncryptedWriter::WriteRaw(std::string_view data) {
     // 2. Data
     impl_->filter->Put(reinterpret_cast<const unsigned char*>(data.data()), data.size());
-    impl_->cpu_relax_.Relax(data.size());
+    impl_->cpu_relax.Relax(data.size());
 }
 
 void EncryptedWriter::Finish() {
diff --git a/core/src/dynamic_config/client/component.cpp b/core/src/dynamic_config/client/component.cpp
index a1a075508a01..c10a37744648 100644
--- a/core/src/dynamic_config/client/component.cpp
+++ b/core/src/dynamic_config/client/component.cpp
@@ -3,6 +3,7 @@
 #include <userver/clients/http/component.hpp>
 #include <userver/components/component.hpp>
 #include <userver/formats/json.hpp>
+#include <userver/logging/log.hpp>
 #include <userver/yaml_config/merge_schemas.hpp>
 
 USERVER_NAMESPACE_BEGIN
diff --git a/core/src/dynamic_config/updates_sink/component.cpp b/core/src/dynamic_config/updates_sink/component.cpp
index 8b552c727f31..50ecd1a3b433 100644
--- a/core/src/dynamic_config/updates_sink/component.cpp
+++ b/core/src/dynamic_config/updates_sink/component.cpp
@@ -13,7 +13,7 @@ USERVER_NAMESPACE_BEGIN
 namespace components {
 
 struct DynamicConfigUpdatesSinkBase::UsedByInfo {
-    concurrent::Variable<std::string> component_name_;
+    concurrent::Variable<std::string> component_name;
 };
 
 DynamicConfigUpdatesSinkBase::DynamicConfigUpdatesSinkBase(
@@ -38,7 +38,7 @@ void RegisterUpdater(
     std::string_view sink_component_name,
     std::string_view updater_component_name
 ) {
-    auto locked_ptr = sink.used_by_->component_name_.Lock();
+    auto locked_ptr = sink.used_by_->component_name.Lock();
     auto& component_name = *locked_ptr;
 
     if (component_name.empty()) {
diff --git a/core/src/engine/coro/marked_allocator.cpp b/core/src/engine/coro/marked_allocator.cpp
index 12fc367f2ab0..f1a0a0974eaa 100644
--- a/core/src/engine/coro/marked_allocator.cpp
+++ b/core/src/engine/coro/marked_allocator.cpp
@@ -8,8 +8,8 @@ static volatile const std::size_t page_size = MarkedAllocator::traits_type::page
 static volatile std::size_t allocator_stack_size = MarkedAllocator::traits_type::default_size();
 
 MarkedAllocator::MarkedAllocator(std::size_t size) : boost::coroutines2::protected_fixedsize_stack(size) {
-    auto aligment = page_size;
-    allocator_stack_size = (size + aligment - 1) / aligment * aligment;
+    auto alignment = page_size;
+    allocator_stack_size = (size + alignment - 1) / alignment * alignment;
 }
 
 }  // namespace engine::coro::debug
diff --git a/core/src/engine/coro/marked_allocator.hpp b/core/src/engine/coro/marked_allocator.hpp
index 6fc007d7ba3b..5715c3463c3f 100644
--- a/core/src/engine/coro/marked_allocator.hpp
+++ b/core/src/engine/coro/marked_allocator.hpp
@@ -9,7 +9,7 @@ namespace engine::coro::debug {
 struct MarkedAllocator : boost::coroutines2::protected_fixedsize_stack {
     MarkedAllocator(std::size_t size = traits_type::default_size());
 
-    const char kCoroutineMark[16] = "ThisIsCoroAlloc";
+    const char coroutine_mark[16] = "ThisIsCoroAlloc";
 };
 
 }  // namespace engine::coro::debug
diff --git a/core/src/engine/coro/pool.cpp b/core/src/engine/coro/pool.cpp
index 9900a16ee1c2..8fa11952e8c3 100644
--- a/core/src/engine/coro/pool.cpp
+++ b/core/src/engine/coro/pool.cpp
@@ -13,6 +13,16 @@ USERVER_NAMESPACE_BEGIN
 
 namespace engine::coro {
 
+namespace {
+bool IsStackUsageMonitorEnabled() {
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
+    auto* enable = std::getenv("USERVER_ENABLE_STACK_USAGE_MONITOR");
+    if (!enable) return true;
+    if (std::string_view(enable) == "0") return false;
+    return true;
+}
+}  // namespace
+
 Pool::Pool(PoolConfig config, Executor executor)
     : config_(FixupConfig(std::move(config))),
       executor_(executor),
@@ -26,7 +36,9 @@ Pool::Pool(PoolConfig config, Executor executor)
     UASSERT(local_coroutine_move_size_ <= config_.local_cache_size);
     const moodycamel::ProducerToken token(initial_coroutines_);
 
-    if (config_.is_stack_usage_monitor_enabled) {
+    if (!IsStackUsageMonitorEnabled()) {
+        LOG_WARNING() << "Stack usage monitor is explicitly disabled via USERVER_ENABLE_STACK_USAGE_MONITOR env var";
+    } else if (config_.is_stack_usage_monitor_enabled) {
         stack_usage_monitor_.Start();
     }
 
diff --git a/core/src/engine/coro/pool_config.cpp b/core/src/engine/coro/pool_config.cpp
index 51d567d830f4..6b4a1eb7854c 100644
--- a/core/src/engine/coro/pool_config.cpp
+++ b/core/src/engine/coro/pool_config.cpp
@@ -12,6 +12,7 @@ PoolConfig Parse(const yaml_config::YamlConfig& value, formats::parse::To<PoolCo
     config.local_cache_size = value["local_cache_size"].As<size_t>(config.local_cache_size);
     config.is_stack_usage_monitor_enabled =
         value["stack_usage_monitor_enabled"].As<bool>(config.is_stack_usage_monitor_enabled);
+
     return config;
 }
 
diff --git a/core/src/engine/coro/stack_usage_monitor.cpp b/core/src/engine/coro/stack_usage_monitor.cpp
index 1219a22b6499..72f5654126ca 100644
--- a/core/src/engine/coro/stack_usage_monitor.cpp
+++ b/core/src/engine/coro/stack_usage_monitor.cpp
@@ -113,7 +113,7 @@ std::uintptr_t GetStackBegin(const void* cb_ptr) noexcept {
 
 [[noreturn]] __attribute__((noinline)) void
 // the name is intentionally caps-ed, to be easily noticeable in the dumps
-THE_COROUTINE_OVERFLOWED_ITS_STACK() {
+THE_COROUTINE_OVERFLOWED_ITS_STACK() {  // NOLINT(readability-identifier-naming)
     // We are hitting a coroutine stack overflow, which normally would result in a
     // SIGSEGV with some hard to diagnose coredump (basically, the only
     // way to diagnose it correctly as SO is to employ some arcane knowledge:
@@ -353,7 +353,7 @@ class StackUsageMonitor::Impl final {
             monitor_thread_.join();
         }
 
-        for (auto* thread_alt_stack : threads_alt_stacks) {
+        for (auto* thread_alt_stack : threads_alt_stacks_) {
             ::munmap(thread_alt_stack, kAltStackSize);
         }
 
@@ -459,7 +459,7 @@ class StackUsageMonitor::Impl final {
 
             const std::lock_guard lock{tid_to_pthread_initialization_mutex_};
             thread_id_to_pthread_id_.emplace_back(tid, thread_id);
-            threads_alt_stacks.push_back(alt_stack);
+            threads_alt_stacks_.push_back(alt_stack);
         }
     }
 
@@ -585,7 +585,7 @@ class StackUsageMonitor::Impl final {
     // change at runtime.
     std::mutex tid_to_pthread_initialization_mutex_;
     boost::container::small_vector<std::pair<int, pthread_t>, 32> thread_id_to_pthread_id_{};
-    boost::container::small_vector<void*, 32> threads_alt_stacks{};
+    boost::container::small_vector<void*, 32> threads_alt_stacks_{};
 
     std::size_t coro_stack_size_;
     std::thread monitor_thread_;
diff --git a/core/src/engine/coro/stack_usage_monitor_benchmark.cpp b/core/src/engine/coro/stack_usage_monitor_benchmark.cpp
index 1bf9e6cdac30..d796889d9a0a 100644
--- a/core/src/engine/coro/stack_usage_monitor_benchmark.cpp
+++ b/core/src/engine/coro/stack_usage_monitor_benchmark.cpp
@@ -41,7 +41,7 @@ __attribute__((noinline)) std::uint64_t SelfLimitingRecursiveFunction() {
     return scope.Get() + SelfLimitingRecursiveFunction();
 }
 
-void create_async(benchmark::State& state, bool enable) {
+void CreateAsync(benchmark::State& state, bool enable) {
     engine::TaskProcessorPoolsConfig config;
     config.is_stack_usage_monitor_enabled = enable;
 
@@ -52,10 +52,10 @@ void create_async(benchmark::State& state, bool enable) {
 
 }  // namespace
 
-void stack_usage_monitor_on(benchmark::State& state) { create_async(state, true); }
-BENCHMARK(stack_usage_monitor_on);
+void StackUsageMonitorOn(benchmark::State& state) { CreateAsync(state, true); }
+BENCHMARK(StackUsageMonitorOn);
 
-void stack_usage_monitor_off(benchmark::State& state) { create_async(state, false); }
-BENCHMARK(stack_usage_monitor_off);
+void StackUsageMonitorOff(benchmark::State& state) { CreateAsync(state, false); }
+BENCHMARK(StackUsageMonitorOff);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/deadline_benchmark.cpp b/core/src/engine/deadline_benchmark.cpp
index 3d4f150c58fb..b3835481949e 100644
--- a/core/src/engine/deadline_benchmark.cpp
+++ b/core/src/engine/deadline_benchmark.cpp
@@ -10,14 +10,14 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
-void deadline_from_duration(benchmark::State& state, std::chrono::nanoseconds duration) {
+void DeadlineFromDuration(benchmark::State& state, std::chrono::nanoseconds duration) {
     for ([[maybe_unused]] auto _ : state) {
         auto deadline = engine::Deadline::FromDuration(duration);
         benchmark::DoNotOptimize(deadline);
     }
 }
 
-void deadline_is_reached(benchmark::State& state, std::chrono::nanoseconds duration) {
+void DeadlineIsReached(benchmark::State& state, std::chrono::nanoseconds duration) {
     auto deadline = engine::Deadline::FromDuration(duration);
     for ([[maybe_unused]] auto _ : state) {
         bool is_reached = deadline.IsReached();
@@ -25,31 +25,27 @@ void deadline_is_reached(benchmark::State& state, std::chrono::nanoseconds durat
     }
 }
 
-void deadline_1us_interval_construction(benchmark::State& state) {
-    deadline_from_duration(state, std::chrono::microseconds{1});
+void Deadline1usIntervalConstruction(benchmark::State& state) {
+    DeadlineFromDuration(state, std::chrono::microseconds{1});
 }
 
-void deadline_20ms_interval_construction(benchmark::State& state) {
-    deadline_from_duration(state, std::chrono::milliseconds{20});
+void Deadline20msIntervalConstruction(benchmark::State& state) {
+    DeadlineFromDuration(state, std::chrono::milliseconds{20});
 }
 
-void deadline_1us_interval_reached(benchmark::State& state) {
-    deadline_is_reached(state, std::chrono::microseconds{1});
-}
+void Deadline1usIntervalReached(benchmark::State& state) { DeadlineIsReached(state, std::chrono::microseconds{1}); }
 
-void deadline_20ms_interval_reached(benchmark::State& state) {
-    deadline_is_reached(state, std::chrono::milliseconds{20});
-}
+void Deadline20msIntervalReached(benchmark::State& state) { DeadlineIsReached(state, std::chrono::milliseconds{20}); }
 
-void deadline_100s_interval_reached(benchmark::State& state) { deadline_is_reached(state, std::chrono::seconds{100}); }
+void Deadline100sIntervalReached(benchmark::State& state) { DeadlineIsReached(state, std::chrono::seconds{100}); }
 
 }  // namespace
 
-BENCHMARK(deadline_1us_interval_construction);
-BENCHMARK(deadline_20ms_interval_construction);
+BENCHMARK(Deadline1usIntervalConstruction);
+BENCHMARK(Deadline20msIntervalConstruction);
 
-BENCHMARK(deadline_1us_interval_reached);
-BENCHMARK(deadline_20ms_interval_reached);
-BENCHMARK(deadline_100s_interval_reached);
+BENCHMARK(Deadline1usIntervalReached);
+BENCHMARK(Deadline20msIntervalReached);
+BENCHMARK(Deadline100sIntervalReached);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/ev/watcher_benchmark.cpp b/core/src/engine/ev/watcher_benchmark.cpp
index d9da8051b589..2a80a0312f0c 100644
--- a/core/src/engine/ev/watcher_benchmark.cpp
+++ b/core/src/engine/ev/watcher_benchmark.cpp
@@ -34,7 +34,7 @@ namespace ev = engine::ev;
 
 }  // namespace
 
-void watcher_async_start(benchmark::State& state) {
+void WatcherAsyncStart(benchmark::State& state) {
     engine::RunStandalone([&]() {
         Pipe pipe;
         ev::Watcher<ev_io> watcher{engine::current_task::GetEventThread(), &pipe};
@@ -46,9 +46,9 @@ void watcher_async_start(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(watcher_async_start);
+BENCHMARK(WatcherAsyncStart);
 
-void watcher_async_start_multiple(benchmark::State& state) {
+void WatcherAsyncStartMultiple(benchmark::State& state) {
     engine::RunStandalone([&]() {
         static constexpr unsigned kPipes = 8;
         Pipe pipes[kPipes];
@@ -68,6 +68,6 @@ void watcher_async_start_multiple(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(watcher_async_start_multiple);
+BENCHMARK(WatcherAsyncStartMultiple);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/future_benchmark.cpp b/core/src/engine/future_benchmark.cpp
index f839fecfae10..7a0cddbf1d13 100644
--- a/core/src/engine/future_benchmark.cpp
+++ b/core/src/engine/future_benchmark.cpp
@@ -104,7 +104,7 @@ struct FutureCoroSetGet {
 
 }  // namespace
 
-void future_std_single_threaded(benchmark::State& state) {
+void FutureStdSingleThreaded(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         std::promise<int> promise;
         auto future = promise.get_future();
@@ -112,9 +112,9 @@ void future_std_single_threaded(benchmark::State& state) {
         benchmark::DoNotOptimize(future.get());
     }
 }
-BENCHMARK(future_std_single_threaded);
+BENCHMARK(FutureStdSingleThreaded);
 
-void future_coro_single_threaded(benchmark::State& state) {
+void FutureCoroSingleThreaded(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             engine::Promise<int> promise;
@@ -124,16 +124,16 @@ void future_coro_single_threaded(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(future_coro_single_threaded);
+BENCHMARK(FutureCoroSingleThreaded);
 
-void future_std_set_and_get(benchmark::State& state) {
+void FutureStdSetAndGet(benchmark::State& state) {
     engine::RunStandalone(2, [&] { RunPrepared<FutureStdSetGet>(state); });
 }
-BENCHMARK(future_std_set_and_get);
+BENCHMARK(FutureStdSetAndGet);
 
-void future_coro_set_and_get(benchmark::State& state) {
+void FutureCoroSetAndGet(benchmark::State& state) {
     engine::RunStandalone(2, [&] { RunPrepared<FutureCoroSetGet>(state); });
 }
-BENCHMARK(future_coro_set_and_get);
+BENCHMARK(FutureCoroSetAndGet);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/impl/mutex_impl.hpp b/core/src/engine/impl/mutex_impl.hpp
index c605624825f5..a9c3aa0709dd 100644
--- a/core/src/engine/impl/mutex_impl.hpp
+++ b/core/src/engine/impl/mutex_impl.hpp
@@ -37,8 +37,6 @@ class MutexImpl {
 private:
     class MutexWaitStrategy;
 
-    bool TryLockWithTaskContext(TaskContext& current);
-
     bool LockFastPath(TaskContext&) noexcept;
     bool LockSlowPath(TaskContext&, Deadline);
 
@@ -54,7 +52,7 @@ class MutexImpl<WaitList>::MutexWaitStrategy final : public WaitStrategy {
 
     EarlyWakeup SetupWakeups() override {
         WaitList::Lock lock(mutex_.lock_waiters_);
-        if (mutex_.TryLockWithTaskContext(current_)) {
+        if (mutex_.LockFastPath(current_)) {
             return EarlyWakeup{true};
         }
         // A race is not possible here, because check + Append is performed under
@@ -175,17 +173,11 @@ void MutexImpl<Waiters>::unlock() {
 template <class Waiters>
 bool MutexImpl<Waiters>::try_lock() {
     auto& current = current_task::GetCurrentTaskContext();
-    return TryLockWithTaskContext(current);
-}
 
-template <class Waiters>
-bool MutexImpl<Waiters>::TryLockWithTaskContext(TaskContext& current) {
 #if USERVER_IMPL_HAS_TSAN
     __tsan_mutex_pre_lock(this, __tsan_mutex_try_lock);
 #endif
-
     const auto result = LockFastPath(current);
-
 #if USERVER_IMPL_HAS_TSAN
     __tsan_mutex_post_lock(this, __tsan_mutex_try_lock | (result ? 0 : __tsan_mutex_try_lock_failed), 0);
 #endif
diff --git a/core/src/engine/impl/wait_list_benchmark.cpp b/core/src/engine/impl/wait_list_benchmark.cpp
index 711a7ec3bfaf..93c5b16184dc 100644
--- a/core/src/engine/impl/wait_list_benchmark.cpp
+++ b/core/src/engine/impl/wait_list_benchmark.cpp
@@ -42,7 +42,7 @@ auto MakeContexts() {
 
 }  // namespace
 
-void wait_list_insertion(benchmark::State& state) {
+void WaitListInsertion(benchmark::State& state) {
     engine::RunStandalone([&] {
         std::size_t i = 0;
         WaitList wl;
@@ -69,9 +69,9 @@ void wait_list_insertion(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(wait_list_insertion)->Iterations(kIterationsCount);
+BENCHMARK(WaitListInsertion)->Iterations(kIterationsCount);
 
-void wait_list_removal(benchmark::State& state) {
+void WaitListRemoval(benchmark::State& state) {
     engine::RunStandalone([&] {
         WaitList wl;
 
@@ -104,9 +104,9 @@ void wait_list_removal(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(wait_list_removal)->Iterations(kIterationsCount);
+BENCHMARK(WaitListRemoval)->Iterations(kIterationsCount);
 
-void wait_list_add_remove_contention(benchmark::State& state) {
+void WaitListAddRemoveContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::atomic<bool> run{true};
         WaitList wl;
@@ -139,9 +139,9 @@ void wait_list_add_remove_contention(benchmark::State& state) {
         run = false;
     });
 }
-BENCHMARK(wait_list_add_remove_contention)->RangeMultiplier(2)->Range(1, 2)->UseRealTime();
+BENCHMARK(WaitListAddRemoveContention)->RangeMultiplier(2)->Range(1, 2)->UseRealTime();
 
-void wait_list_add_remove_contention_unbalanced(benchmark::State& state) {
+void WaitListAddRemoveContentionUnbalanced(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::atomic<bool> run{true};
         WaitList wl;
@@ -189,7 +189,7 @@ void wait_list_add_remove_contention_unbalanced(benchmark::State& state) {
 // threads an opportunity to work on the WaitList. On top of it, for a benchmark
 // iteration to complete, the rare ownership switch is required to have occurred
 // A LOT of times (once per TaskContext).
-BENCHMARK(wait_list_add_remove_contention_unbalanced)
+BENCHMARK(WaitListAddRemoveContentionUnbalanced)
     ->RangeMultiplier(2)
     ->Range(1, 1)
     ->Unit(benchmark::kMillisecond)
diff --git a/core/src/engine/io/fd_control_benchmark.cpp b/core/src/engine/io/fd_control_benchmark.cpp
index c721e1cbf8c3..6024dd185543 100644
--- a/core/src/engine/io/fd_control_benchmark.cpp
+++ b/core/src/engine/io/fd_control_benchmark.cpp
@@ -32,7 +32,7 @@ using FdControl = io::impl::FdControl;
 
 }  // namespace
 
-void fd_control_destroy(benchmark::State& state) {
+void FdControlDestroy(benchmark::State& state) {
     engine::RunStandalone([&]() {
         for ([[maybe_unused]] auto _ : state) {
             state.PauseTiming();
@@ -45,9 +45,9 @@ void fd_control_destroy(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(fd_control_destroy);
+BENCHMARK(FdControlDestroy);
 
-void fd_control_close_destroy(benchmark::State& state) {
+void FdControlCloseDestroy(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             state.PauseTiming();
@@ -61,9 +61,9 @@ void fd_control_close_destroy(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(fd_control_close_destroy);
+BENCHMARK(FdControlCloseDestroy);
 
-void fd_control_wait_destroy(benchmark::State& state) {
+void FdControlWaitDestroy(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             state.PauseTiming();
@@ -77,9 +77,9 @@ void fd_control_wait_destroy(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(fd_control_wait_destroy);
+BENCHMARK(FdControlWaitDestroy);
 
-void fd_control_construct_wait_destroy(benchmark::State& state) {
+void FdControlConstructWaitDestroy(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             state.PauseTiming();
@@ -92,6 +92,6 @@ void fd_control_construct_wait_destroy(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(fd_control_construct_wait_destroy);
+BENCHMARK(FdControlConstructWaitDestroy);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/io/fd_poller.cpp b/core/src/engine/io/fd_poller.cpp
index 37743f64d37f..8d7cb04a300f 100644
--- a/core/src/engine/io/fd_poller.cpp
+++ b/core/src/engine/io/fd_poller.cpp
@@ -83,38 +83,38 @@ struct FdPoller::Impl final : public engine::impl::ContextAccessor {
     static void IoWatcherCb(struct ev_loop*, ev_io*, int) noexcept;
     void WakeupWaiters();
 
-    void ResetReady() noexcept { waiters_->GetAndResetSignal(); }
+    void ResetReady() noexcept { waiters->GetAndResetSignal(); }
 
     // ContextAccessor implementation
-    bool IsReady() const noexcept override { return waiters_->IsSignaled(); }
+    bool IsReady() const noexcept override { return waiters->IsSignaled(); }
 
     engine::impl::EarlyWakeup TryAppendWaiter(engine::impl::TaskContext& waiter) override {
-        if (waiters_->GetSignalOrAppend(&waiter)) {
+        if (waiters->GetSignalOrAppend(&waiter)) {
             return engine::impl::EarlyWakeup{true};
         }
-        watcher_.StartAsync();
+        watcher.StartAsync();
         return engine::impl::EarlyWakeup{false};
     }
 
     void RemoveWaiter(engine::impl::TaskContext& waiter) noexcept override {
-        waiters_->Remove(waiter);
+        waiters->Remove(waiter);
         // we need to stop watcher manually to avoid racy wakeups later
-        watcher_.StopAsync();
+        watcher.StopAsync();
     }
 
-    void AfterWait() noexcept override { watcher_.Stop(); }
+    void AfterWait() noexcept override { watcher.Stop(); }
 
     void RethrowErrorResult() const override {}
 
-    std::atomic<FdPoller::State> state_{FdPoller::State::kInvalid};
-    engine::impl::FastPimplWaitListLight waiters_;
-    ev::Watcher<ev_io> watcher_;
-    std::atomic<FdPoller::Kind> events_that_happened_{};
+    std::atomic<FdPoller::State> state{FdPoller::State::kInvalid};
+    engine::impl::FastPimplWaitListLight waiters;
+    ev::Watcher<ev_io> watcher;
+    std::atomic<FdPoller::Kind> events_that_happened{};
 };
 
-void FdPoller::Impl::WakeupWaiters() { waiters_->SetSignalAndWakeupOne(); }
+void FdPoller::Impl::WakeupWaiters() { waiters->SetSignalAndWakeupOne(); }
 
-FdPoller::Impl::Impl(ev::ThreadControl control) : watcher_(control, this) { watcher_.Init(&IoWatcherCb); }
+FdPoller::Impl::Impl(ev::ThreadControl control) : watcher(control, this) { watcher.Init(&IoWatcherCb); }
 
 FdPoller::Impl::~Impl() = default;
 
@@ -130,7 +130,7 @@ engine::impl::TaskContext::WakeupSource FdPoller::Impl::DoWait(Deadline deadline
      * Manually call Stop() here to be sure that after DoWait() no waiter_'s
      * callback (IoWatcherCb) is running.
      */
-    watcher_.Stop();
+    watcher.Stop();
     return ret;
 }
 
@@ -138,7 +138,7 @@ void FdPoller::Impl::Invalidate() {
     StopWatcher();
 
     auto old_state = State::kReadyToUse;
-    const auto res = state_.compare_exchange_strong(old_state, State::kInvalid);
+    const auto res = state.compare_exchange_strong(old_state, State::kInvalid);
 
     UINVARIANT(
         res,
@@ -148,7 +148,7 @@ void FdPoller::Impl::Invalidate() {
 
 void FdPoller::Impl::StopWatcher() noexcept {
     UASSERT(IsValid());
-    watcher_.Stop();
+    watcher.Stop();
 }
 
 void FdPoller::Impl::IoWatcherCb(struct ev_loop*, ev_io* watcher, int) noexcept {
@@ -161,13 +161,13 @@ void FdPoller::Impl::IoWatcherCb(struct ev_loop*, ev_io* watcher, int) noexcept
 
     // Cleanup watcher_ first, then awake the coroutine.
     // Otherwise, the coroutine may close watcher_'s fd before watcher_ is stopped.
-    const auto guard = self->watcher_.StopWithinEvCallback();
+    const auto guard = self->watcher.StopWithinEvCallback();
 
-    self->events_that_happened_.store(GetUserMode(ev_events), std::memory_order_relaxed);
+    self->events_that_happened.store(GetUserMode(ev_events), std::memory_order_relaxed);
     self->WakeupWaiters();
 }
 
-bool FdPoller::Impl::IsValid() const noexcept { return state_ != State::kInvalid; }
+bool FdPoller::Impl::IsValid() const noexcept { return state != State::kInvalid; }
 
 FdPoller::FdPoller(const ev::ThreadControl& control) : pimpl_(control) {
     static_assert(std::atomic<State>::is_always_lock_free);
@@ -179,20 +179,20 @@ FdPoller::operator bool() const noexcept { return IsValid(); }
 
 bool FdPoller::IsValid() const noexcept { return pimpl_->IsValid(); }
 
-int FdPoller::GetFd() const noexcept { return pimpl_->watcher_.GetFd(); }
+int FdPoller::GetFd() const noexcept { return pimpl_->watcher.GetFd(); }
 
 std::optional<FdPoller::Kind> FdPoller::Wait(Deadline deadline) {
     ResetReady();
     if (pimpl_->DoWait(deadline) == engine::impl::TaskContext::WakeupSource::kWaitList) {
-        return pimpl_->events_that_happened_.load(std::memory_order_relaxed);
+        return pimpl_->events_that_happened.load(std::memory_order_relaxed);
     } else {
         return std::nullopt;
     }
 }
 
 std::optional<FdPoller::Kind> FdPoller::GetReady() noexcept {
-    if (pimpl_->waiters_->GetAndResetSignal()) {
-        return pimpl_->events_that_happened_.load(std::memory_order_relaxed);
+    if (pimpl_->waiters->GetAndResetSignal()) {
+        return pimpl_->events_that_happened.load(std::memory_order_relaxed);
     } else {
         return std::nullopt;
     }
@@ -208,7 +208,7 @@ void FdPoller::WakeupWaiters() { pimpl_->WakeupWaiters(); }
 
 void FdPoller::SwitchStateToInUse() {
     auto old_state = State::kReadyToUse;
-    const auto res = pimpl_->state_.compare_exchange_strong(old_state, State::kInUse);
+    const auto res = pimpl_->state.compare_exchange_strong(old_state, State::kInUse);
 
     UASSERT_MSG(
         res,
@@ -218,7 +218,7 @@ void FdPoller::SwitchStateToInUse() {
 
 void FdPoller::SwitchStateToReadyToUse() {
     auto old_state = State::kInUse;
-    const auto res = pimpl_->state_.compare_exchange_strong(old_state, State::kReadyToUse);
+    const auto res = pimpl_->state.compare_exchange_strong(old_state, State::kReadyToUse);
     UASSERT_MSG(
         res, fmt::format("Socket misuse: expected socket state is '{}', actual state is '{}'", State::kInUse, old_state)
     );
@@ -226,9 +226,9 @@ void FdPoller::SwitchStateToReadyToUse() {
 
 void FdPoller::Impl::Reset(int fd, Kind kind) {
     UASSERT(!IsValid());
-    UASSERT(watcher_.GetFd() == fd || watcher_.GetFd() == -1);
-    watcher_.Set(fd, GetEvMode(kind));
-    state_ = State::kReadyToUse;
+    UASSERT(watcher.GetFd() == fd || watcher.GetFd() == -1);
+    watcher.Set(fd, GetEvMode(kind));
+    state = State::kReadyToUse;
 }
 
 void FdPoller::ResetReady() noexcept { pimpl_->ResetReady(); }
diff --git a/core/src/engine/io/poller.cpp b/core/src/engine/io/poller.cpp
index 24fc7d741fd8..6717a9ec02cd 100644
--- a/core/src/engine/io/poller.cpp
+++ b/core/src/engine/io/poller.cpp
@@ -109,11 +109,11 @@ void Poller::RemoveImpl(Poller::IoWatcher& watcher) {
 }
 
 Poller::Status Poller::NextEvent(Event& buf, Deadline deadline) {
-    return EventsFilter([this, deadline](Event& buf_) { return event_consumer_.Pop(buf_, deadline); }, buf);
+    return EventsFilter([this, deadline](Event& l_buf) { return event_consumer_.Pop(l_buf, deadline); }, buf);
 }
 
 Poller::Status Poller::NextEventNoblock(Event& buf) {
-    return EventsFilter([this](Event& buf_) { return event_consumer_.PopNoblock(buf_); }, buf);
+    return EventsFilter([this](Event& l_buf) { return event_consumer_.PopNoblock(l_buf); }, buf);
 }
 
 void Poller::Interrupt() {
diff --git a/core/src/engine/io/socket_benchmark.cpp b/core/src/engine/io/socket_benchmark.cpp
index 14b62159570a..95c27ab73704 100644
--- a/core/src/engine/io/socket_benchmark.cpp
+++ b/core/src/engine/io/socket_benchmark.cpp
@@ -25,7 +25,7 @@ constexpr auto kDeadlineMaxTime = std::chrono::seconds{60};
 
 }  // namespace
 
-void socket_send_all(benchmark::State& state) {
+void SocketSendAll(benchmark::State& state) {
     engine::RunStandalone([&]() {
         const auto test_deadline = Deadline::FromDuration(kDeadlineMaxTime);
         internal::net::TcpListener listener;
@@ -49,9 +49,9 @@ void socket_send_all(benchmark::State& state) {
         task_reader.Get();
     });
 }
-BENCHMARK(socket_send_all);
+BENCHMARK(SocketSendAll);
 
-void socket_send_all_v(benchmark::State& state) {
+void SocketSendAllV(benchmark::State& state) {
     engine::RunStandalone([&]() {
         const auto test_deadline = Deadline::FromDuration(kDeadlineMaxTime);
         internal::net::TcpListener listener;
@@ -73,9 +73,9 @@ void socket_send_all_v(benchmark::State& state) {
         task_reader.Get();
     });
 }
-BENCHMARK(socket_send_all_v);
+BENCHMARK(SocketSendAllV);
 
-[[maybe_unused]] void socket_send_all_v_range(benchmark::State& state) {
+[[maybe_unused]] void SocketSendAllVRange(benchmark::State& state) {
     engine::RunStandalone(2, [&]() {
         const auto test_deadline = Deadline::FromDuration(kDeadlineMaxTime);
         internal::net::TcpListener listener;
@@ -105,7 +105,7 @@ BENCHMARK(socket_send_all_v);
 // TODO(TAXICOMMON-5510) flaky, sometimes throws engine::io::IoTimeout
 // BENCHMARK(socket_send_all_v_range)->RangeMultiplier(10)->Range(10, 10000);
 
-[[maybe_unused]] void socket_send_all_range(benchmark::State& state) {
+[[maybe_unused]] void SocketSendAllRange(benchmark::State& state) {
     engine::RunStandalone(2, [&]() {
         const auto test_deadline = Deadline::FromDuration(kDeadlineMaxTime);
         internal::net::TcpListener listener;
diff --git a/core/src/engine/io/tls_wrapper.cpp b/core/src/engine/io/tls_wrapper.cpp
index ccd4890aef31..a0b78aa1d373 100644
--- a/core/src/engine/io/tls_wrapper.cpp
+++ b/core/src/engine/io/tls_wrapper.cpp
@@ -21,11 +21,6 @@ USERVER_NAMESPACE_BEGIN
 namespace engine::io {
 namespace {
 
-struct SslCtxDeleter {
-    void operator()(SSL_CTX* ctx) const noexcept { SSL_CTX_free(ctx); }
-};
-using SslCtx = std::unique_ptr<SSL_CTX, SslCtxDeleter>;
-
 struct SslDeleter {
     void operator()(SSL* ssl) const noexcept { SSL_free(ssl); }
 };
@@ -190,65 +185,11 @@ int SSL_write_ex(SSL* ssl, const void* data, size_t len, size_t* bytes_written)
 }
 #endif
 
-SslCtx MakeSslCtx() {
-    crypto::Openssl::Init();
-
-    SslCtx ssl_ctx{SSL_CTX_new(SSLv23_method())};
-    if (!ssl_ctx) {
-        throw TlsException(crypto::FormatSslError("Failed create an SSL context: SSL_CTX_new"));
-    }
-#if OPENSSL_VERSION_NUMBER >= 0x010100000L
-    if (1 != SSL_CTX_set_min_proto_version(ssl_ctx.get(), TLS1_VERSION)) {
-        throw TlsException(crypto::FormatSslError("Failed create an SSL context: SSL_CTX_set_min_proto_version"));
-    }
-#endif
-
-    constexpr auto options = SSL_OP_ALL | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_COMPRESSION
-#if OPENSSL_VERSION_NUMBER >= 0x010100000L
-                             | SSL_OP_NO_RENEGOTIATION
-#endif
-        ;
-    SSL_CTX_set_options(ssl_ctx.get(), options);
-    SSL_CTX_set_mode(ssl_ctx.get(), SSL_MODE_ENABLE_PARTIAL_WRITE);
-    SSL_CTX_clear_mode(ssl_ctx.get(), SSL_MODE_AUTO_RETRY);
-    if (1 != SSL_CTX_set_default_verify_paths(ssl_ctx.get())) {
-        LOG_LIMITED_WARNING() << crypto::FormatSslError("Failed create an SSL context: SSL_CTX_set_default_verify_paths"
-        );
-    }
-    return ssl_ctx;
-}
-
 enum InterruptAction {
     kPass,
     kFail,
 };
 
-void SetServerName(SslCtx& ctx, std::string_view server_name) {
-    if (server_name.empty()) {
-        return;
-    }
-
-    X509_VERIFY_PARAM* verify_param = SSL_CTX_get0_param(ctx.get());
-    if (!verify_param) {
-        throw TlsException("Failed to set up client TLS wrapper: SSL_CTX_get0_param");
-    }
-    if (1 != X509_VERIFY_PARAM_set1_host(verify_param, server_name.data(), server_name.size())) {
-        throw TlsException(crypto::FormatSslError("Failed to set up client TLS wrapper: X509_VERIFY_PARAM_set1_host"));
-    }
-    SSL_CTX_set_verify(ctx.get(), SSL_VERIFY_PEER, nullptr);
-}
-
-void AddCertAuthorities(SslCtx& ctx, const std::vector<crypto::Certificate>& cert_authorities) {
-    UASSERT(!cert_authorities.empty());
-    auto* store = SSL_CTX_get_cert_store(ctx.get());
-    UASSERT(store);
-    for (const auto& ca : cert_authorities) {
-        if (1 != X509_STORE_add_cert(store, ca.GetNative())) {
-            throw TlsException(crypto::FormatSslError("Failed to set up client TLS wrapper: X509_STORE_add_cert"));
-        }
-    }
-}
-
 }  // namespace
 
 class TlsWrapper::ReadContextAccessor final : public engine::impl::ContextAccessor {
@@ -267,7 +208,7 @@ class TlsWrapper::ReadContextAccessor final : public engine::impl::ContextAccess
 
     engine::impl::ContextAccessor& GetSocketContextAccessor() const noexcept;
 
-    TlsWrapper::Impl& impl_;
+    TlsWrapper::Impl& impl;
 };
 
 class TlsWrapper::Impl {
@@ -284,7 +225,7 @@ class TlsWrapper::Impl {
         SyncBioData(SSL_get_rbio(ssl.get()), &other.bio_data);
     }
 
-    void SetUp(SslCtx&& ssl_ctx) {
+    void SetUp(const crypto::SslCtx& ssl_ctx) {
         Bio socket_bio{BIO_new(GetSocketBioMethod())};
         if (!socket_bio) {
             throw TlsException(crypto::FormatSslError("Failed to set up TLS wrapper: BIO_new"));
@@ -293,7 +234,7 @@ class TlsWrapper::Impl {
         SyncBioData(socket_bio.get(), nullptr);
         BIO_set_init(socket_bio.get(), 1);
 
-        ssl.reset(SSL_new(ssl_ctx.get()));
+        ssl.reset(SSL_new(static_cast<SSL_CTX*>(ssl_ctx.GetRawSslCtx())));
         if (!ssl) {
             throw TlsException(crypto::FormatSslError("Failed to set up TLS wrapper: SSL_new"));
         }
@@ -329,6 +270,41 @@ class TlsWrapper::Impl {
         }
     }
 
+    template <typename SslIoFunc>
+    std::optional<size_t> PerformSslIoOptional(SslIoFunc&& io_func, void* buf, size_t len, const char* context) {
+        UASSERT(ssl);
+        if (!len) return 0;
+
+        char* const begin = static_cast<char*>(buf);
+        char* const end = begin + len;
+        size_t chunk_size = 0;
+
+        bio_data.current_deadline = Deadline::Passed();
+
+        const int io_ret = io_func(ssl.get(), begin, end - begin, &chunk_size);
+        if (io_ret == 1) {
+            return chunk_size;
+        }
+
+        const int ssl_error = SSL_get_error(ssl.get(), io_ret);
+        switch (ssl_error) {
+            case SSL_ERROR_WANT_READ:
+            case SSL_ERROR_WANT_WRITE:
+                return std::nullopt;
+
+            case SSL_ERROR_ZERO_RETURN:
+                return 0;
+
+            case SSL_ERROR_SYSCALL:
+            case SSL_ERROR_SSL:
+                ssl.reset();
+                [[fallthrough]];
+
+            default:
+                throw TlsException(crypto::FormatSslError(std::string{context} + " failed"));
+        }
+    }
+
     template <typename SslIoFunc>
     size_t PerformSslIo(
         SslIoFunc&& io_func,
@@ -422,16 +398,16 @@ class TlsWrapper::Impl {
     }
 };
 
-TlsWrapper::ReadContextAccessor::ReadContextAccessor(TlsWrapper::Impl& impl) : impl_(impl) {}
+TlsWrapper::ReadContextAccessor::ReadContextAccessor(TlsWrapper::Impl& impl) : impl(impl) {}
 
 bool TlsWrapper::ReadContextAccessor::IsReady() const noexcept {
-    auto* ssl = impl_.ssl.get();
+    auto* ssl = impl.ssl.get();
     if (!ssl || SSL_has_pending(ssl)) return true;
     return GetSocketContextAccessor().IsReady();
 }
 
 engine::impl::EarlyWakeup TlsWrapper::ReadContextAccessor::TryAppendWaiter(engine::impl::TaskContext& waiter) {
-    auto* ssl = impl_.ssl.get();
+    auto* ssl = impl.ssl.get();
     if (!ssl || SSL_has_pending(ssl)) return engine::impl::EarlyWakeup{true};
 
     return GetSocketContextAccessor().TryAppendWaiter(waiter);
@@ -446,7 +422,7 @@ void TlsWrapper::ReadContextAccessor::AfterWait() noexcept { GetSocketContextAcc
 void TlsWrapper::ReadContextAccessor::RethrowErrorResult() const { GetSocketContextAccessor().RethrowErrorResult(); }
 
 engine::impl::ContextAccessor& TlsWrapper::ReadContextAccessor::GetSocketContextAccessor() const noexcept {
-    auto* ca = impl_.bio_data.socket.GetReadableBase().TryGetContextAccessor();
+    auto* ca = impl.bio_data.socket.GetReadableBase().TryGetContextAccessor();
     UASSERT(ca);
     return *ca;
 }
@@ -454,11 +430,8 @@ engine::impl::ContextAccessor& TlsWrapper::ReadContextAccessor::GetSocketContext
 TlsWrapper::TlsWrapper(Socket&& socket) : impl_(std::move(socket)) { SetupContextAccessors(); }
 
 TlsWrapper TlsWrapper::StartTlsClient(Socket&& socket, const std::string& server_name, Deadline deadline) {
-    auto ssl_ctx = MakeSslCtx();
-    SetServerName(ssl_ctx, server_name);
-
     TlsWrapper wrapper{std::move(socket)};
-    wrapper.impl_->SetUp(std::move(ssl_ctx));
+    wrapper.impl_->SetUp(crypto::SslCtx::CreateClientTlsContext(server_name));
     wrapper.impl_->ClientConnect(server_name, deadline);
     return wrapper;
 }
@@ -471,79 +444,15 @@ TlsWrapper TlsWrapper::StartTlsClient(
     Deadline deadline,
     const std::vector<crypto::Certificate>& extra_cert_authorities
 ) {
-    auto ssl_ctx = MakeSslCtx();
-    SetServerName(ssl_ctx, server_name);
-
-    if (!extra_cert_authorities.empty()) {
-        AddCertAuthorities(ssl_ctx, extra_cert_authorities);
-    }
-
-    if (cert) {
-        if (1 != SSL_CTX_use_certificate(ssl_ctx.get(), cert.GetNative())) {
-            throw TlsException(crypto::FormatSslError("Failed to set up client TLS wrapper: SSL_CTX_use_certificate"));
-        }
-    }
-
-    if (key) {
-        if (1 != SSL_CTX_use_PrivateKey(ssl_ctx.get(), key.GetNative())) {
-            throw TlsException(crypto::FormatSslError("Failed to set up client TLS wrapper: SSL_CTX_use_PrivateKey"));
-        }
-    }
-
     TlsWrapper wrapper{std::move(socket)};
-    wrapper.impl_->SetUp(std::move(ssl_ctx));
+    wrapper.impl_->SetUp(crypto::SslCtx::CreateClientTlsContext(server_name, cert, key, extra_cert_authorities));
     wrapper.impl_->ClientConnect(server_name, deadline);
     return wrapper;
 }
 
-TlsWrapper TlsWrapper::StartTlsServer(
-    Socket&& socket,
-    const crypto::CertificatesChain& cert_chain,
-    const crypto::PrivateKey& key,
-    Deadline deadline,
-    const std::vector<crypto::Certificate>& extra_cert_authorities
-) {
-    auto ssl_ctx = MakeSslCtx();
-
-    if (!extra_cert_authorities.empty()) {
-        AddCertAuthorities(ssl_ctx, extra_cert_authorities);
-        SSL_CTX_set_verify(ssl_ctx.get(), SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
-        LOG_INFO() << "Client SSL cert will be verified";
-    } else {
-        LOG_INFO() << "Client SSL cert will not be verified";
-    }
-
-    if (cert_chain.empty()) {
-        throw TlsException(crypto::FormatSslError("Empty certificate chain provided"));
-    }
-
-    if (1 != SSL_CTX_use_certificate(ssl_ctx.get(), cert_chain.begin()->GetNative())) {
-        throw TlsException(crypto::FormatSslError("Failed to set up server TLS wrapper: SSL_CTX_use_certificate"));
-    }
-
-    if (cert_chain.size() > 1) {
-        auto cert_it = std::next(cert_chain.begin());
-        for (; cert_it != cert_chain.end(); ++cert_it) {
-            // cast in openssl1.0 macro expansion
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
-            if (SSL_CTX_add_extra_chain_cert(ssl_ctx.get(), cert_it->GetNative()) <= 0) {
-                throw TlsException(
-                    crypto::FormatSslError("Failed to set up server TLS wrapper: SSL_CTX_add_extra_chain_cert")
-                );
-            }
-
-            // After SSL_CTX_add_extra_chain_cert we should not free the cert
-            const auto ret = X509_up_ref(cert_it->GetNative());
-            UASSERT(ret == 1);
-        }
-    }
-
-    if (1 != SSL_CTX_use_PrivateKey(ssl_ctx.get(), key.GetNative())) {
-        throw TlsException(crypto::FormatSslError("Failed to set up server TLS wrapper: SSL_CTX_use_PrivateKey"));
-    }
-
+TlsWrapper TlsWrapper::StartTlsServer(Socket&& socket, const crypto::SslCtx& ctx, Deadline deadline) {
     TlsWrapper wrapper{std::move(socket)};
-    wrapper.impl_->SetUp(std::move(ssl_ctx));
+    wrapper.impl_->SetUp(ctx);
     wrapper.impl_->bio_data.current_deadline = deadline;
 
     auto ret = SSL_accept(wrapper.impl_->ssl.get());
@@ -609,6 +518,11 @@ size_t TlsWrapper::RecvAll(void* buf, size_t len, Deadline deadline) {
     );
 }
 
+std::optional<size_t> TlsWrapper::RecvNoblock(void* buf, size_t len) {
+    impl_->CheckAlive();
+    return impl_->PerformSslIoOptional(&SSL_read_ex, buf, len, "RecvNoblock");
+}
+
 size_t TlsWrapper::SendAll(const void* buf, size_t len, Deadline deadline) {
     impl_->CheckAlive();
     return impl_->PerformSslIo(
diff --git a/core/src/engine/io/tls_wrapper_benchmark.cpp b/core/src/engine/io/tls_wrapper_benchmark.cpp
index e617bf19cc34..dddef9fc65ea 100644
--- a/core/src/engine/io/tls_wrapper_benchmark.cpp
+++ b/core/src/engine/io/tls_wrapper_benchmark.cpp
@@ -85,7 +85,7 @@ constexpr auto kDeadlineMaxTime = std::chrono::seconds{60};
 
 }  // namespace
 
-[[maybe_unused]] void tls_write_all_buffered(benchmark::State& state) {
+[[maybe_unused]] void TlsWriteAllBuffered(benchmark::State& state) {
     engine::RunStandalone(2, [&]() {
         const auto deadline = Deadline::FromDuration(kDeadlineMaxTime);
 
@@ -93,14 +93,13 @@ constexpr auto kDeadlineMaxTime = std::chrono::seconds{60};
         auto [server, client] = tcp_listener.MakeSocketPair(deadline);
 
         std::atomic<bool> reading{true};
+        crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+            crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
+        );
         auto server_task = engine::AsyncNoSpan(
-            [&reading, deadline](auto&& server) {
-                auto tls_server = io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(key),
-                    deadline
-                );
+            [&reading, deadline, &ssl_ctx](auto&& server) {
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, deadline);
 
                 std::array<std::byte, 16'384> buf{};
                 while (tls_server.RecvSome(buf.data(), buf.size(), deadline) > 0 && reading) {
@@ -127,9 +126,9 @@ constexpr auto kDeadlineMaxTime = std::chrono::seconds{60};
     });
 }
 
-BENCHMARK(tls_write_all_buffered)->RangeMultiplier(2)->Range(1 << 6, 1 << 12)->Unit(benchmark::kNanosecond);
+BENCHMARK(TlsWriteAllBuffered)->RangeMultiplier(2)->Range(1 << 6, 1 << 12)->Unit(benchmark::kNanosecond);
 
-[[maybe_unused]] void tls_write_all_default(benchmark::State& state) {
+[[maybe_unused]] void TlsWriteAllDefault(benchmark::State& state) {
     engine::RunStandalone(2, [&]() {
         const auto deadline = Deadline::FromDuration(kDeadlineMaxTime);
 
@@ -137,14 +136,13 @@ BENCHMARK(tls_write_all_buffered)->RangeMultiplier(2)->Range(1 << 6, 1 << 12)->U
         auto [server, client] = tcp_listener.MakeSocketPair(deadline);
 
         std::atomic<bool> reading{true};
+        crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+            crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
+        );
         auto server_task = engine::AsyncNoSpan(
-            [&reading, deadline](auto&& server) {
-                auto tls_server = io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(key),
-                    deadline
-                );
+            [&reading, deadline, &ssl_ctx](auto&& server) {
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, deadline);
 
                 std::array<std::byte, 16'384> buf{};
                 while (tls_server.RecvSome(buf.data(), buf.size(), deadline) > 0 && reading) {
@@ -173,6 +171,6 @@ BENCHMARK(tls_write_all_buffered)->RangeMultiplier(2)->Range(1 << 6, 1 << 12)->U
     });
 }
 
-BENCHMARK(tls_write_all_default)->RangeMultiplier(2)->Range(1 << 6, 1 << 12)->Unit(benchmark::kNanosecond);
+BENCHMARK(TlsWriteAllDefault)->RangeMultiplier(2)->Range(1 << 6, 1 << 12)->Unit(benchmark::kNanosecond);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/io/tls_wrapper_test.cpp b/core/src/engine/io/tls_wrapper_test.cpp
index 68cfa30eb1a9..178859764d74 100644
--- a/core/src/engine/io/tls_wrapper_test.cpp
+++ b/core/src/engine/io/tls_wrapper_test.cpp
@@ -8,6 +8,8 @@
 #include <vector>
 
 #include <userver/engine/async.hpp>
+#include <userver/engine/get_all.hpp>
+#include <userver/engine/io/exception.hpp>
 #include <userver/engine/io/socket.hpp>
 #include <userver/engine/io/tls_wrapper.hpp>
 #include <userver/engine/single_consumer_event.hpp>
@@ -213,6 +215,77 @@ ud5lWYZNZ6ygIOvwFz1VST30jT4Lj3Bmrg==
 -----END CERTIFICATE-----)";
 constexpr auto kShortTimeout = std::chrono::milliseconds{10};
 
+void Tests2Servers2Clients(const crypto::SslCtx& ssl_ctx1, const crypto::SslCtx& ssl_ctx2) {
+    const auto test_deadline = Deadline::FromDuration(utest::kMaxTestWaitTime);
+
+    TcpListener tcp_listener;
+    auto [server, client] = tcp_listener.MakeSocketPair(test_deadline);
+    auto [other_server, other_client] = tcp_listener.MakeSocketPair(test_deadline);
+
+    auto server_task = engine::AsyncNoSpan(
+        [test_deadline, &ssl_ctx1](auto&& server) {
+            auto tls_server =
+                io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx1, test_deadline);
+            EXPECT_EQ(1, tls_server.SendAll("1", 1, test_deadline));
+            char c = 0;
+            EXPECT_EQ(1, tls_server.RecvSome(&c, 1, test_deadline));
+            EXPECT_EQ('2', c);
+
+            auto raw_server = tls_server.StopTls(test_deadline);
+            EXPECT_EQ(1, raw_server.SendAll("3", 1, test_deadline));
+            EXPECT_EQ(1, raw_server.RecvSome(&c, 1, test_deadline));
+            EXPECT_EQ('4', c);
+        },
+        std::move(server)
+    );
+
+    auto other_server_task = engine::AsyncNoSpan(
+        [test_deadline, &ssl_ctx2](auto&& server) {
+            auto tls_server =
+                io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx2, test_deadline);
+            EXPECT_EQ(1, tls_server.SendAll("5", 1, test_deadline));
+            char c = 0;
+            EXPECT_EQ(1, tls_server.RecvSome(&c, 1, test_deadline));
+            EXPECT_EQ('6', c);
+
+            auto raw_server = tls_server.StopTls(test_deadline);
+            EXPECT_EQ(1, raw_server.SendAll("7", 1, test_deadline));
+            EXPECT_EQ(1, raw_server.RecvSome(&c, 1, test_deadline));
+            EXPECT_EQ('8', c);
+        },
+        std::move(other_server)
+    );
+
+    auto other_client_task = engine::AsyncNoSpan(
+        [test_deadline](auto&& client) {
+            auto tls_client = io::TlsWrapper::StartTlsClient(std::forward<decltype(client)>(client), {}, test_deadline);
+            char c = 0;
+            EXPECT_EQ(1, tls_client.RecvSome(&c, 1, test_deadline));
+            EXPECT_EQ('5', c);
+            EXPECT_EQ(1, tls_client.SendAll("6", 1, test_deadline));
+            auto raw_client = tls_client.StopTls(test_deadline);
+            EXPECT_EQ(1, raw_client.RecvSome(&c, 1, test_deadline));
+            EXPECT_EQ('7', c);
+            EXPECT_EQ(1, raw_client.SendAll("8", 1, test_deadline));
+        },
+        std::move(other_client)
+    );
+
+    auto tls_client = io::TlsWrapper::StartTlsClient(std::move(client), {}, test_deadline);
+    char c = 0;
+    EXPECT_EQ(1, tls_client.RecvSome(&c, 1, test_deadline));
+    EXPECT_EQ('1', c);
+    EXPECT_EQ(1, tls_client.SendAll("2", 1, test_deadline));
+    auto raw_client = tls_client.StopTls(test_deadline);
+    EXPECT_EQ(1, raw_client.RecvSome(&c, 1, test_deadline));
+    EXPECT_EQ('3', c);
+    EXPECT_EQ(1, raw_client.SendAll("4", 1, test_deadline));
+
+    server_task.Get();
+    other_server_task.Get();
+    other_client_task.Get();
+}
+
 }  // namespace
 
 UTEST(TlsWrapper, InitListSmall) {
@@ -232,12 +305,11 @@ UTEST(TlsWrapper, InitListSmall) {
     auto server_task = utils::Async(
         "tls-server",
         [deadline, kDataA, kDataB, kDataC, kDataD](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
+            crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
                 crypto::LoadCertificatesChainFromString(cert_chain),
-                crypto::PrivateKey::LoadFromString(chain_private_key),
-                deadline
+                crypto::PrivateKey::LoadFromString(chain_private_key)
             );
+            auto tls_server = io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, deadline);
             if (tls_server.WriteAll({kDataA, kDataB, kDataC, kDataD}, deadline) !=
                 kDataA.len + kDataB.len + kDataC.len + kDataD.len) {
                 throw std::runtime_error("Couldn't send data");
@@ -272,12 +344,10 @@ UTEST(TlsWrapper, InitListLarge) {
     auto server_task = utils::Async(
         "tls-server",
         [deadline, kDataA, kDataB, kDataC, kDataD](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(cert),
-                crypto::PrivateKey::LoadFromString(key),
-                deadline
+            crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
             );
+            auto tls_server = io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, deadline);
             if (tls_server.WriteAll({kDataA, kDataB, kDataC, kDataD}, deadline) !=
                 kDataA.len + kDataB.len + kDataC.len + kDataD.len) {
                 throw std::runtime_error("Couldn't send data");
@@ -308,12 +378,10 @@ UTEST(TlsWrapper, InitListSmallThenLarge) {
     auto server_task = utils::Async(
         "tls-server",
         [deadline, kDataSmall, kDataLarge](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(cert),
-                crypto::PrivateKey::LoadFromString(key),
-                deadline
+            crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
             );
+            auto tls_server = io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, deadline);
             if (tls_server.WriteAll({kDataSmall, kDataSmall, kDataSmall, kDataSmall, kDataLarge}, deadline) !=
                 kDataSmall.len * 4 + kDataLarge.len) {
                 throw std::runtime_error("Couldn't send data");
@@ -340,12 +408,11 @@ UTEST_MT(TlsWrapper, Smoke, 2) {
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
             try {
-                auto tls_server = io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(key),
-                    test_deadline
+                crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                    crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
                 );
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
                 EXPECT_EQ(1, tls_server.SendAll("1", 1, test_deadline));
                 char c = 0;
                 EXPECT_EQ(1, tls_server.RecvSome(&c, 1, test_deadline));
@@ -387,12 +454,10 @@ UTEST_MT(TlsWrapper, DocTest, 2) {
     auto server_task = utils::Async(
         "tls-server",
         [deadline](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(cert),
-                crypto::PrivateKey::LoadFromString(key),
-                deadline
+            crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
             );
+            auto tls_server = io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, deadline);
             if (tls_server.SendAll(kData.data(), kData.size(), deadline) != kData.size()) {
                 throw std::runtime_error("Couldn't send data");
             }
@@ -419,12 +484,11 @@ UTEST(TlsWrapper, Move) {
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
             try {
-                auto tls_server = io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(key),
-                    test_deadline
+                crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                    crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
                 );
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
                 engine::AsyncNoSpan(
                     [test_deadline](auto&& tls_server) {
                         EXPECT_EQ(1, tls_server.SendAll("1", 1, test_deadline));
@@ -468,13 +532,14 @@ UTEST(TlsWrapper, ConnectTimeout) {
         static_cast<void>(io::TlsWrapper::StartTlsClient(std::move(client), {}, Deadline::FromDuration(kShortTimeout))),
         io::IoTimeout
     );
+
+    crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+        crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
+    );
     EXPECT_THROW(
-        static_cast<void>(io::TlsWrapper::StartTlsServer(
-            std::move(server),
-            crypto::LoadCertificatesChainFromString(cert),
-            crypto::PrivateKey::LoadFromString(key),
-            Deadline::FromDuration(kShortTimeout)
-        )),
+        static_cast<void>(
+            io::TlsWrapper::StartTlsServer(std::move(server), ssl_ctx, Deadline::FromDuration(kShortTimeout))
+        ),
         io::IoException
     );
 }
@@ -488,12 +553,11 @@ UTEST_MT(TlsWrapper, IoTimeout, 2) {
     engine::SingleConsumerEvent timeout_happened;
     auto server_task = engine::AsyncNoSpan(
         [test_deadline, &timeout_happened](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(cert),
-                crypto::PrivateKey::LoadFromString(key),
-                test_deadline
+            crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
             );
+            auto tls_server =
+                io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
             char c = 0;
             UEXPECT_THROW(
                 static_cast<void>(tls_server.RecvSome(&c, 1, Deadline::FromDuration(kShortTimeout))), io::IoTimeout
@@ -525,12 +589,11 @@ UTEST(TlsWrapper, Cancel) {
 
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(cert),
-                crypto::PrivateKey::LoadFromString(key),
-                test_deadline
+            crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
             );
+            auto tls_server =
+                io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
             char c = 0;
             UEXPECT_THROW(static_cast<void>(tls_server.RecvSome(&c, 1, test_deadline)), io::IoInterrupted);
         },
@@ -551,21 +614,21 @@ UTEST_MT(TlsWrapper, CertKeyMismatch, 2) {
 
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
-            UEXPECT_THROW(
-                static_cast<void>(io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(other_key),
-                    test_deadline
-                )),
-                io::TlsException
-            );
+            UEXPECT_THROW(crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                              crypto::LoadCertificatesChainFromString(cert),
+                              crypto::PrivateKey::LoadFromString(other_key)
+                          );
+                          static_cast<void>(io::TlsWrapper::StartTlsServer(
+                              std::forward<decltype(server)>(server), ssl_ctx, test_deadline
+                          )),
+                          crypto::CryptoException);
         },
         std::move(server)
     );
 
     EXPECT_THROW(
-        static_cast<void>(io::TlsWrapper::StartTlsClient(std::move(client), {}, test_deadline)), io::IoException
+        static_cast<void>(io::TlsWrapper::StartTlsClient(std::move(client), {}, test_deadline)),
+        std::exception  // Could be engine::io::TlsException or engine::io::IoSystemError
     );
     server_task.Get();
 }
@@ -578,15 +641,14 @@ UTEST_MT(TlsWrapper, NonTlsClient, 2) {
 
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
-            UEXPECT_THROW(
-                static_cast<void>(io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(other_key),
-                    test_deadline
-                )),
-                io::TlsException
-            );
+            UEXPECT_THROW(crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                              crypto::LoadCertificatesChainFromString(cert),
+                              crypto::PrivateKey::LoadFromString(other_key)
+                          );
+                          static_cast<void>(io::TlsWrapper::StartTlsServer(
+                              std::forward<decltype(server)>(server), ssl_ctx, test_deadline
+                          )),
+                          crypto::CryptoException);
         },
         std::move(server)
     );
@@ -612,94 +674,45 @@ UTEST_MT(TlsWrapper, NonTlsServer, 2) {
 }
 
 UTEST_MT(TlsWrapper, DoubleSmoke, 4) {
-    const auto test_deadline = Deadline::FromDuration(utest::kMaxTestWaitTime);
-
-    TcpListener tcp_listener;
-    auto [server, client] = tcp_listener.MakeSocketPair(test_deadline);
-    auto [other_server, other_client] = tcp_listener.MakeSocketPair(test_deadline);
-
-    auto server_task = engine::AsyncNoSpan(
-        [test_deadline](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(cert),
-                crypto::PrivateKey::LoadFromString(key),
-                test_deadline
-            );
-            EXPECT_EQ(1, tls_server.SendAll("1", 1, test_deadline));
-            char c = 0;
-            EXPECT_EQ(1, tls_server.RecvSome(&c, 1, test_deadline));
-            EXPECT_EQ('2', c);
-
-            auto raw_server = tls_server.StopTls(test_deadline);
-            EXPECT_EQ(1, raw_server.SendAll("3", 1, test_deadline));
-            EXPECT_EQ(1, raw_server.RecvSome(&c, 1, test_deadline));
-            EXPECT_EQ('4', c);
-        },
-        std::move(server)
+    crypto::SslCtx ssl_ctx1 = crypto::SslCtx::CreateServerTlsContext(
+        crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
     );
+    crypto::SslCtx ssl_ctx2 = crypto::SslCtx::CreateServerTlsContext(
+        crypto::LoadCertificatesChainFromString(other_cert), crypto::PrivateKey::LoadFromString(other_key)
+    );
+    Tests2Servers2Clients(ssl_ctx1, ssl_ctx2);
+}
 
-    auto other_server_task = engine::AsyncNoSpan(
-        [test_deadline](auto&& server) {
-            auto tls_server = io::TlsWrapper::StartTlsServer(
-                std::forward<decltype(server)>(server),
-                crypto::LoadCertificatesChainFromString(other_cert),
-                crypto::PrivateKey::LoadFromString(other_key),
-                test_deadline
-            );
-            EXPECT_EQ(1, tls_server.SendAll("5", 1, test_deadline));
-            char c = 0;
-            EXPECT_EQ(1, tls_server.RecvSome(&c, 1, test_deadline));
-            EXPECT_EQ('6', c);
-
-            auto raw_server = tls_server.StopTls(test_deadline);
-            EXPECT_EQ(1, raw_server.SendAll("7", 1, test_deadline));
-            EXPECT_EQ(1, raw_server.RecvSome(&c, 1, test_deadline));
-            EXPECT_EQ('8', c);
-        },
-        std::move(other_server)
+UTEST_MT(TlsWrapper, DoubleSmokeSameCtx, 4) {
+    crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+        crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
     );
+    Tests2Servers2Clients(ssl_ctx, ssl_ctx);
+}
 
-    auto other_client_task = engine::AsyncNoSpan(
-        [test_deadline](auto&& client) {
-            auto tls_client = io::TlsWrapper::StartTlsClient(std::forward<decltype(client)>(client), {}, test_deadline);
-            char c = 0;
-            EXPECT_EQ(1, tls_client.RecvSome(&c, 1, test_deadline));
-            EXPECT_EQ('5', c);
-            EXPECT_EQ(1, tls_client.SendAll("6", 1, test_deadline));
-            auto raw_client = tls_client.StopTls(test_deadline);
-            EXPECT_EQ(1, raw_client.RecvSome(&c, 1, test_deadline));
-            EXPECT_EQ('7', c);
-            EXPECT_EQ(1, raw_client.SendAll("8", 1, test_deadline));
-        },
-        std::move(other_client)
+UTEST_MT(TlsWrapper, SmokeSameCtxTorture, 4) {
+    crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+        crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
     );
 
-    auto tls_client = io::TlsWrapper::StartTlsClient(std::move(client), {}, test_deadline);
-    char c = 0;
-    EXPECT_EQ(1, tls_client.RecvSome(&c, 1, test_deadline));
-    EXPECT_EQ('1', c);
-    EXPECT_EQ(1, tls_client.SendAll("2", 1, test_deadline));
-    auto raw_client = tls_client.StopTls(test_deadline);
-    EXPECT_EQ(1, raw_client.RecvSome(&c, 1, test_deadline));
-    EXPECT_EQ('3', c);
-    EXPECT_EQ(1, raw_client.SendAll("4", 1, test_deadline));
+    constexpr unsigned kTasksCount = 30;
+    std::vector<engine::TaskWithResult<void>> tasks;
+    tasks.reserve(kTasksCount);
+    for (unsigned i = 0; i < kTasksCount; ++i) {
+        tasks.push_back(engine::AsyncNoSpan(&Tests2Servers2Clients, std::ref(ssl_ctx), std::ref(ssl_ctx)));
+    }
 
-    server_task.Get();
-    other_server_task.Get();
-    other_client_task.Get();
+    engine::GetAll(tasks);
 }
 
 UTEST(TlsWrapper, InvalidSocket) {
     const auto test_deadline = Deadline::FromDuration(utest::kMaxTestWaitTime);
 
     UEXPECT_THROW(static_cast<void>(io::TlsWrapper::StartTlsClient({}, {}, test_deadline)), io::TlsException);
-    UEXPECT_THROW(
-        static_cast<void>(io::TlsWrapper::StartTlsServer(
-            {}, crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key), test_deadline
-        )),
-        io::TlsException
+    crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+        crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
     );
+    UEXPECT_THROW(static_cast<void>(io::TlsWrapper::StartTlsServer({}, ssl_ctx, test_deadline)), io::TlsException);
 }
 
 UTEST(TlsWrapper, PeerShutdown) {
@@ -711,12 +724,11 @@ UTEST(TlsWrapper, PeerShutdown) {
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
             try {
-                auto tls_server = io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(key),
-                    test_deadline
+                crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                    crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
                 );
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
                 char c = 0;
                 // Get a non-fatal error on the channel
                 EXPECT_THROW(
@@ -753,12 +765,11 @@ UTEST(TlsWrapper, PeerDisconnect) {
     auto server_task = engine::AsyncNoSpan(
         [test_deadline](auto&& server) {
             try {
-                auto tls_server = io::TlsWrapper::StartTlsServer(
-                    std::forward<decltype(server)>(server),
-                    crypto::LoadCertificatesChainFromString(cert),
-                    crypto::PrivateKey::LoadFromString(key),
-                    test_deadline
+                crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                    crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
                 );
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
                 char c = 0;
                 // Get a non-fatal error on the channel
                 EXPECT_THROW(
@@ -790,4 +801,94 @@ UTEST(TlsWrapper, PeerDisconnect) {
     server_task.Get();
 }
 
+UTEST(TlsWrapper, RecvNoblock) {
+    const auto test_deadline = Deadline::FromDuration(utest::kMaxTestWaitTime);
+
+    TcpListener tcp_listener;
+    auto [server, client] = tcp_listener.MakeSocketPair(test_deadline);
+
+    auto server_task = engine::AsyncNoSpan(
+        [test_deadline](auto&& server) {
+            try {
+                crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                    crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
+                );
+                auto tls_server = io::TlsWrapper::StartTlsServer(
+                    std::forward<decltype(server)>(server), std::move(ssl_ctx), test_deadline
+                );
+                EXPECT_EQ(1, tls_server.SendAll("1", 1, test_deadline));
+
+                char c = 0;
+                std::optional<size_t> read_bytes;
+                while (true) {
+                    read_bytes = tls_server.RecvNoblock(&c, 1);
+                    if (read_bytes.has_value()) {
+                        EXPECT_EQ(1, read_bytes.value());
+                        EXPECT_EQ('2', c);
+                        return;
+                    }
+
+                    ASSERT_FALSE(test_deadline.IsReached());
+                }
+            } catch (const std::exception& e) {
+                LOG_ERROR() << e;
+                FAIL() << e.what();
+            }
+        },
+        std::move(server)
+    );
+
+    auto tls_client = io::TlsWrapper::StartTlsClient(std::move(client), {}, test_deadline);
+
+    char c = 0;
+    auto read_bytes = tls_client.RecvAll(&c, 1, test_deadline);
+    EXPECT_EQ(1, read_bytes);
+    EXPECT_EQ('1', c);
+
+    EXPECT_EQ(1, tls_client.SendAll("2", 1, test_deadline));
+    server_task.Get();
+}
+
+UTEST(TlsWrapper, RecvNoblockNoData) {
+    const auto test_deadline = Deadline::FromDuration(utest::kMaxTestWaitTime);
+
+    TcpListener tcp_listener;
+    auto [server, client] = tcp_listener.MakeSocketPair(test_deadline);
+
+    auto server_task = engine::AsyncNoSpan(
+        [test_deadline](auto&& server) {
+            try {
+                crypto::SslCtx ssl_ctx = crypto::SslCtx::CreateServerTlsContext(
+                    crypto::LoadCertificatesChainFromString(cert), crypto::PrivateKey::LoadFromString(key)
+                );
+                auto tls_server =
+                    io::TlsWrapper::StartTlsServer(std::forward<decltype(server)>(server), ssl_ctx, test_deadline);
+
+                char server_char = 0;
+
+                // Test that the call does not block if there is no data
+                const auto read_bytes = tls_server.RecvNoblock(&server_char, 1);
+                ASSERT_FALSE(read_bytes.has_value());
+                EXPECT_EQ(1, tls_server.SendAll("1", 1, test_deadline));
+            } catch (const std::exception& e) {
+                LOG_ERROR() << e;
+                FAIL() << e.what();
+            }
+        },
+        std::move(server)
+    );
+
+    auto tls_client = io::TlsWrapper::StartTlsClient(std::move(client), {}, test_deadline);
+
+    char c = 0;
+    auto read_bytes = tls_client.RecvAll(&c, 1, test_deadline);
+    EXPECT_EQ(1, read_bytes);
+    EXPECT_EQ('1', c);
+
+    // Test that the call does not block if there is no data or remote closed the socket
+    ASSERT_EQ(tls_client.RecvNoblock(&c, 1).value_or(0), 0);
+
+    server_task.Get();
+}
+
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/mutex_benchmark.cpp b/core/src/engine/mutex_benchmark.cpp
index 243be2a9a655..a72379d49761 100644
--- a/core/src/engine/mutex_benchmark.cpp
+++ b/core/src/engine/mutex_benchmark.cpp
@@ -21,7 +21,7 @@ namespace {
 //////// Generic cases for benchmarking
 
 template <typename Mutex>
-void generic_lock(benchmark::State& state) {
+void GenericLock(benchmark::State& state) {
     constexpr std::size_t kMutexCount = 256;
     std::size_t i = 0;
     Mutex mutexes[kMutexCount];
@@ -45,7 +45,7 @@ void generic_lock(benchmark::State& state) {
 }
 
 template <typename Mutex>
-void generic_unlock(benchmark::State& state) {
+void GenericUnlock(benchmark::State& state) {
     constexpr std::size_t kMutexCount = 256;
     std::size_t i = 0;
     Mutex mutexes[kMutexCount];
@@ -73,7 +73,7 @@ void generic_unlock(benchmark::State& state) {
 }
 
 template <typename Mutex>
-void generic_contention(benchmark::State& state) {
+void GenericContention(benchmark::State& state) {
     std::atomic<std::size_t> lock_unlock_count{0};
     concurrent::impl::InterferenceShield<Mutex> m;
 
@@ -96,7 +96,7 @@ void generic_contention(benchmark::State& state) {
 }
 
 template <typename Mutex>
-void generic_contention_with_payload(benchmark::State& state) {
+void GenericContentionWithPayload(benchmark::State& state) {
     std::atomic<std::uint64_t> lock_unlock_count{0};
     concurrent::impl::InterferenceShield<Mutex> m;
 
@@ -127,64 +127,62 @@ void generic_contention_with_payload(benchmark::State& state) {
 // avoid any side-effects (RunStandalone spawns additional std::threads and uses
 // some synchronization primitives).
 
-void mutex_coro_lock(benchmark::State& state) {
-    engine::RunStandalone([&] { generic_lock<engine::Mutex>(state); });
+void MutexCoroLock(benchmark::State& state) {
+    engine::RunStandalone([&] { GenericLock<engine::Mutex>(state); });
 }
 
-void mutex_std_lock(benchmark::State& state) { generic_lock<std::mutex>(state); }
+void MutexStdLock(benchmark::State& state) { GenericLock<std::mutex>(state); }
 
-void single_waiting_task_mutex_lock(benchmark::State& state) {
-    engine::RunStandalone([&] { generic_lock<engine::SingleWaitingTaskMutex>(state); });
+void SingleWaitingTaskMutexLock(benchmark::State& state) {
+    engine::RunStandalone([&] { GenericLock<engine::SingleWaitingTaskMutex>(state); });
 }
 
-void mutex_coro_unlock(benchmark::State& state) {
-    engine::RunStandalone([&] { generic_unlock<engine::Mutex>(state); });
+void MutexCoroUnlock(benchmark::State& state) {
+    engine::RunStandalone([&] { GenericUnlock<engine::Mutex>(state); });
 }
 
-void mutex_std_unlock(benchmark::State& state) { generic_lock<std::mutex>(state); }
+void MutexStdUnlock(benchmark::State& state) { GenericLock<std::mutex>(state); }
 
-void single_waiting_task_mutex_unlock(benchmark::State& state) {
-    engine::RunStandalone([&] { generic_unlock<engine::SingleWaitingTaskMutex>(state); });
+void SingleWaitingTaskMutexUnlock(benchmark::State& state) {
+    engine::RunStandalone([&] { GenericUnlock<engine::SingleWaitingTaskMutex>(state); });
 }
 
-void mutex_coro_contention(benchmark::State& state) {
-    engine::RunStandalone(state.range(0), [&] { generic_contention<engine::Mutex>(state); });
+void MutexCoroContention(benchmark::State& state) {
+    engine::RunStandalone(state.range(0), [&] { GenericContention<engine::Mutex>(state); });
 }
 
-void mutex_std_contention(benchmark::State& state) { generic_contention<std::mutex>(state); }
+void MutexStdContention(benchmark::State& state) { GenericContention<std::mutex>(state); }
 
-void single_waiting_task_mutex_contention(benchmark::State& state) {
-    engine::RunStandalone(state.range(0), [&] { generic_contention<engine::SingleWaitingTaskMutex>(state); });
+void SingleWaitingTaskMutexContention(benchmark::State& state) {
+    engine::RunStandalone(state.range(0), [&] { GenericContention<engine::SingleWaitingTaskMutex>(state); });
 }
 
-void mutex_coro_contention_with_payload(benchmark::State& state) {
-    engine::RunStandalone(state.range(0), [&] { generic_contention_with_payload<engine::Mutex>(state); });
+void MutexCoroContentionWithPayload(benchmark::State& state) {
+    engine::RunStandalone(state.range(0), [&] { GenericContentionWithPayload<engine::Mutex>(state); });
 }
 
-void mutex_std_contention_with_payload(benchmark::State& state) { generic_contention_with_payload<std::mutex>(state); }
+void MutexStdContentionWithPayload(benchmark::State& state) { GenericContentionWithPayload<std::mutex>(state); }
 
-void single_waiting_task_mutex_contention_with_payload(benchmark::State& state) {
-    engine::RunStandalone(state.range(0), [&] {
-        generic_contention_with_payload<engine::SingleWaitingTaskMutex>(state);
-    });
+void SingleWaitingTaskMutexContentionWithPayload(benchmark::State& state) {
+    engine::RunStandalone(state.range(0), [&] { GenericContentionWithPayload<engine::SingleWaitingTaskMutex>(state); });
 }
 
 }  // namespace
 
-BENCHMARK(mutex_coro_lock);
-BENCHMARK(mutex_std_lock);
-BENCHMARK(single_waiting_task_mutex_lock);
+BENCHMARK(MutexCoroLock);
+BENCHMARK(MutexStdLock);
+BENCHMARK(SingleWaitingTaskMutexLock);
 
-BENCHMARK(mutex_coro_unlock);
-BENCHMARK(mutex_std_unlock);
-BENCHMARK(single_waiting_task_mutex_unlock);
+BENCHMARK(MutexCoroUnlock);
+BENCHMARK(MutexStdUnlock);
+BENCHMARK(SingleWaitingTaskMutexUnlock);
 
-BENCHMARK(mutex_coro_contention)->RangeMultiplier(2)->Range(1, 32);
-BENCHMARK(mutex_std_contention)->RangeMultiplier(2)->Range(1, 32);
-BENCHMARK(single_waiting_task_mutex_contention)->Range(1, 2);
+BENCHMARK(MutexCoroContention)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(MutexStdContention)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(SingleWaitingTaskMutexContention)->Range(1, 2);
 
-BENCHMARK(mutex_coro_contention_with_payload)->RangeMultiplier(2)->Range(1, 32);
-BENCHMARK(mutex_std_contention_with_payload)->RangeMultiplier(2)->Range(1, 32);
-BENCHMARK(single_waiting_task_mutex_contention_with_payload)->Range(1, 2);
+BENCHMARK(MutexCoroContentionWithPayload)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(MutexStdContentionWithPayload)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(SingleWaitingTaskMutexContentionWithPayload)->Range(1, 2);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/semaphore.cpp b/core/src/engine/semaphore.cpp
index 081cca608746..4cf18ac134c5 100644
--- a/core/src/engine/semaphore.cpp
+++ b/core/src/engine/semaphore.cpp
@@ -105,8 +105,9 @@ void CancellableSemaphore::lock_shared_count(const Counter count) {
 void CancellableSemaphore::unlock_shared() { unlock_shared_count(1); }
 
 void CancellableSemaphore::unlock_shared_count(const Counter count) {
-    UASSERT(count > 0);
-
+    if (count == 0) {
+        return;
+    }
     const auto old_acquired_locks = acquired_locks_.fetch_sub(count, std::memory_order_acq_rel);
     UASSERT_MSG(
         old_acquired_locks >= old_acquired_locks - count,
@@ -175,8 +176,9 @@ CancellableSemaphore::TryLockStatus CancellableSemaphore::DoTryLock(const Counte
 }
 
 CancellableSemaphore::TryLockStatus CancellableSemaphore::LockFastPath(const Counter count) {
-    UASSERT(count > 0);
-
+    if (count == 0) {
+        return TryLockStatus::kSuccess;
+    }
     const auto status = DoTryLock(count);
     return status;
 }
diff --git a/core/src/engine/semaphore_benchmark.cpp b/core/src/engine/semaphore_benchmark.cpp
index dc0c642115e0..e80c48617da1 100644
--- a/core/src/engine/semaphore_benchmark.cpp
+++ b/core/src/engine/semaphore_benchmark.cpp
@@ -12,7 +12,7 @@
 USERVER_NAMESPACE_BEGIN
 
 /// [RunStandalone sample]
-void semaphore_lock(benchmark::State& state) {
+void SemaphoreLock(benchmark::State& state) {
     engine::RunStandalone([&]() {
         std::size_t i = 0;
         engine::Semaphore sem{std::numeric_limits<std::size_t>::max()};
@@ -27,10 +27,10 @@ void semaphore_lock(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(semaphore_lock);
+BENCHMARK(SemaphoreLock);
 /// [RunStandalone sample]
 
-void semaphore_unlock(benchmark::State& state) {
+void SemaphoreUnlock(benchmark::State& state) {
     engine::RunStandalone([&]() {
         unsigned i = 0;
         engine::Semaphore sem{std::numeric_limits<std::size_t>::max()};
@@ -58,9 +58,9 @@ void semaphore_unlock(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(semaphore_unlock);
+BENCHMARK(SemaphoreUnlock);
 
-void semaphore_lock_unlock_contention(benchmark::State& state) {
+void SemaphoreLockUnlockContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         engine::Semaphore sem{1};
 
@@ -72,9 +72,9 @@ void semaphore_lock_unlock_contention(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(semaphore_lock_unlock_contention)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(SemaphoreLockUnlockContention)->RangeMultiplier(2)->Range(1, 32);
 
-void semaphore_lock_unlock_payload_contention(benchmark::State& state) {
+void SemaphoreLockUnlockPayloadContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         engine::Semaphore sem{1};
 
@@ -90,9 +90,9 @@ void semaphore_lock_unlock_payload_contention(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(semaphore_lock_unlock_payload_contention)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(SemaphoreLockUnlockPayloadContention)->RangeMultiplier(2)->Range(1, 32);
 
-void semaphore_lock_unlock_coro_contention(benchmark::State& state) {
+void SemaphoreLockUnlockCoroContention(benchmark::State& state) {
     engine::RunStandalone(4, [&] {
         engine::Semaphore sem{1};
 
@@ -104,9 +104,9 @@ void semaphore_lock_unlock_coro_contention(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(semaphore_lock_unlock_coro_contention)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(SemaphoreLockUnlockCoroContention)->RangeMultiplier(2)->Range(1, 1024);
 
-void semaphore_lock_unlock_payload_coro_contention(benchmark::State& state) {
+void SemaphoreLockUnlockPayloadCoroContention(benchmark::State& state) {
     engine::RunStandalone(4, [&] {
         engine::Semaphore sem{1};
 
@@ -122,9 +122,9 @@ void semaphore_lock_unlock_payload_coro_contention(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(semaphore_lock_unlock_payload_coro_contention)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(SemaphoreLockUnlockPayloadCoroContention)->RangeMultiplier(2)->Range(1, 1024);
 
-void semaphore_lock_unlock_st_coro_contention(benchmark::State& state) {
+void SemaphoreLockUnlockStCoroContention(benchmark::State& state) {
     engine::RunStandalone([&]() {
         engine::Semaphore sem{1};
 
@@ -137,6 +137,6 @@ void semaphore_lock_unlock_st_coro_contention(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(semaphore_lock_unlock_st_coro_contention)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(SemaphoreLockUnlockStCoroContention)->RangeMultiplier(2)->Range(1, 1024);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/semaphore_test.cpp b/core/src/engine/semaphore_test.cpp
index 7eb2240e864a..6b8baea7955a 100644
--- a/core/src/engine/semaphore_test.cpp
+++ b/core/src/engine/semaphore_test.cpp
@@ -439,4 +439,33 @@ UTEST(SemaphoreLock, SampleSemaphore) {
     /// [Sample engine::Semaphore usage]
 }
 
+UTEST(Semaphore, LockZeroUnitsWithRemaining) {
+    engine::Semaphore sem{1};
+    EXPECT_EQ(sem.GetCapacity(), 1);
+    EXPECT_EQ(sem.RemainingApprox(), 1);
+    EXPECT_EQ(sem.UsedApprox(), 0);
+
+    sem.lock_shared_count(0);
+    EXPECT_EQ(sem.GetCapacity(), 1);
+    EXPECT_EQ(sem.RemainingApprox(), 1);
+    EXPECT_EQ(sem.UsedApprox(), 0);
+    sem.unlock_shared_count(0);
+}
+
+UTEST(Semaphore, LockZeroUnitsWithoutRemaining) {
+    engine::Semaphore sem{1};
+    sem.lock_shared_count(1);
+    EXPECT_EQ(sem.GetCapacity(), 1);
+    EXPECT_EQ(sem.RemainingApprox(), 0);
+    EXPECT_EQ(sem.UsedApprox(), 1);
+
+    sem.lock_shared_count(0);
+    EXPECT_EQ(sem.GetCapacity(), 1);
+    EXPECT_EQ(sem.RemainingApprox(), 0);
+    EXPECT_EQ(sem.UsedApprox(), 1);
+    sem.unlock_shared_count(0);
+
+    sem.unlock_shared_count(1);
+}
+
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/shared_mutex_benchmark.cpp b/core/src/engine/shared_mutex_benchmark.cpp
index 3c31a4fd485b..bb27de345c5a 100644
--- a/core/src/engine/shared_mutex_benchmark.cpp
+++ b/core/src/engine/shared_mutex_benchmark.cpp
@@ -7,7 +7,7 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void shared_mutex_benchmark(benchmark::State& state) {
+void SharedMutexBenchmark(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         int variable = 0;
         engine::SharedMutex mutex;
@@ -26,6 +26,6 @@ void shared_mutex_benchmark(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(shared_mutex_benchmark)->DenseRange(1, 6);
+BENCHMARK(SharedMutexBenchmark)->DenseRange(1, 6);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/single_use_event.cpp b/core/src/engine/single_use_event.cpp
index f7e017e1499c..4fb23fafb13a 100644
--- a/core/src/engine/single_use_event.cpp
+++ b/core/src/engine/single_use_event.cpp
@@ -27,9 +27,8 @@ void SingleUseEvent::Wait() {
                 "Timeout is not expected here due to unreachable "
                 "Deadline at Sleep"
             );
-#ifdef NDEBUG
-            [[fallthrough]];
-#endif
+            // Never reaches
+            break;
         case FutureStatus::kCancelled:
             throw WaitInterruptedException(current_task::CancellationReason());
     }
diff --git a/core/src/engine/sleep_benchmark.cpp b/core/src/engine/sleep_benchmark.cpp
index 0c8d8e5aaced..9620517fd4ba 100644
--- a/core/src/engine/sleep_benchmark.cpp
+++ b/core/src/engine/sleep_benchmark.cpp
@@ -9,7 +9,7 @@ using namespace std::chrono_literals;
 
 USERVER_NAMESPACE_BEGIN
 
-void sleep_benchmark_us(benchmark::State& state) {
+void SleepBenchmarkUs(benchmark::State& state) {
     engine::RunStandalone([&] {
         const std::chrono::microseconds sleep_duration{state.range(0)};
         for ([[maybe_unused]] auto _ : state) {
@@ -18,9 +18,9 @@ void sleep_benchmark_us(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(sleep_benchmark_us)->RangeMultiplier(2)->Range(1, 1024 * 128)->Unit(benchmark::kMicrosecond);
+BENCHMARK(SleepBenchmarkUs)->RangeMultiplier(2)->Range(1, 1024 * 128)->Unit(benchmark::kMicrosecond);
 
-void run_in_ev_loop_benchmark(benchmark::State& state) {
+void RunInEvLoopBenchmark(benchmark::State& state) {
     engine::RunStandalone([&] {
         auto& ev_thread = engine::current_task::GetEventThread();
         for ([[maybe_unused]] auto _ : state) {
@@ -28,9 +28,9 @@ void run_in_ev_loop_benchmark(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(run_in_ev_loop_benchmark);
+BENCHMARK(RunInEvLoopBenchmark);
 
-[[maybe_unused]] void successful_wait_for_benchmark(benchmark::State& state) {
+[[maybe_unused]] void SuccessfulWaitForBenchmark(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             auto task = engine::AsyncNoSpan([] { engine::Yield(); });
@@ -40,9 +40,9 @@ BENCHMARK(run_in_ev_loop_benchmark);
         }
     });
 }
-BENCHMARK(successful_wait_for_benchmark);
+BENCHMARK(SuccessfulWaitForBenchmark);
 
-void unreached_task_deadline_benchmark(benchmark::State& state, bool has_task_deadline) {
+void UnreachedTaskDeadlineBenchmark(benchmark::State& state, bool has_task_deadline) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             const auto sleep_deadline = engine::Deadline::FromDuration(20s);
@@ -56,7 +56,7 @@ void unreached_task_deadline_benchmark(benchmark::State& state, bool has_task_de
         }
     });
 }
-BENCHMARK_CAPTURE(unreached_task_deadline_benchmark, no_task_deadline, false);
-BENCHMARK_CAPTURE(unreached_task_deadline_benchmark, unreached_task_deadline, true);
+BENCHMARK_CAPTURE(UnreachedTaskDeadlineBenchmark, no_task_deadline, false);
+BENCHMARK_CAPTURE(UnreachedTaskDeadlineBenchmark, unreached_task_deadline, true);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/task/async_benchmark.cpp b/core/src/engine/task/async_benchmark.cpp
index fd640ddc3b54..0ce1598272ab 100644
--- a/core/src/engine/task/async_benchmark.cpp
+++ b/core/src/engine/task/async_benchmark.cpp
@@ -20,7 +20,7 @@ using WrappedSpanCall = utils::impl::WrappedCallImplType<decltype(utils::impl::S
 // Note: We intentionally do not run this benchmark from RunStandalone to avoid
 // any side-effects (RunStandalone spawns additional std::threads and uses some
 // synchronization primitives).
-void async_comparisons_std_thread(benchmark::State& state) {
+void AsyncComparisonsStdThread(benchmark::State& state) {
     std::uint64_t constructed_joined_count = 0;
     for ([[maybe_unused]] auto _ : state) {
         std::thread([] {}).join();
@@ -28,9 +28,9 @@ void async_comparisons_std_thread(benchmark::State& state) {
     }
     benchmark::DoNotOptimize(constructed_joined_count);
 }
-BENCHMARK(async_comparisons_std_thread);
+BENCHMARK(AsyncComparisonsStdThread);
 
-void async_comparisons_coro(benchmark::State& state) {
+void AsyncComparisonsCoro(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::uint64_t constructed_joined_count = 0;
         for ([[maybe_unused]] auto _ : state) {
@@ -40,18 +40,18 @@ void async_comparisons_coro(benchmark::State& state) {
         benchmark::DoNotOptimize(constructed_joined_count);
     });
 }
-BENCHMARK(async_comparisons_coro)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(AsyncComparisonsCoro)->RangeMultiplier(2)->Range(1, 32);
 
-void wrap_call_single(benchmark::State& state) {
+void WrapCallSingle(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             WrappedSpanCall(utils::impl::SpanLazyPrvalue(""), []() {});
         }
     });
 }
-BENCHMARK(wrap_call_single);
+BENCHMARK(WrapCallSingle);
 
-void wrap_call_multiple(benchmark::State& state) {
+void WrapCallMultiple(benchmark::State& state) {
     engine::RunStandalone([&] {
         constexpr std::size_t kInMemoryInstancesCount = 100;
         utils::FixedArray<std::optional<WrappedSpanCall>> calls{kInMemoryInstancesCount};
@@ -66,9 +66,9 @@ void wrap_call_multiple(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(wrap_call_multiple);
+BENCHMARK(WrapCallMultiple);
 
-void wrap_call_and_perform(benchmark::State& state) {
+void WrapCallAndPerform(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             WrappedSpanCall wrapped_call{utils::impl::SpanLazyPrvalue(""), []() {}};
@@ -81,9 +81,9 @@ void wrap_call_and_perform(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(wrap_call_and_perform);
+BENCHMARK(WrapCallAndPerform);
 
-void async_comparisons_coro_spanned(benchmark::State& state) {
+void AsyncComparisonsCoroSpanned(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::uint64_t constructed_joined_count = 0;
         for ([[maybe_unused]] auto _ : state) {
@@ -93,6 +93,6 @@ void async_comparisons_coro_spanned(benchmark::State& state) {
         benchmark::DoNotOptimize(constructed_joined_count);
     });
 }
-BENCHMARK(async_comparisons_coro_spanned)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(AsyncComparisonsCoroSpanned)->RangeMultiplier(2)->Range(1, 32);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/task/task_benchmark.cpp b/core/src/engine/task/task_benchmark.cpp
index a75bfb11f9c9..ad36d88ee33d 100644
--- a/core/src/engine/task/task_benchmark.cpp
+++ b/core/src/engine/task/task_benchmark.cpp
@@ -23,16 +23,16 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void engine_task_create(benchmark::State& state) {
+void EngineTaskCreate(benchmark::State& state) {
     // We use 2 threads to ensure that detached tasks are deallocated,
     // otherwise this benchmark OOMs after some time.
     engine::RunStandalone(2, [&] {
         for ([[maybe_unused]] auto _ : state) engine::DetachUnscopedUnsafe(engine::AsyncNoSpan([]() {}));
     });
 }
-BENCHMARK(engine_task_create);
+BENCHMARK(EngineTaskCreate);
 
-void engine_task_yield_single_thread(benchmark::State& state) {
+void EngineTaskYieldSingleThread(benchmark::State& state) {
     engine::RunStandalone([&] {
         RunParallelBenchmark(state, [](auto& range) {
             for ([[maybe_unused]] auto _ : range) {
@@ -41,9 +41,9 @@ void engine_task_yield_single_thread(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(engine_task_yield_single_thread)->RangeMultiplier(2)->Range(1, 128);
+BENCHMARK(EngineTaskYieldSingleThread)->RangeMultiplier(2)->Range(1, 128);
 
-void engine_task_yield_multiple_threads(benchmark::State& state) {
+void EngineTaskYieldMultipleThreads(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::atomic<std::uint64_t> total_yields{0};
 
@@ -61,9 +61,9 @@ void engine_task_yield_multiple_threads(benchmark::State& state) {
             benchmark::Counter(static_cast<double>(total_yields) / state.range(0), benchmark::Counter::kIsRate);
     });
 }
-BENCHMARK(engine_task_yield_multiple_threads)->RangeMultiplier(2)->Range(1, 32)->Arg(6)->Arg(12);
+BENCHMARK(EngineTaskYieldMultipleThreads)->RangeMultiplier(2)->Range(1, 32)->Arg(6)->Arg(12);
 
-void engine_task_yield_multiple_task_processors(benchmark::State& state) {
+void EngineTaskYieldMultipleTaskProcessors(benchmark::State& state) {
     engine::RunStandalone([&] {
         auto tp_pool = engine::SingleThreadedTaskProcessorsPool::MakeForTests(state.range(0) - 1);
 
@@ -98,14 +98,14 @@ void engine_task_yield_multiple_task_processors(benchmark::State& state) {
             benchmark::Counter(static_cast<double>(yields_performed) / state.range(0), benchmark::Counter::kIsRate);
     });
 }
-BENCHMARK(engine_task_yield_multiple_task_processors)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(EngineTaskYieldMultipleTaskProcessors)->RangeMultiplier(2)->Range(1, 32);
 
-void thread_yield(benchmark::State& state) {
+void ThreadYield(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) std::this_thread::yield();
 }
-BENCHMARK(thread_yield)->RangeMultiplier(2)->ThreadRange(1, 32);
+BENCHMARK(ThreadYield)->RangeMultiplier(2)->ThreadRange(1, 32);
 
-void engine_multiple_tasks_multiple_threads(benchmark::State& state) {
+void EngineMultipleTasksMultipleThreads(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::atomic<std::uint64_t> tasks_count_total = 0;
         RunParallelBenchmark(state, [&](auto& range) {
@@ -120,9 +120,9 @@ void engine_multiple_tasks_multiple_threads(benchmark::State& state) {
         benchmark::DoNotOptimize(tasks_count_total);
     });
 }
-BENCHMARK(engine_multiple_tasks_multiple_threads)->RangeMultiplier(2)->Range(1, 32)->Arg(6)->Arg(12);
+BENCHMARK(EngineMultipleTasksMultipleThreads)->RangeMultiplier(2)->Range(1, 32)->Arg(6)->Arg(12);
 
-void engine_multiple_yield_two_task_processor_no_extra_wakeups(benchmark::State& state) {
+void EngineMultipleYieldTwoTaskProcessorNoExtraWakeups(benchmark::State& state) {
     engine::RunStandalone([&] {
         std::vector<std::unique_ptr<engine::TaskProcessor>> processors;
         for (int i = 0; i < 2; i++) {
@@ -170,9 +170,9 @@ void engine_multiple_yield_two_task_processor_no_extra_wakeups(benchmark::State&
             benchmark::Counter(static_cast<double>(yields_performed) / state.range(0), benchmark::Counter::kIsRate);
     });
 }
-BENCHMARK(engine_multiple_yield_two_task_processor_no_extra_wakeups)->RangeMultiplier(2)->Range(2, 32)->Arg(6)->Arg(12);
+BENCHMARK(EngineMultipleYieldTwoTaskProcessorNoExtraWakeups)->RangeMultiplier(2)->Range(2, 32)->Arg(6)->Arg(12);
 
-void engine_tasks_from_another_task_processor(benchmark::State& state) {
+void EngineTasksFromAnotherTaskProcessor(benchmark::State& state) {
     engine::RunStandalone([&] {
         engine::TaskProcessorConfig proc_config;
         proc_config.name = "benchmark";
@@ -192,6 +192,6 @@ void engine_tasks_from_another_task_processor(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(engine_tasks_from_another_task_processor)->RangeMultiplier(2)->Range(2, 32)->Arg(6)->Arg(12);
+BENCHMARK(EngineTasksFromAnotherTaskProcessor)->RangeMultiplier(2)->Range(2, 32)->Arg(6)->Arg(12);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/engine/task/task_context.hpp b/core/src/engine/task/task_context.hpp
index 70430929e960..6ea1da48c011 100644
--- a/core/src/engine/task/task_context.hpp
+++ b/core/src/engine/task/task_context.hpp
@@ -245,8 +245,8 @@ class TaskContext final : public ContextAccessor {
 
     // refcounter for resources and memory deallocation
     std::atomic<std::size_t> intrusive_refcount_{1};
-    friend void intrusive_ptr_add_ref(TaskContext* p) noexcept;
-    friend void intrusive_ptr_release(TaskContext* p) noexcept;
+    friend void intrusive_ptr_add_ref(TaskContext* p) noexcept;  // NOLINT(readability-identifier-naming)
+    friend void intrusive_ptr_release(TaskContext* p) noexcept;  // NOLINT(readability-identifier-naming)
 
 public:
     using WaitListHook = typename boost::intrusive::make_list_member_hook<
@@ -256,8 +256,8 @@ class TaskContext final : public ContextAccessor {
     WaitListHook wait_list_hook;
 };
 
-void intrusive_ptr_add_ref(TaskContext* p) noexcept;
-void intrusive_ptr_release(TaskContext* p) noexcept;
+void intrusive_ptr_add_ref(TaskContext* p) noexcept;  // NOLINT(readability-identifier-naming)
+void intrusive_ptr_release(TaskContext* p) noexcept;  // NOLINT(readability-identifier-naming)
 
 bool HasWaitSucceeded(TaskContext::WakeupSource) noexcept;
 
diff --git a/core/src/engine/task/task_with_result_test.cpp b/core/src/engine/task/task_with_result_test.cpp
index 9cc652537f20..555e9ab1cf9a 100644
--- a/core/src/engine/task/task_with_result_test.cpp
+++ b/core/src/engine/task/task_with_result_test.cpp
@@ -57,6 +57,19 @@ UTEST(TaskWithResult, LifetimeIfTaskCancelledBeforeStart) {
     EXPECT_TRUE(is_func_destroyed);
 }
 
+UTEST(TaskWithResult, InvalidationOfCancelledTask) {
+    auto task = utils::Async("some_task", [value = std::move("some_value")] {
+        engine::InterruptibleSleepFor(std::chrono::milliseconds(100));
+        return value;
+    });
+
+    task.RequestCancel();
+    task.Wait();
+    EXPECT_EQ(task.GetState(), engine::Task::State::kCancelled);
+    UEXPECT_THROW(task.Get(), engine::TaskCancelledException);
+    EXPECT_FALSE(task.IsValid());
+}
+
 static_assert(std::is_move_constructible_v<engine::TaskWithResult<void>>);
 static_assert(std::is_move_assignable_v<engine::TaskWithResult<void>>);
 
diff --git a/core/src/engine/wait_any_test.cpp b/core/src/engine/wait_any_test.cpp
index ba86f0e3d928..3294b6292996 100644
--- a/core/src/engine/wait_any_test.cpp
+++ b/core/src/engine/wait_any_test.cpp
@@ -69,6 +69,17 @@ UTEST(WaitAny, Cancelled) {
     task.SyncCancel();
 }
 
+UTEST(WaitAny, VectorWithCancelledTask) {
+    std::vector<engine::TaskWithResult<std::string>> tasks;
+    tasks.push_back(engine::AsyncNoSpan([] { return std::string{"some_value"}; }));
+    tasks[0].RequestCancel();
+
+    auto task_idx_opt = engine::WaitAny(tasks);
+    EXPECT_TRUE(!!task_idx_opt);
+    UEXPECT_THROW(tasks[*task_idx_opt].Get(), engine::TaskCancelledException);
+    EXPECT_EQ(engine::WaitAny(tasks), std::nullopt);
+}
+
 UTEST(WaitAny, WaitAnyFor) {
     engine::TaskWithResult<void> tasks[] = {
         engine::AsyncNoSpan([] {
diff --git a/core/src/fs/fs_cache_client.cpp b/core/src/fs/fs_cache_client.cpp
index dd0cf6627ecb..a8d84eeceebd 100644
--- a/core/src/fs/fs_cache_client.cpp
+++ b/core/src/fs/fs_cache_client.cpp
@@ -5,6 +5,7 @@
 
 #include <userver/engine/task/task_processor_fwd.hpp>
 #include <userver/fs/read.hpp>
+#include <userver/logging/log.hpp>
 #include <userver/rcu/rcu_map.hpp>
 #include <userver/utils/async.hpp>
 #include <userver/utils/periodic_task.hpp>
diff --git a/core/src/fs/temp_file.cpp b/core/src/fs/temp_file.cpp
index d03c69e4290e..91c8ce45757f 100644
--- a/core/src/fs/temp_file.cpp
+++ b/core/src/fs/temp_file.cpp
@@ -1,6 +1,7 @@
 #include <userver/fs/temp_file.hpp>
 
 #include <userver/engine/async.hpp>
+#include <userver/logging/log.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -27,7 +28,13 @@ TempFile::Create(std::string_view parent_path, std::string_view name_prefix, eng
     };
 }
 
-TempFile::~TempFile() { std::move(*this).Remove(); }
+TempFile::~TempFile() noexcept {
+    try {
+        std::move(*this).Remove();
+    } catch (const std::exception& ex) {
+        LOG_ERROR() << "fs::~TempFile failed with exception:" << ex;
+    }
+}
 
 TempFile TempFile::Adopt(std::string path, engine::TaskProcessor& fs_task_processor) {
     return {fs_task_processor, blocking::TempFile::Adopt(std::move(path))};
diff --git a/core/src/fs/temp_file_test.cpp b/core/src/fs/temp_file_test.cpp
new file mode 100644
index 000000000000..7a14a19ecfea
--- /dev/null
+++ b/core/src/fs/temp_file_test.cpp
@@ -0,0 +1,75 @@
+#include <gmock/gmock.h>
+#include <userver/utest/utest.hpp>
+
+#include <boost/filesystem/operations.hpp>
+
+#include <userver/engine/task/current_task.hpp>
+#include <userver/fs/blocking/temp_directory.hpp>
+#include <userver/fs/temp_file.hpp>
+#include <userver/logging/log.hpp>
+#include <userver/utest/log_capture_fixture.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+using FsTempFileWithLog = utest::LogCaptureFixture<>;
+}
+
+UTEST_F(FsTempFileWithLog, TempFileDestructorWithException) {
+    std::string parent_dir;
+    {
+        const auto parent = fs::blocking::TempDirectory::Create();
+        parent_dir = parent.GetPath();
+
+        {
+            // Create temp file in temporaty directory
+            const auto file = fs::TempFile::Create(
+                parent_dir, "TempFileDestructorWithException", engine::current_task::GetTaskProcessor()
+            );
+
+            const auto dir_status = boost::filesystem::status(parent_dir);
+            const auto original_perms = dir_status.permissions();
+
+            LOG_DEBUG() << "Original directory permissions: " << static_cast<int>(original_perms);
+
+            // Check that the directory has write permissions
+            ASSERT_TRUE((original_perms & boost::filesystem::perms::owner_write) != boost::filesystem::perms::no_perms);
+
+            // Change permissions for the directory
+            boost::filesystem::permissions(
+                parent_dir,
+                boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_exe |
+                    boost::filesystem::perms::group_read | boost::filesystem::perms::group_exe |
+                    boost::filesystem::perms::others_read | boost::filesystem::perms::others_exe
+            );
+            LOG_DEBUG() << "Changed directory permissions, write is now forbidden";
+
+            // Check that the file can not be removed
+            try {
+                boost::filesystem::remove(file.GetPath());
+                FAIL() << "Expected exception when removing file";
+            } catch (const std::exception& ex) {
+                LOG_DEBUG() << "Confirmed file cannot be removed";
+            }
+
+            // We don't expect that ~TempFile to throw an exception
+        }
+
+        // Check that log with error from ~TempFile exists
+        EXPECT_THAT(GetLogCapture().Filter("fs::~TempFile failed with exception:"), testing::SizeIs(1));
+
+        // Rollback directory permissions
+        boost::filesystem::permissions(
+            parent_dir,
+            boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_write |
+                boost::filesystem::perms::owner_exe | boost::filesystem::perms::group_read |
+                boost::filesystem::perms::group_write | boost::filesystem::perms::group_exe |
+                boost::filesystem::perms::others_read | boost::filesystem::perms::others_write |
+                boost::filesystem::perms::others_exe
+        );
+        LOG_DEBUG() << "Changed directory permissions, write is now available";
+    }
+    ASSERT_FALSE(boost::filesystem::exists(parent_dir));
+}
+
+USERVER_NAMESPACE_END
diff --git a/core/src/logging/impl/file_sinks_benchmark.cpp b/core/src/logging/impl/file_sinks_benchmark.cpp
index c82259d75f6d..c9c66b3d86a9 100644
--- a/core/src/logging/impl/file_sinks_benchmark.cpp
+++ b/core/src/logging/impl/file_sinks_benchmark.cpp
@@ -10,7 +10,7 @@ USERVER_NAMESPACE_BEGIN
 
 constexpr ssize_t kCountLogs = 100000;
 
-void check_file_sink(benchmark::State& state) {
+void CheckFileSink(benchmark::State& state) {
     const auto temp_root = fs::blocking::TempDirectory::Create();
     const std::string filename = temp_root.GetPath() + "/temp_file_" + std::to_string(utils::Rand());
     auto sink = logging::impl::FileSink(filename);
@@ -21,9 +21,9 @@ void check_file_sink(benchmark::State& state) {
     }
     sink.Flush();
 }
-BENCHMARK(check_file_sink);
+BENCHMARK(CheckFileSink);
 
-void check_buffered_file_sink(benchmark::State& state) {
+void CheckBufferedFileSink(benchmark::State& state) {
     const auto temp_root = fs::blocking::TempDirectory::Create();
     const std::string filename = temp_root.GetPath() + "/temp_file_" + std::to_string(utils::Rand());
     auto sink = logging::impl::BufferedFileSink(filename);
@@ -34,6 +34,6 @@ void check_buffered_file_sink(benchmark::State& state) {
     }
     sink.Flush();
 }
-BENCHMARK(check_buffered_file_sink);
+BENCHMARK(CheckBufferedFileSink);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/logging/log_message_benchmark.cpp b/core/src/logging/log_message_benchmark.cpp
index 9ef43d6cedde..2c8c2aef9dae 100644
--- a/core/src/logging/log_message_benchmark.cpp
+++ b/core/src/logging/log_message_benchmark.cpp
@@ -91,14 +91,14 @@ BENCHMARK_DEFINE_F(LogHelperBenchmark, LogCheck)(benchmark::State& state) {
 BENCHMARK_REGISTER_F(LogHelperBenchmark, LogCheck);
 
 struct StreamedStruct {
-    int64_t intVal;
-    std::string stringVal;
+    int64_t int_val;
+    std::string string_val;
 };
 
 std::ostream& operator<<(std::ostream& os, const StreamedStruct& value) {
     const std::ostream::sentry s(os);
     if (s) {
-        os << value.intVal << " " << value.stringVal;
+        os << value.int_val << " " << value.string_val;
     }
     return os;
 }
diff --git a/core/src/logging/logger.cpp b/core/src/logging/logger.cpp
index 2d333f4115a0..6603f0494c4a 100644
--- a/core/src/logging/logger.cpp
+++ b/core/src/logging/logger.cpp
@@ -66,7 +66,7 @@ LoggerPtr MakeFileLogger(const std::string& name, const std::string& path, Forma
     return MakeSimpleLogger(name, std::make_unique<impl::BufferedFileSink>(path), level, format);
 }
 
-namespace impl::default_ {
+namespace impl {
 
 bool DoShouldLog(Level level) noexcept {
     const auto* const span = tracing::Span::CurrentSpanUnchecked();
@@ -98,7 +98,7 @@ void PrependCommonTags(TagWriter writer, Level logger_level) {
     }
 }
 
-}  // namespace impl::default_
+}  // namespace impl
 
 }  // namespace logging
 
diff --git a/core/src/logging/tp_logger.cpp b/core/src/logging/tp_logger.cpp
index c527e591b3e7..380f2bc0d5d6 100644
--- a/core/src/logging/tp_logger.cpp
+++ b/core/src/logging/tp_logger.cpp
@@ -154,9 +154,9 @@ void TpLogger::Log(Level level, impl::formatters::LoggerItemRef item) {
     }
 }
 
-void TpLogger::PrependCommonTags(TagWriter writer) const { impl::default_::PrependCommonTags(writer, GetLevel()); }
+void TpLogger::PrependCommonTags(TagWriter writer) const { impl::PrependCommonTags(writer, GetLevel()); }
 
-bool TpLogger::DoShouldLog(Level level) const noexcept { return impl::default_::DoShouldLog(level); }
+bool TpLogger::DoShouldLog(Level level) const noexcept { return impl::DoShouldLog(level); }
 
 void TpLogger::AddSink(impl::SinkPtr&& sink) {
     UASSERT(sink);
diff --git a/core/src/rcu/atomic_shared_ptr_benchmark.cpp b/core/src/rcu/atomic_shared_ptr_benchmark.cpp
index 240e2656136f..56745761c048 100644
--- a/core/src/rcu/atomic_shared_ptr_benchmark.cpp
+++ b/core/src/rcu/atomic_shared_ptr_benchmark.cpp
@@ -28,7 +28,7 @@ class AtomicSharedPtr {
     std::shared_ptr<const T> storage_;
 };
 
-void atomic_shared_ptr_read(benchmark::State& state) {
+void AtomicSharedPtrRead(benchmark::State& state) {
     engine::RunStandalone([&] {
         const AtomicSharedPtr<int> ptr(std::make_unique<int>(1));
 
@@ -38,9 +38,9 @@ void atomic_shared_ptr_read(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(atomic_shared_ptr_read);
+BENCHMARK(AtomicSharedPtrRead);
 
-void atomic_shared_ptr_contention(benchmark::State& state) {
+void AtomicSharedPtrContention(benchmark::State& state) {
     engine::RunStandalone(state.range(0), [&] {
         std::atomic<bool> run{true};
         AtomicSharedPtr<std::unordered_map<int, int>> ptr{std::make_shared<std::unordered_map<int, int>>()};
@@ -74,6 +74,6 @@ void atomic_shared_ptr_contention(benchmark::State& state) {
         run = false;
     });
 }
-BENCHMARK(atomic_shared_ptr_contention)->RangeMultiplier(2)->Ranges({{2, 32}, {false, true}});
+BENCHMARK(AtomicSharedPtrContention)->RangeMultiplier(2)->Ranges({{2, 32}, {false, true}});
 
 USERVER_NAMESPACE_END
diff --git a/core/src/rcu/rcu_benchmark.cpp b/core/src/rcu/rcu_benchmark.cpp
index 855989e640d6..6f2fa91aebb1 100644
--- a/core/src/rcu/rcu_benchmark.cpp
+++ b/core/src/rcu/rcu_benchmark.cpp
@@ -15,7 +15,7 @@
 USERVER_NAMESPACE_BEGIN
 
 template <int VariableCount>
-void rcu_read(benchmark::State& state) {
+void RcuRead(benchmark::State& state) {
     engine::RunStandalone([&] {
         rcu::Variable<std::uint64_t> vars[VariableCount];
         {
@@ -34,12 +34,12 @@ void rcu_read(benchmark::State& state) {
         }
     });
 }
-BENCHMARK_TEMPLATE(rcu_read, 1);
-BENCHMARK_TEMPLATE(rcu_read, 2);
-BENCHMARK_TEMPLATE(rcu_read, 4);
+BENCHMARK_TEMPLATE(RcuRead, 1);
+BENCHMARK_TEMPLATE(RcuRead, 2);
+BENCHMARK_TEMPLATE(RcuRead, 4);
 
 template <int VariableCount>
-void rcu_write(benchmark::State& state) {
+void RcuWrite(benchmark::State& state) {
     engine::RunStandalone([&] {
         rcu::Variable<std::uint64_t> vars[VariableCount];
 
@@ -50,11 +50,11 @@ void rcu_write(benchmark::State& state) {
         }
     });
 }
-BENCHMARK_TEMPLATE(rcu_write, 1);
-BENCHMARK_TEMPLATE(rcu_write, 2);
-BENCHMARK_TEMPLATE(rcu_write, 4);
+BENCHMARK_TEMPLATE(RcuWrite, 1);
+BENCHMARK_TEMPLATE(RcuWrite, 2);
+BENCHMARK_TEMPLATE(RcuWrite, 4);
 
-void rcu_contention(benchmark::State& state) {
+void RcuContention(benchmark::State& state) {
     const std::size_t readers_count = state.range(0);
     const std::size_t writers_count = state.range(1);
     const std::size_t kept_readable_pointers_count = state.range(2);
@@ -112,12 +112,9 @@ void rcu_contention(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(rcu_contention)
-    ->RangeMultiplier(2)
-    ->Ranges({{1, 16}, {0, 1}, {1, 4}})
-    ->Ranges({{2048, 2048}, {0, 1}, {1, 4}});
+BENCHMARK(RcuContention)->RangeMultiplier(2)->Ranges({{1, 16}, {0, 1}, {1, 4}})->Ranges({{2048, 2048}, {0, 1}, {1, 4}});
 
-void rcu_of_shared_ptr(benchmark::State& state) {
+void RcuOfSharedPtr(benchmark::State& state) {
     const std::size_t readers_count = state.range(0);
 
     engine::RunStandalone(readers_count, [&] {
@@ -131,6 +128,6 @@ void rcu_of_shared_ptr(benchmark::State& state) {
         });
     });
 }
-BENCHMARK(rcu_of_shared_ptr)->RangeMultiplier(2)->Range(1, 32);
+BENCHMARK(RcuOfSharedPtr)->RangeMultiplier(2)->Range(1, 32);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/rcu/rcu_test.cpp b/core/src/rcu/rcu_test.cpp
index dd6c4941dc23..292202fe763f 100644
--- a/core/src/rcu/rcu_test.cpp
+++ b/core/src/rcu/rcu_test.cpp
@@ -217,7 +217,7 @@ UTEST(Rcu, ReadablePtrMoveAssign) {
 
 UTEST(Rcu, NoCopy) {
     struct X {
-        X(int x_, bool y_) : x(x_), y(y_) {}
+        X(int x, bool y) : x(x), y(y) {}
 
         X(X&&) = default;
         X(const X&) = delete;
diff --git a/core/src/server/component.cpp b/core/src/server/component.cpp
index 54092d6fe7bb..061832739d5a 100644
--- a/core/src/server/component.cpp
+++ b/core/src/server/component.cpp
@@ -79,7 +79,7 @@ additionalProperties: false
         description: set to logger name from components::Logging component to write access logs in TSKV format into it; do not set to avoid writing access logs
     max_response_size_in_flight:
         type: integer
-        description: set it to the size of response in bytes and the component will drop bigger responses from handlers that allow throttling
+        description: drop incomming requests if the handler allows throttling and the size of waiting for send responses in bytes is greater than this value
     server-name:
         type: string
         description: value to send in HTTP Server header
diff --git a/core/src/server/handlers/auth/digest/auth_checker_base.cpp b/core/src/server/handlers/auth/digest/auth_checker_base.cpp
index 4c82a777f02b..c4ee87a3de33 100644
--- a/core/src/server/handlers/auth/digest/auth_checker_base.cpp
+++ b/core/src/server/handlers/auth/digest/auth_checker_base.cpp
@@ -44,8 +44,7 @@ class ServerDigestSecretKey {
     const ServerDigestAuthSecret& GetSecretKey() const {
         if (!secret_key_.has_value()) {
             throw std::runtime_error(
-                "Secret key storage is missing. Field "
-                "'http_server_digest_auth_secret' was missing in json."
+                "Secret key storage is missing. Field 'http_server_digest_auth_secret' was missing in json."
             );
         }
 
@@ -61,31 +60,47 @@ class ServerDigestSecretKey {
 UserData::UserData(HA1 ha1, std::string nonce, TimePoint timestamp, std::int64_t nonce_count)
     : ha1(std::move(ha1)), nonce(std::move(nonce)), timestamp(timestamp), nonce_count(nonce_count) {}
 
-Hasher::Hasher(std::string_view algorithm, const SecdistConfig& secdist_config) : secdist_config_(secdist_config) {
-    switch (kHashAlgToType.TryFindICase(algorithm).value_or(HashAlgTypes::kUnknown)) {
-        case HashAlgTypes::kMD5:
-            hash_algorithm_ = &crypto::hash::weak::Md5;
-            break;
-        case HashAlgTypes::kSHA256:
-            hash_algorithm_ = &crypto::hash::Sha256;
-            break;
-        case HashAlgTypes::kSHA512:
-            hash_algorithm_ = &crypto::hash::Sha512;
-            break;
-        default:
-            throw std::runtime_error("Unknown hash algorithm");
+Hasher::Hasher(std::string_view algorithm, const SecdistConfig& secdist_config)
+    : hash_algorithm_{kHashAlgToType.TryFindICase(algorithm).value_or(HashAlgTypes::kUnknown)},
+      secdist_config_(secdist_config) {
+    if (hash_algorithm_ == HashAlgTypes::kUnknown) {
+        throw std::runtime_error("Unknown hash algorithm");
     }
 }
 
 std::string Hasher::GenerateNonce(std::string_view etag) const {
-    auto timestamp = std::to_string(std::chrono::system_clock::now().time_since_epoch().count());
-    return GetHash(fmt::format(
-        "{}:{}:{}", timestamp, etag, secdist_config_.Get<ServerDigestSecretKey>().GetSecretKey().GetUnderlying()
-    ));
+    const auto timestamp = std::to_string(std::chrono::system_clock::now().time_since_epoch().count());
+    return GetHash(
+        {timestamp, ":", etag, ":", secdist_config_.Get<ServerDigestSecretKey>().GetSecretKey().GetUnderlying()}
+    );
 }
 
 std::string Hasher::GetHash(std::string_view data) const {
-    return hash_algorithm_(data, crypto::hash::OutputEncoding::kHex);
+    switch (hash_algorithm_) {
+        case HashAlgTypes::kMD5:
+            return crypto::hash::weak::Md5(data, crypto::hash::OutputEncoding::kHex);
+        case HashAlgTypes::kSHA256:
+            return crypto::hash::Sha256(data, crypto::hash::OutputEncoding::kHex);
+        case HashAlgTypes::kSHA512:
+            return crypto::hash::Sha512(data, crypto::hash::OutputEncoding::kHex);
+        case HashAlgTypes::kUnknown:
+            UASSERT_MSG(false, "Unknown hash algorithm");
+    }
+    UINVARIANT(false, "Unknown hash algorithm");
+}
+
+std::string Hasher::GetHash(std::initializer_list<std::string_view> data) const {
+    switch (hash_algorithm_) {
+        case HashAlgTypes::kMD5:
+            return crypto::hash::weak::Md5(data, crypto::hash::OutputEncoding::kHex);
+        case HashAlgTypes::kSHA256:
+            return crypto::hash::Sha256(data, crypto::hash::OutputEncoding::kHex);
+        case HashAlgTypes::kSHA512:
+            return crypto::hash::Sha512(data, crypto::hash::OutputEncoding::kHex);
+        case HashAlgTypes::kUnknown:
+            UASSERT_MSG(false, "Unknown hash algorithm");
+    }
+    UINVARIANT(false, "Unknown hash algorithm");
 }
 
 AuthCheckerBase::AuthCheckerBase(
@@ -275,19 +290,21 @@ std::string AuthCheckerBase::CalculateDigest(
         ha1 = fmt::format("{}:{}:{}", ha1, client_context.nonce, client_context.cnonce);
     }
 
-    auto a2 = fmt::format("{}:{}", ToString(request_method), client_context.uri);
-    auto ha2 = digest_hasher_.GetHash(a2);
-
-    auto request_digest = fmt::format(
-        "{}:{}:{}:{}:{}:{}",
-        ha1,
-        client_context.nonce,
-        client_context.nc,
-        client_context.cnonce,
-        client_context.qop,
-        ha2
+    const auto ha2 = digest_hasher_.GetHash({ToString(request_method), ":", client_context.uri});
+
+    return digest_hasher_.GetHash(
+        {ha1,
+         ":",
+         client_context.nonce,
+         ":",
+         client_context.nc,
+         ":",
+         client_context.cnonce,
+         ":",
+         client_context.qop,
+         ":",
+         ha2}
     );
-    return digest_hasher_.GetHash(request_digest);
 }
 
 }  // namespace server::handlers::auth::digest
diff --git a/core/src/server/handlers/auth/digest/directives_parser.cpp b/core/src/server/handlers/auth/digest/directives_parser.cpp
index b5914472d7c4..fa3c124ffec1 100644
--- a/core/src/server/handlers/auth/digest/directives_parser.cpp
+++ b/core/src/server/handlers/auth/digest/directives_parser.cpp
@@ -18,7 +18,7 @@ namespace {
 
 constexpr utils::StringLiteral kDigestWord = "Digest";
 
-enum class kClientDirectiveTypes {
+enum class ClientDirectiveTypes {
     kUsername,
     kRealm,
     kNonce,
@@ -35,25 +35,25 @@ enum class kClientDirectiveTypes {
 
 const utils::TrivialBiMap kClientDirectivesMap = [](auto selector) {
     return selector()
-        .Case(directives::kUsername, kClientDirectiveTypes::kUsername)
-        .Case(directives::kRealm, kClientDirectiveTypes::kRealm)
-        .Case(directives::kNonce, kClientDirectiveTypes::kNonce)
-        .Case(directives::kUri, kClientDirectiveTypes::kUri)
-        .Case(directives::kResponse, kClientDirectiveTypes::kResponse)
-        .Case(directives::kAlgorithm, kClientDirectiveTypes::kAlgorithm)
-        .Case(directives::kCnonce, kClientDirectiveTypes::kCnonce)
-        .Case(directives::kOpaque, kClientDirectiveTypes::kOpaque)
-        .Case(directives::kQop, kClientDirectiveTypes::kQop)
-        .Case(directives::kNonceCount, kClientDirectiveTypes::kNonceCount)
-        .Case(directives::kAuthParam, kClientDirectiveTypes::kAuthParam);
+        .Case(directives::kUsername, ClientDirectiveTypes::kUsername)
+        .Case(directives::kRealm, ClientDirectiveTypes::kRealm)
+        .Case(directives::kNonce, ClientDirectiveTypes::kNonce)
+        .Case(directives::kUri, ClientDirectiveTypes::kUri)
+        .Case(directives::kResponse, ClientDirectiveTypes::kResponse)
+        .Case(directives::kAlgorithm, ClientDirectiveTypes::kAlgorithm)
+        .Case(directives::kCnonce, ClientDirectiveTypes::kCnonce)
+        .Case(directives::kOpaque, ClientDirectiveTypes::kOpaque)
+        .Case(directives::kQop, ClientDirectiveTypes::kQop)
+        .Case(directives::kNonceCount, ClientDirectiveTypes::kNonceCount)
+        .Case(directives::kAuthParam, ClientDirectiveTypes::kAuthParam);
 };
 
-const std::array<kClientDirectiveTypes, kClientMandatoryDirectivesNumber> kMandatoryDirectives = {
-    kClientDirectiveTypes::kRealm,
-    kClientDirectiveTypes::kNonce,
-    kClientDirectiveTypes::kResponse,
-    kClientDirectiveTypes::kUri,
-    kClientDirectiveTypes::kUsername};
+const std::array<ClientDirectiveTypes, kClientMandatoryDirectivesNumber> kMandatoryDirectives = {
+    ClientDirectiveTypes::kRealm,
+    ClientDirectiveTypes::kNonce,
+    ClientDirectiveTypes::kResponse,
+    ClientDirectiveTypes::kUri,
+    ClientDirectiveTypes::kUsername};
 
 enum class State {
     kStateSpace,
@@ -170,44 +170,44 @@ ContextFromClient Parser::ParseAuthInfo(std::string_view auth_header_value) {
 
 void Parser::PushToClientContext(std::string&& directive, std::string&& value, ContextFromClient& client_context) {
     const auto directive_type =
-        kClientDirectivesMap.TryFind(std::move(directive)).value_or(kClientDirectiveTypes::kUnknown);
+        kClientDirectivesMap.TryFind(std::move(directive)).value_or(ClientDirectiveTypes::kUnknown);
     const auto index = static_cast<std::size_t>(directive_type);
-    if (directive_type != kClientDirectiveTypes::kUnknown) directives_counter_[index]++;
+    if (directive_type != ClientDirectiveTypes::kUnknown) directives_counter_[index]++;
     switch (directive_type) {
-        case kClientDirectiveTypes::kUsername:
+        case ClientDirectiveTypes::kUsername:
             client_context.username = std::move(value);
             break;
-        case kClientDirectiveTypes::kRealm:
+        case ClientDirectiveTypes::kRealm:
             client_context.realm = std::move(value);
             break;
-        case kClientDirectiveTypes::kNonce:
+        case ClientDirectiveTypes::kNonce:
             client_context.nonce = std::move(value);
             break;
-        case kClientDirectiveTypes::kUri:
+        case ClientDirectiveTypes::kUri:
             client_context.uri = std::move(value);
             break;
-        case kClientDirectiveTypes::kResponse:
+        case ClientDirectiveTypes::kResponse:
             client_context.response = std::move(value);
             break;
-        case kClientDirectiveTypes::kAlgorithm:
+        case ClientDirectiveTypes::kAlgorithm:
             client_context.algorithm = std::move(value);
             break;
-        case kClientDirectiveTypes::kCnonce:
+        case ClientDirectiveTypes::kCnonce:
             client_context.cnonce = std::move(value);
             break;
-        case kClientDirectiveTypes::kOpaque:
+        case ClientDirectiveTypes::kOpaque:
             client_context.opaque = std::move(value);
             break;
-        case kClientDirectiveTypes::kQop:
+        case ClientDirectiveTypes::kQop:
             client_context.qop = std::move(value);
             break;
-        case kClientDirectiveTypes::kNonceCount:
+        case ClientDirectiveTypes::kNonceCount:
             client_context.nc = std::move(value);
             break;
-        case kClientDirectiveTypes::kAuthParam:
+        case ClientDirectiveTypes::kAuthParam:
             client_context.authparam = std::move(value);
             break;
-        case kClientDirectiveTypes::kUnknown:
+        case ClientDirectiveTypes::kUnknown:
             throw ParseException("Unknown directive found");
             break;
     }
@@ -237,7 +237,7 @@ void Parser::CheckDuplicateDirectivesExist() const {
 
     if (it != directives_counter_.end()) {
         const auto index = std::distance(directives_counter_.begin(), it);
-        const auto directive_type = static_cast<kClientDirectiveTypes>(index);
+        const auto directive_type = static_cast<ClientDirectiveTypes>(index);
         auto directive =
             kClientDirectivesMap.TryFind(directive_type).value_or(utils::StringLiteral{"unknown_directive"});
         UASSERT(directive != "unknown_directive");
diff --git a/core/src/server/handlers/auth/digest/standalone_checker_test.cpp b/core/src/server/handlers/auth/digest/standalone_checker_test.cpp
index acfbfdff24b8..9f66001ef3a5 100644
--- a/core/src/server/handlers/auth/digest/standalone_checker_test.cpp
+++ b/core/src/server/handlers/auth/digest/standalone_checker_test.cpp
@@ -67,7 +67,7 @@ class StandAloneCheckerTest : public ::testing::Test {
                {}}
           ),
           secdist_config({&default_loader, std::chrono::milliseconds::zero()}),
-          digest_settings_({
+          digest_settings({
               "MD5",                             // algorithm
               std::vector<std::string>{"/"},     // domains
               std::vector<std::string>{"auth"},  // qops
@@ -75,8 +75,8 @@ class StandAloneCheckerTest : public ::testing::Test {
               false,                             // is_session
               kNonceTTL                          // nonce_ttl
           }),
-          checker_(digest_settings_, "testrealm@host.com", secdist_config),
-          correct_client_context_({
+          checker(digest_settings, "testrealm@host.com", secdist_config),
+          correct_client_context({
               "Mufasa",                            // username
               "testrealm@host.com",                // realm
               kValidNonce,                         // nonce
@@ -89,58 +89,58 @@ class StandAloneCheckerTest : public ::testing::Test {
               "00000001",                          // nc
               "auth-param"                         // authparam
           }) {
-        client_context_ = correct_client_context_;
+        client_context = correct_client_context;
     }
 
     TempFileProvider temp_file_provider;
     storages::secdist::DefaultLoader default_loader;
     storages::secdist::SecdistConfig secdist_config;
 
-    AuthCheckerSettings digest_settings_;
-    StandAloneChecker checker_;
-    ContextFromClient client_context_;
-    ContextFromClient correct_client_context_;
+    AuthCheckerSettings digest_settings;
+    StandAloneChecker checker;
+    ContextFromClient client_context;
+    ContextFromClient correct_client_context;
 };
 
 UTEST_F(StandAloneCheckerTest, NonceTTL) {
     utils::datetime::MockNowSet(utils::datetime::Now());
-    checker_.PushUnnamedNonce(kValidNonce);
+    checker.PushUnnamedNonce(kValidNonce);
 
     const UserData test_data{kValidHA1, kValidNonce, utils::datetime::Now(), 0};
     utils::datetime::MockSleep(kNonceTTL - std::chrono::milliseconds(100));
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kOk);
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kOk);
 
     utils::datetime::MockSleep(kNonceTTL + std::chrono::milliseconds(100));
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kWrongUserData);
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kWrongUserData);
 }
 
 UTEST_F(StandAloneCheckerTest, NonceCount) {
-    checker_.PushUnnamedNonce(kValidNonce);
+    checker.PushUnnamedNonce(kValidNonce);
 
     UserData test_data{kValidHA1, kValidNonce, utils::datetime::Now(), 0};
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kOk);
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kOk);
 
     test_data.nonce_count++;
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kDuplicateRequest);
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kDuplicateRequest);
 
-    correct_client_context_.nc = "00000002";
-    client_context_ = correct_client_context_;
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kOk);
+    correct_client_context.nc = "00000002";
+    client_context = correct_client_context;
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kOk);
 }
 
 UTEST_F(StandAloneCheckerTest, InvalidNonce) {
     const auto* invalid_nonce_ = "abc88743bacdf9238";
     UserData test_data{kValidHA1, invalid_nonce_, utils::datetime::Now(), 0};
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kWrongUserData);
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kWrongUserData);
 
     test_data.nonce = kValidNonce;
-    EXPECT_EQ(checker_.ValidateUserData(client_context_, test_data), ValidateResult::kOk);
+    EXPECT_EQ(checker.ValidateUserData(client_context, test_data), ValidateResult::kOk);
 }
 
 UTEST_F(StandAloneCheckerTest, NonceCountConvertingThrow) {
-    client_context_.nc = "not-a-hex-number";
+    client_context.nc = "not-a-hex-number";
     const UserData test_data{kValidHA1, kValidNonce, utils::datetime::Now(), 0};
-    EXPECT_THROW(checker_.ValidateUserData(client_context_, test_data), std::runtime_error);
+    EXPECT_THROW(checker.ValidateUserData(client_context, test_data), std::runtime_error);
 }
 
 }  // namespace server::handlers::auth::digest::test
diff --git a/core/src/server/handlers/exceptions_test.cpp b/core/src/server/handlers/exceptions_test.cpp
index 4c544409d646..5c92e0e2dca1 100644
--- a/core/src/server/handlers/exceptions_test.cpp
+++ b/core/src/server/handlers/exceptions_test.cpp
@@ -17,13 +17,13 @@ class CustomErrorBuilder {
         formats::json::ValueBuilder error;
         error["code"] = std::move(status);
         error["message"] = std::move(msg);
-        json_error_body = formats::json::ToString(error.ExtractValue());
+        json_error_body_ = formats::json::ToString(error.ExtractValue());
     }
 
-    std::string GetExternalBody() const { return json_error_body; }
+    std::string GetExternalBody() const { return json_error_body_; }
 
 private:
-    std::string json_error_body;
+    std::string json_error_body_;
 };
 
 TEST(CustomHandlerException, BuilderSample) {
diff --git a/core/src/server/handlers/server_monitor.cpp b/core/src/server/handlers/server_monitor.cpp
index 0b085dea82e3..b9d92eea07dc 100644
--- a/core/src/server/handlers/server_monitor.cpp
+++ b/core/src/server/handlers/server_monitor.cpp
@@ -131,6 +131,8 @@ std::string ServerMonitor::HandleRequestThrow(const http::HttpRequest& request,
     }
 
     UINVARIANT(false, "Unexpected 'format' value");
+    // never reaches
+    return {};
 }
 
 std::string
diff --git a/core/src/server/http/http_cached_date.cpp b/core/src/server/http/http_cached_date.cpp
index cd0ae75eaca4..2b1bf4c46b9d 100644
--- a/core/src/server/http/http_cached_date.cpp
+++ b/core/src/server/http/http_cached_date.cpp
@@ -46,7 +46,14 @@ std::string_view GetCachedDate() {
         cache->last_time_string_size = time_str.size();
     }
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-stack-address"
+#endif
     return std::string_view{cache->last_time_string, cache->last_time_string_size};
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
 }
 
 }  // namespace impl
diff --git a/core/src/server/http/http_cached_date_benchmark.cpp b/core/src/server/http/http_cached_date_benchmark.cpp
index a0b9f532ba22..f63b59de4acc 100644
--- a/core/src/server/http/http_cached_date_benchmark.cpp
+++ b/core/src/server/http/http_cached_date_benchmark.cpp
@@ -5,18 +5,18 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void http_get_cached_date_benchmark(benchmark::State& state) {
+void HttpGetCachedDateBenchmark(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(server::http::impl::GetCachedDate());
     }
 }
-BENCHMARK(http_get_cached_date_benchmark);
+BENCHMARK(HttpGetCachedDateBenchmark);
 
-void http_make_date_benchmark(benchmark::State& state) {
+void HttpMakeDateBenchmark(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(server::http::impl::MakeHttpDate(utils::datetime::WallCoarseClock::now()));
     }
 }
-BENCHMARK(http_make_date_benchmark);
+BENCHMARK(HttpMakeDateBenchmark);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/http/http_method.cpp b/core/src/server/http/http_method.cpp
index b52f5b87846f..366d962be71e 100644
--- a/core/src/server/http/http_method.cpp
+++ b/core/src/server/http/http_method.cpp
@@ -6,6 +6,8 @@ namespace server::http {
 
 namespace {
 
+// NOLINTBEGIN(readability-identifier-naming)
+// Struct because of static initialization order fiasco.
 struct HttpMethodStrings {
     const std::string kDelete = "DELETE";
     const std::string kGet = "GET";
@@ -17,6 +19,7 @@ struct HttpMethodStrings {
     const std::string kOptions = "OPTIONS";
     const std::string kUnknown = "unknown";
 };
+// NOLINTEND(readability-identifier-naming)
 
 // Modern SSO could hold 7 chars without dynamic allocation
 const HttpMethodStrings& GetHttpMethodStrings() noexcept {
diff --git a/core/src/server/http/http_request.cpp b/core/src/server/http/http_request.cpp
index 3128bc3a8f57..4748efadcf4a 100644
--- a/core/src/server/http/http_request.cpp
+++ b/core/src/server/http/http_request.cpp
@@ -72,17 +72,17 @@ HttpRequest::HttpRequest(request::ResponseDataAccounter& data_accounter, utils::
 
 HttpRequest::~HttpRequest() = default;
 
-const HttpMethod& HttpRequest::GetMethod() const { return pimpl_->method_; }
+const HttpMethod& HttpRequest::GetMethod() const { return pimpl_->method; }
 
-const std::string& HttpRequest::GetMethodStr() const { return ToString(pimpl_->method_); }
+const std::string& HttpRequest::GetMethodStr() const { return ToString(pimpl_->method); }
 
-int HttpRequest::GetHttpMajor() const { return pimpl_->http_major_; }
+int HttpRequest::GetHttpMajor() const { return pimpl_->http_major; }
 
-int HttpRequest::GetHttpMinor() const { return pimpl_->http_minor_; }
+int HttpRequest::GetHttpMinor() const { return pimpl_->http_minor; }
 
-const std::string& HttpRequest::GetUrl() const { return pimpl_->url_; }
+const std::string& HttpRequest::GetUrl() const { return pimpl_->url; }
 
-const std::string& HttpRequest::GetRequestPath() const { return pimpl_->request_path_; }
+const std::string& HttpRequest::GetRequestPath() const { return pimpl_->request_path; }
 
 std::chrono::duration<double> HttpRequest::GetRequestTime() const {
     return GetHttpResponse().SentTime() - GetStartTime();
@@ -94,44 +94,44 @@ std::chrono::duration<double> HttpRequest::GetResponseTime() const {
 
 const std::string& HttpRequest::GetHost() const { return GetHeader(USERVER_NAMESPACE::http::headers::kHost); }
 
-const engine::io::Sockaddr& HttpRequest::GetRemoteAddress() const { return pimpl_->remote_address_; }
+const engine::io::Sockaddr& HttpRequest::GetRemoteAddress() const { return pimpl_->remote_address; }
 
 const std::string& HttpRequest::GetArg(std::string_view arg_name) const {
 #ifndef NDEBUG
-    pimpl_->args_referenced_ = true;
+    pimpl_->args_referenced = true;
 #endif
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->request_args_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->request_args, arg_name);
     if (!ptr) return kEmptyString;
     return ptr->at(0);
 }
 
 const std::vector<std::string>& HttpRequest::GetArgVector(std::string_view arg_name) const {
 #ifndef NDEBUG
-    pimpl_->args_referenced_ = true;
+    pimpl_->args_referenced = true;
 #endif
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->request_args_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->request_args, arg_name);
     if (!ptr) return kEmptyVector;
     return *ptr;
 }
 
 bool HttpRequest::HasArg(std::string_view arg_name) const {
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->request_args_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->request_args, arg_name);
     return !!ptr;
 }
 
-size_t HttpRequest::ArgCount() const { return pimpl_->request_args_.size(); }
+size_t HttpRequest::ArgCount() const { return pimpl_->request_args.size(); }
 
 std::vector<std::string> HttpRequest::ArgNames() const {
     std::vector<std::string> res;
-    res.reserve(pimpl_->request_args_.size());
-    for (const auto& arg : pimpl_->request_args_) res.push_back(arg.first);
+    res.reserve(pimpl_->request_args.size());
+    for (const auto& arg : pimpl_->request_args) res.push_back(arg.first);
     return res;
 }
 
 const FormDataArg& HttpRequest::GetFormDataArg(std::string_view arg_name) const {
     static const FormDataArg kEmptyFormDataArg{};
 
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->form_data_args_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->form_data_args, arg_name);
     if (!ptr) return kEmptyFormDataArg;
     return ptr->at(0);
 }
@@ -139,202 +139,198 @@ const FormDataArg& HttpRequest::GetFormDataArg(std::string_view arg_name) const
 const std::vector<FormDataArg>& HttpRequest::GetFormDataArgVector(std::string_view arg_name) const {
     static const std::vector<FormDataArg> kEmptyFormDataArgVector{};
 
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->form_data_args_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->form_data_args, arg_name);
     if (!ptr) return kEmptyFormDataArgVector;
     return *ptr;
 }
 
 bool HttpRequest::HasFormDataArg(std::string_view arg_name) const {
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->form_data_args_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->form_data_args, arg_name);
     return !!ptr;
 }
 
-size_t HttpRequest::FormDataArgCount() const { return pimpl_->form_data_args_.size(); }
+size_t HttpRequest::FormDataArgCount() const { return pimpl_->form_data_args.size(); }
 
 std::vector<std::string> HttpRequest::FormDataArgNames() const {
     std::vector<std::string> res;
-    res.reserve(pimpl_->form_data_args_.size());
-    for (const auto& [name, _] : pimpl_->form_data_args_) res.push_back(name);
+    res.reserve(pimpl_->form_data_args.size());
+    for (const auto& [name, _] : pimpl_->form_data_args) res.push_back(name);
     return res;
 }
 
 const std::string& HttpRequest::GetPathArg(std::string_view arg_name) const {
-    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->path_args_by_name_index_, arg_name);
+    const auto* ptr = utils::impl::FindTransparentOrNullptr(pimpl_->path_args_by_name_index, arg_name);
     if (!ptr) return kEmptyString;
-    UASSERT(*ptr < pimpl_->path_args_.size());
-    return pimpl_->path_args_[*ptr];
+    UASSERT(*ptr < pimpl_->path_args.size());
+    return pimpl_->path_args[*ptr];
 }
 
 const std::string& HttpRequest::GetPathArg(size_t index) const {
-    return index < PathArgCount() ? pimpl_->path_args_[index] : kEmptyString;
+    return index < PathArgCount() ? pimpl_->path_args[index] : kEmptyString;
 }
 
 bool HttpRequest::HasPathArg(std::string_view arg_name) const {
-    return !!utils::impl::FindTransparentOrNullptr(pimpl_->path_args_by_name_index_, arg_name);
+    return !!utils::impl::FindTransparentOrNullptr(pimpl_->path_args_by_name_index, arg_name);
 }
 
 bool HttpRequest::HasPathArg(size_t index) const { return index < PathArgCount(); }
 
-size_t HttpRequest::PathArgCount() const { return pimpl_->path_args_.size(); }
+size_t HttpRequest::PathArgCount() const { return pimpl_->path_args.size(); }
 
 const std::string& HttpRequest::GetHeader(std::string_view header_name) const {
-    auto it = pimpl_->headers_.find(header_name);
-    if (it == pimpl_->headers_.end()) return kEmptyString;
+    auto it = pimpl_->headers.find(header_name);
+    if (it == pimpl_->headers.end()) return kEmptyString;
     return it->second;
 }
 
 const std::string& HttpRequest::GetHeader(const USERVER_NAMESPACE::http::headers::PredefinedHeader& header_name) const {
-    auto it = pimpl_->headers_.find(header_name);
-    if (it == pimpl_->headers_.end()) return kEmptyString;
+    auto it = pimpl_->headers.find(header_name);
+    if (it == pimpl_->headers.end()) return kEmptyString;
     return it->second;
 }
 
-bool HttpRequest::HasHeader(std::string_view header_name) const { return pimpl_->headers_.count(header_name) != 0; }
+bool HttpRequest::HasHeader(std::string_view header_name) const { return pimpl_->headers.count(header_name) != 0; }
 
 bool HttpRequest::HasHeader(const USERVER_NAMESPACE::http::headers::PredefinedHeader& header_name) const {
-    return pimpl_->headers_.count(header_name) != 0;
+    return pimpl_->headers.count(header_name) != 0;
 }
 
-size_t HttpRequest::HeaderCount() const { return pimpl_->headers_.size(); }
+size_t HttpRequest::HeaderCount() const { return pimpl_->headers.size(); }
 
-void HttpRequest::RemoveHeader(std::string_view header_name) { pimpl_->headers_.erase(header_name); }
+void HttpRequest::RemoveHeader(std::string_view header_name) { pimpl_->headers.erase(header_name); }
 
 void HttpRequest::RemoveHeader(const USERVER_NAMESPACE::http::headers::PredefinedHeader& header_name) {
-    pimpl_->headers_.erase(header_name);
+    pimpl_->headers.erase(header_name);
 }
 
-HttpRequest::HeadersMapKeys HttpRequest::GetHeaderNames() const {
-    return HttpRequest::HeadersMapKeys{pimpl_->headers_};
-}
+HttpRequest::HeadersMapKeys HttpRequest::GetHeaderNames() const { return HttpRequest::HeadersMapKeys{pimpl_->headers}; }
 
-const HttpRequest::HeadersMap& HttpRequest::GetHeaders() const { return pimpl_->headers_; }
+const HttpRequest::HeadersMap& HttpRequest::GetHeaders() const { return pimpl_->headers; }
 
 const std::string& HttpRequest::GetCookie(const std::string& cookie_name) const {
-    auto it = pimpl_->cookies_.find(cookie_name);
-    if (it == pimpl_->cookies_.end()) return kEmptyString;
+    auto it = pimpl_->cookies.find(cookie_name);
+    if (it == pimpl_->cookies.end()) return kEmptyString;
     return it->second;
 }
 
-bool HttpRequest::HasCookie(const std::string& cookie_name) const { return pimpl_->cookies_.count(cookie_name); }
+bool HttpRequest::HasCookie(const std::string& cookie_name) const { return pimpl_->cookies.count(cookie_name); }
 
-size_t HttpRequest::CookieCount() const { return pimpl_->cookies_.size(); }
+size_t HttpRequest::CookieCount() const { return pimpl_->cookies.size(); }
 
-HttpRequest::CookiesMapKeys HttpRequest::GetCookieNames() const {
-    return HttpRequest::CookiesMapKeys{pimpl_->cookies_};
-}
+HttpRequest::CookiesMapKeys HttpRequest::GetCookieNames() const { return HttpRequest::CookiesMapKeys{pimpl_->cookies}; }
 
-const HttpRequest::CookiesMap& HttpRequest::RequestCookies() const { return pimpl_->cookies_; }
+const HttpRequest::CookiesMap& HttpRequest::RequestCookies() const { return pimpl_->cookies; }
 
-const std::string& HttpRequest::RequestBody() const { return pimpl_->request_body_; }
+const std::string& HttpRequest::RequestBody() const { return pimpl_->request_body; }
 
-std::string HttpRequest::ExtractRequestBody() { return std::move(pimpl_->request_body_); }
+std::string HttpRequest::ExtractRequestBody() { return std::move(pimpl_->request_body); }
 
-void HttpRequest::SetRequestBody(std::string body) { pimpl_->request_body_ = std::move(body); }
+void HttpRequest::SetRequestBody(std::string body) { pimpl_->request_body = std::move(body); }
 
 void HttpRequest::ParseArgsFromBody() {
 #ifndef NDEBUG
     UASSERT_MSG(
-        !pimpl_->args_referenced_,
+        !pimpl_->args_referenced,
         "References to arguments could be invalidated by ParseArgsFromBody(). "
         "Avoid calling GetArg()/GetArgVector() before ParseArgsFromBody()"
     );
 #endif
 
     USERVER_NAMESPACE::http::parser::ParseAndConsumeArgs(
-        pimpl_->request_body_,
+        pimpl_->request_body,
         [this](std::string&& key, std::string&& value) {
-            pimpl_->request_args_[std::move(key)].push_back(std::move(value));
+            pimpl_->request_args[std::move(key)].push_back(std::move(value));
         }
     );
 }
 
-bool HttpRequest::IsFinal() const { return pimpl_->is_final_; }
+bool HttpRequest::IsFinal() const { return pimpl_->is_final; }
 
-void HttpRequest::SetResponseStatus(HttpStatus status) const { pimpl_->response_.SetStatus(status); }
+void HttpRequest::SetResponseStatus(HttpStatus status) const { pimpl_->response.SetStatus(status); }
 
 bool HttpRequest::IsBodyCompressed() const {
     const auto& encoding = GetHeader(USERVER_NAMESPACE::http::headers::kContentEncoding);
     return !encoding.empty() && encoding != "identity";
 }
 
-HttpResponse& HttpRequest::GetHttpResponse() const { return pimpl_->response_; }
+HttpResponse& HttpRequest::GetHttpResponse() const { return pimpl_->response; }
 
-std::chrono::steady_clock::time_point HttpRequest::GetStartTime() const { return pimpl_->start_time_; }
+std::chrono::steady_clock::time_point HttpRequest::GetStartTime() const { return pimpl_->start_time; }
 
-bool HttpRequest::IsUpgradeWebsocket() const { return static_cast<bool>(pimpl_->upgrade_websocket_cb_); }
+bool HttpRequest::IsUpgradeWebsocket() const { return static_cast<bool>(pimpl_->upgrade_websocket_cb); }
 
-void HttpRequest::SetUpgradeWebsocket(UpgradeCallback cb) const { pimpl_->upgrade_websocket_cb_ = std::move(cb); }
+void HttpRequest::SetUpgradeWebsocket(UpgradeCallback cb) const { pimpl_->upgrade_websocket_cb = std::move(cb); }
 
 void HttpRequest::DoUpgrade(std::unique_ptr<engine::io::RwBase>&& socket, engine::io::Sockaddr&& peer_name) const {
-    pimpl_->upgrade_websocket_cb_(std::move(socket), std::move(peer_name));
+    pimpl_->upgrade_websocket_cb(std::move(socket), std::move(peer_name));
 }
 
 void HttpRequest::SetPathArgs(std::vector<std::pair<std::string, std::string>> args) {
-    pimpl_->path_args_.clear();
-    pimpl_->path_args_.reserve(args.size());
+    pimpl_->path_args.clear();
+    pimpl_->path_args.reserve(args.size());
 
-    pimpl_->path_args_by_name_index_.clear();
+    pimpl_->path_args_by_name_index.clear();
     for (auto& [name, value] : args) {
-        pimpl_->path_args_.push_back(std::move(value));
+        pimpl_->path_args.push_back(std::move(value));
         if (!name.empty()) {
-            pimpl_->path_args_by_name_index_[std::move(name)] = pimpl_->path_args_.size() - 1;
+            pimpl_->path_args_by_name_index[std::move(name)] = pimpl_->path_args.size() - 1;
         }
     }
 }
 
 void HttpRequest::AccountResponseTime() {
-    if (pimpl_->request_statistics_) {
+    if (pimpl_->request_statistics) {
         auto timing = std::chrono::duration_cast<std::chrono::milliseconds>(
-            pimpl_->finish_send_response_time_ - pimpl_->start_time_
+            pimpl_->finish_send_response_time - pimpl_->start_time
         );
-        pimpl_->request_statistics_->ForMethod(GetMethod()).Account(handlers::HttpRequestStatisticsEntry{timing});
+        pimpl_->request_statistics->ForMethod(GetMethod()).Account(handlers::HttpRequestStatisticsEntry{timing});
     }
 }
 
 void HttpRequest::MarkAsInternalServerError() const {
     // TODO : refactor, this being here is a bit ridiculous
-    pimpl_->response_.SetStatus(http::HttpStatus::kInternalServerError);
-    pimpl_->response_.SetData({});
+    pimpl_->response.SetStatus(http::HttpStatus::kInternalServerError);
+    pimpl_->response.SetData({});
 
-    std::string server_header = pimpl_->response_.GetHeader(USERVER_NAMESPACE::http::headers::kServer);
-    pimpl_->response_.ClearHeaders();
+    std::string server_header = pimpl_->response.GetHeader(USERVER_NAMESPACE::http::headers::kServer);
+    pimpl_->response.ClearHeaders();
     if (!server_header.empty()) {
-        pimpl_->response_.SetHeader(USERVER_NAMESPACE::http::headers::kServer, std::move(server_header));
+        pimpl_->response.SetHeader(USERVER_NAMESPACE::http::headers::kServer, std::move(server_header));
     }
 }
 
-void HttpRequest::SetHttpHandler(const handlers::HttpHandlerBase& handler) { pimpl_->handler_ = &handler; }
+void HttpRequest::SetHttpHandler(const handlers::HttpHandlerBase& handler) { pimpl_->handler = &handler; }
 
-const handlers::HttpHandlerBase* HttpRequest::GetHttpHandler() const { return pimpl_->handler_; }
+const handlers::HttpHandlerBase* HttpRequest::GetHttpHandler() const { return pimpl_->handler; }
 
-void HttpRequest::SetTaskProcessor(engine::TaskProcessor& task_processor) { pimpl_->task_processor_ = &task_processor; }
+void HttpRequest::SetTaskProcessor(engine::TaskProcessor& task_processor) { pimpl_->task_processor = &task_processor; }
 
-engine::TaskProcessor* HttpRequest::GetTaskProcessor() const { return pimpl_->task_processor_; }
+engine::TaskProcessor* HttpRequest::GetTaskProcessor() const { return pimpl_->task_processor; }
 
 void HttpRequest::SetHttpHandlerStatistics(handlers::HttpRequestStatistics& stats) {
-    pimpl_->request_statistics_ = &stats;
+    pimpl_->request_statistics = &stats;
 }
 
-void HttpRequest::SetResponseStreamId(std::int32_t stream_id) { pimpl_->response_.SetStreamId(stream_id); }
+void HttpRequest::SetResponseStreamId(std::int32_t stream_id) { pimpl_->response.SetStreamId(stream_id); }
 
 void HttpRequest::SetStreamProducer(impl::Http2StreamEventProducer&& producer) {
-    pimpl_->response_.SetStreamProdicer(std::move(producer));
+    pimpl_->response.SetStreamProdicer(std::move(producer));
 }
 
-void HttpRequest::SetTaskCreateTime() { pimpl_->task_create_time_ = std::chrono::steady_clock::now(); }
+void HttpRequest::SetTaskCreateTime() { pimpl_->task_create_time = std::chrono::steady_clock::now(); }
 
-void HttpRequest::SetTaskStartTime() { pimpl_->task_start_time_ = std::chrono::steady_clock::now(); }
+void HttpRequest::SetTaskStartTime() { pimpl_->task_start_time = std::chrono::steady_clock::now(); }
 
 void HttpRequest::SetResponseNotifyTime() { SetResponseNotifyTime(std::chrono::steady_clock::now()); }
 
 void HttpRequest::SetResponseNotifyTime(std::chrono::steady_clock::time_point now) {
-    pimpl_->response_notify_time_ = now;
+    pimpl_->response_notify_time = now;
 }
 
-void HttpRequest::SetStartSendResponseTime() { pimpl_->start_send_response_time_ = std::chrono::steady_clock::now(); }
+void HttpRequest::SetStartSendResponseTime() { pimpl_->start_send_response_time = std::chrono::steady_clock::now(); }
 
 void HttpRequest::SetFinishSendResponseTime() {
-    pimpl_->finish_send_response_time_ = std::chrono::steady_clock::now();
+    pimpl_->finish_send_response_time = std::chrono::steady_clock::now();
     AccountResponseTime();
 }
 
@@ -367,7 +363,7 @@ void HttpRequest::WriteAccessLog(
             EscapeForAccessLog(GetUrl()),
             GetHttpMajor(),
             GetHttpMinor(),
-            static_cast<int>(pimpl_->response_.GetStatus()),
+            static_cast<int>(pimpl_->response.GetStatus()),
             EscapeForAccessLog(GetHeader("Referer")),
             EscapeForAccessLog(GetHeader("User-Agent")),
             EscapeForAccessLog(GetHeader("Cookie")),
@@ -407,7 +403,7 @@ void HttpRequest::WriteAccessTskvLog(
         "\tupstream_response_time={:0.3f}"
         "\trequest_body={}",
         utils::datetime::LocalTimezoneTimestring(tp, "timestamp=%Y-%m-%dT%H:%M:%S\ttimezone=%Ez"),
-        static_cast<int>(pimpl_->response_.GetStatus()),
+        static_cast<int>(pimpl_->response.GetStatus()),
         GetHttpMajor(),
         GetHttpMinor(),
         EscapeForAccessTskvLog(GetMethodStr()),
diff --git a/core/src/server/http/http_request_builder.cpp b/core/src/server/http/http_request_builder.cpp
index 347e63d8b8d9..9958888092e2 100644
--- a/core/src/server/http/http_request_builder.cpp
+++ b/core/src/server/http/http_request_builder.cpp
@@ -25,22 +25,22 @@ HttpRequestBuilder::HttpRequestBuilder(request::ResponseDataAccounter& data_acco
 HttpRequestBuilder::HttpRequestBuilder() : HttpRequestBuilder(default_data_accounter) {}
 
 HttpRequestBuilder& HttpRequestBuilder::SetRemoteAddress(engine::io::Sockaddr remote_address) {
-    request_->pimpl_->remote_address_ = std::move(remote_address);
+    request_->pimpl_->remote_address = std::move(remote_address);
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetMethod(HttpMethod method) {
-    request_->pimpl_->method_ = method;
+    request_->pimpl_->method = method;
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetHttpMajor(int http_major) {
-    request_->pimpl_->http_major_ = http_major;
+    request_->pimpl_->http_major = http_major;
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetHttpMinor(int http_minor) {
-    request_->pimpl_->http_minor_ = http_minor;
+    request_->pimpl_->http_minor = http_minor;
     return *this;
 }
 
@@ -50,12 +50,12 @@ HttpRequestBuilder& HttpRequestBuilder::SetBody(std::string&& body) {
 }
 
 HttpRequestBuilder& HttpRequestBuilder::AddHeader(std::string&& header, std::string&& value) {
-    request_->pimpl_->headers_.InsertOrAppend(std::move(header), std::move(value));
+    request_->pimpl_->headers.InsertOrAppend(std::move(header), std::move(value));
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::AddRequestArg(std::string&& key, std::string&& value) {
-    request_->pimpl_->request_args_[std::move(key)].push_back(std::move(value));
+    request_->pimpl_->request_args[std::move(key)].push_back(std::move(value));
     return *this;
 }
 
@@ -65,24 +65,24 @@ HttpRequestBuilder& HttpRequestBuilder::SetPathArgs(std::vector<std::pair<std::s
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetUrl(std::string&& url) {
-    request_->pimpl_->url_ = std::move(url);
+    request_->pimpl_->url = std::move(url);
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetRequestPath(std::string&& path) {
-    request_->pimpl_->request_path_ = std::move(path);
+    request_->pimpl_->request_path = std::move(path);
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetIsFinal(bool is_final) {
-    request_->pimpl_->is_final_ = is_final;
+    request_->pimpl_->is_final = is_final;
     return *this;
 }
 
 HttpRequestBuilder& HttpRequestBuilder::SetFormDataArgs(
     utils::impl::TransparentMap<std::string, std::vector<FormDataArg>, utils::StrCaseHash>&& form_data_args
 ) {
-    request_->pimpl_->form_data_args_ = std::move(form_data_args);
+    request_->pimpl_->form_data_args = std::move(form_data_args);
     return *this;
 }
 
@@ -127,15 +127,15 @@ std::shared_ptr<HttpRequest> HttpRequestBuilder::Build() {
     ParseCookies();
 
     UASSERT(std::all_of(
-        request_->pimpl_->request_args_.begin(),
-        request_->pimpl_->request_args_.end(),
+        request_->pimpl_->request_args.begin(),
+        request_->pimpl_->request_args.end(),
         [](const auto& arg) { return !arg.second.empty(); }
     ));
 
     LOG_TRACE() << "method=" << request_->GetMethodStr();
-    LOG_TRACE() << "request_args:" << request_->pimpl_->request_args_;
-    LOG_TRACE() << "headers:" << request_->pimpl_->headers_;
-    LOG_TRACE() << "cookies:" << request_->pimpl_->cookies_;
+    LOG_TRACE() << "request_args:" << request_->pimpl_->request_args;
+    LOG_TRACE() << "headers:" << request_->pimpl_->headers;
+    LOG_TRACE() << "cookies:" << request_->pimpl_->cookies;
 
     return request_;
 }
@@ -166,7 +166,7 @@ void HttpRequestBuilder::ParseCookies() {
             }
             Strip(key_begin, key_end);
             if (key_begin < key_end) {
-                request_->pimpl_->cookies_.emplace(
+                request_->pimpl_->cookies.emplace(
                     std::piecewise_construct, std::tie(key_begin, key_end), std::tie(value_begin, value_end)
                 );
             }
diff --git a/core/src/server/http/http_request_constructor.cpp b/core/src/server/http/http_request_constructor.cpp
index 4b60dde91838..60a2fbebe2fd 100644
--- a/core/src/server/http/http_request_constructor.cpp
+++ b/core/src/server/http/http_request_constructor.cpp
@@ -213,6 +213,11 @@ void HttpRequestConstructor::FinalizeImpl() {
             builder_.SetFormDataArgs(std::move(form_data_args));
         }
     }
+
+    const auto& host = request.GetHeader(USERVER_NAMESPACE::http::headers::kHost);
+    if (host.empty()) {
+        LOG_LIMITED_WARNING() << "\"Host\" header in request is empty or absent";
+    }
 }
 
 void HttpRequestConstructor::ParseArgs(const HttpParserUrl& url) {
diff --git a/core/src/server/http/http_request_constructor_benchmark.cpp b/core/src/server/http/http_request_constructor_benchmark.cpp
index 75cc159025af..a7237ee51f51 100644
--- a/core/src/server/http/http_request_constructor_benchmark.cpp
+++ b/core/src/server/http/http_request_constructor_benchmark.cpp
@@ -7,7 +7,7 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
-void http_request_constructor_url_decode(benchmark::State& state) {
+void HttpRequestConstructorUrlDecode(benchmark::State& state) {
     const std::string tmp = "1";
     std::string input;
 
@@ -16,6 +16,6 @@ void http_request_constructor_url_decode(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) benchmark::DoNotOptimize(USERVER_NAMESPACE::http::parser::UrlDecode(input));
 }
 }  // namespace
-BENCHMARK(http_request_constructor_url_decode)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(HttpRequestConstructorUrlDecode)->RangeMultiplier(2)->Range(1, 1024);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/http/http_request_headers_benchmark.cpp b/core/src/server/http/http_request_headers_benchmark.cpp
index b1124541aaa9..c7fade2b3cde 100644
--- a/core/src/server/http/http_request_headers_benchmark.cpp
+++ b/core/src/server/http/http_request_headers_benchmark.cpp
@@ -25,7 +25,7 @@ constexpr PredefinedHeader kHeadersArray[kHeadersCount] = {
     PredefinedHeader{"TestHeader30"}, PredefinedHeader{"TestHeader31"},
 };
 
-void http_request_headers_insert(benchmark::State& state) {
+void HttpRequestHeadersInsert(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         server::http::HttpRequest::HeadersMap map;
 
@@ -35,7 +35,7 @@ void http_request_headers_insert(benchmark::State& state) {
     }
 }
 
-void http_request_headers_get(benchmark::State& state) {
+void HttpRequestHeadersGet(benchmark::State& state) {
     server::http::HttpRequest::HeadersMap map;
     for (const auto& header : kHeadersArray) map[header] = "1";
 
@@ -47,8 +47,8 @@ void http_request_headers_get(benchmark::State& state) {
 }
 
 }  // namespace
-BENCHMARK(http_request_headers_insert)->RangeMultiplier(2)->Range(1, kHeadersCount);
+BENCHMARK(HttpRequestHeadersInsert)->RangeMultiplier(2)->Range(1, kHeadersCount);
 
-BENCHMARK(http_request_headers_get);
+BENCHMARK(HttpRequestHeadersGet);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/http/http_request_impl.hpp b/core/src/server/http/http_request_impl.hpp
index 80479d242d8a..7dfbd61cb649 100644
--- a/core/src/server/http/http_request_impl.hpp
+++ b/core/src/server/http/http_request_impl.hpp
@@ -19,44 +19,44 @@ struct HttpRequest::Impl {
     // unordered_maps because we don't need different seeds and want to avoid its
     // overhead.
     Impl(HttpRequest& http_request, request::ResponseDataAccounter& data_accounter)
-        : start_time_(std::chrono::steady_clock::now()),
-          form_data_args_(impl::kZeroAllocationBucketCount, request_args_.hash_function()),
-          path_args_by_name_index_(impl::kZeroAllocationBucketCount, request_args_.hash_function()),
-          headers_(impl::kBucketCount),
-          cookies_(impl::kZeroAllocationBucketCount, request_args_.hash_function()),
-          response_(http_request, data_accounter, start_time_, cookies_.hash_function()) {}
+        : start_time(std::chrono::steady_clock::now()),
+          form_data_args(impl::kZeroAllocationBucketCount, request_args.hash_function()),
+          path_args_by_name_index(impl::kZeroAllocationBucketCount, request_args.hash_function()),
+          headers(impl::kBucketCount),
+          cookies(impl::kZeroAllocationBucketCount, request_args.hash_function()),
+          response(http_request, data_accounter, start_time, cookies.hash_function()) {}
 
-    std::chrono::steady_clock::time_point start_time_;
-    std::chrono::steady_clock::time_point task_create_time_;
-    std::chrono::steady_clock::time_point task_start_time_;
-    std::chrono::steady_clock::time_point response_notify_time_;
-    std::chrono::steady_clock::time_point start_send_response_time_;
-    std::chrono::steady_clock::time_point finish_send_response_time_;
+    std::chrono::steady_clock::time_point start_time;
+    std::chrono::steady_clock::time_point task_create_time;
+    std::chrono::steady_clock::time_point task_start_time;
+    std::chrono::steady_clock::time_point response_notify_time;
+    std::chrono::steady_clock::time_point start_send_response_time;
+    std::chrono::steady_clock::time_point finish_send_response_time;
 
-    HttpMethod method_{HttpMethod::kUnknown};
-    int http_major_{1};
-    int http_minor_{1};
-    std::string url_;
-    std::string request_path_;
-    std::string request_body_;
-    utils::impl::TransparentMap<std::string, std::vector<std::string>, utils::StrCaseHash> request_args_;
-    utils::impl::TransparentMap<std::string, std::vector<FormDataArg>, utils::StrCaseHash> form_data_args_;
-    std::vector<std::string> path_args_;
-    utils::impl::TransparentMap<std::string, size_t, utils::StrCaseHash> path_args_by_name_index_;
-    HeadersMap headers_;
-    CookiesMap cookies_;
-    bool is_final_{false};
+    HttpMethod method{HttpMethod::kUnknown};
+    int http_major{1};
+    int http_minor{1};
+    std::string url;
+    std::string request_path;
+    std::string request_body;
+    utils::impl::TransparentMap<std::string, std::vector<std::string>, utils::StrCaseHash> request_args;
+    utils::impl::TransparentMap<std::string, std::vector<FormDataArg>, utils::StrCaseHash> form_data_args;
+    std::vector<std::string> path_args;
+    utils::impl::TransparentMap<std::string, size_t, utils::StrCaseHash> path_args_by_name_index;
+    HeadersMap headers;
+    CookiesMap cookies;
+    bool is_final{false};
 #ifndef NDEBUG
-    mutable bool args_referenced_{false};
+    mutable bool args_referenced{false};
 #endif
     // TODO
-    mutable UpgradeCallback upgrade_websocket_cb_;
+    mutable UpgradeCallback upgrade_websocket_cb;
 
-    mutable HttpResponse response_;
-    engine::io::Sockaddr remote_address_;
-    engine::TaskProcessor* task_processor_{nullptr};
-    const handlers::HttpHandlerBase* handler_{nullptr};
-    handlers::HttpRequestStatistics* request_statistics_{nullptr};
+    mutable HttpResponse response;
+    engine::io::Sockaddr remote_address;
+    engine::TaskProcessor* task_processor{nullptr};
+    const handlers::HttpHandlerBase* handler{nullptr};
+    handlers::HttpRequestStatistics* request_statistics{nullptr};
 };
 
 }  // namespace server::http
diff --git a/core/src/server/http/http_request_parser_benchmark.cpp b/core/src/server/http/http_request_parser_benchmark.cpp
index 8310e6efa873..b4f7a9948f3d 100644
--- a/core/src/server/http/http_request_parser_benchmark.cpp
+++ b/core/src/server/http/http_request_parser_benchmark.cpp
@@ -43,7 +43,7 @@ inline server::http::HttpRequestParser CreateBenchmarkParser(server::http::HttpR
 
 }  // namespace
 
-void http_request_parser_parse_benchmark_small(benchmark::State& state) {
+void HttpRequestParserParseBenchmarkSmall(benchmark::State& state) {
     auto parser = CreateBenchmarkParser([](std::shared_ptr<server::http::HttpRequest>&&) {});
 
     for ([[maybe_unused]] auto _ : state) {
@@ -51,7 +51,7 @@ void http_request_parser_parse_benchmark_small(benchmark::State& state) {
     }
 }
 
-void http_request_parser_parse_benchmark_middle(benchmark::State& state) {
+void HttpRequestParserParseBenchmarkMiddle(benchmark::State& state) {
     auto parser = CreateBenchmarkParser([](std::shared_ptr<server::http::HttpRequest>&&) {});
 
     for ([[maybe_unused]] auto _ : state) {
@@ -59,7 +59,7 @@ void http_request_parser_parse_benchmark_middle(benchmark::State& state) {
     }
 }
 
-void http_request_parser_parse_benchmark_large_url(benchmark::State& state) {
+void HttpRequestParserParseBenchmarkLargeUrl(benchmark::State& state) {
     auto parser = CreateBenchmarkParser([](std::shared_ptr<server::http::HttpRequest>&&) {});
 
     std::string large_url;
@@ -73,7 +73,7 @@ void http_request_parser_parse_benchmark_large_url(benchmark::State& state) {
     }
 }
 
-void http_request_parser_parse_benchmark_large_body(benchmark::State& state) {
+void HttpRequestParserParseBenchmarkLargeBody(benchmark::State& state) {
     auto parser = CreateBenchmarkParser([](std::shared_ptr<server::http::HttpRequest>&&) {});
 
     std::string large_body;
@@ -92,7 +92,7 @@ void http_request_parser_parse_benchmark_large_body(benchmark::State& state) {
     }
 }
 
-void http_request_parser_parse_benchmark_many_headers(benchmark::State& state) {
+void HttpRequestParserParseBenchmarkManyHeaders(benchmark::State& state) {
     auto parser = CreateBenchmarkParser([](std::shared_ptr<server::http::HttpRequest>&&) {});
 
     std::string headers;
@@ -110,10 +110,10 @@ void http_request_parser_parse_benchmark_many_headers(benchmark::State& state) {
     }
 }
 
-BENCHMARK(http_request_parser_parse_benchmark_small);
-BENCHMARK(http_request_parser_parse_benchmark_middle);
-BENCHMARK(http_request_parser_parse_benchmark_large_url);
-BENCHMARK(http_request_parser_parse_benchmark_large_body);
-BENCHMARK(http_request_parser_parse_benchmark_many_headers);
+BENCHMARK(HttpRequestParserParseBenchmarkSmall);
+BENCHMARK(HttpRequestParserParseBenchmarkMiddle);
+BENCHMARK(HttpRequestParserParseBenchmarkLargeUrl);
+BENCHMARK(HttpRequestParserParseBenchmarkLargeBody);
+BENCHMARK(HttpRequestParserParseBenchmarkManyHeaders);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/http/http_request_parser_test.cpp b/core/src/server/http/http_request_parser_test.cpp
index 88146947b24d..63612e9bc4c3 100644
--- a/core/src/server/http/http_request_parser_test.cpp
+++ b/core/src/server/http/http_request_parser_test.cpp
@@ -11,6 +11,9 @@ constexpr std::string_view kHttpRequestSmall = "GET / HTTP/1.1\r\n\r\n";
 
 constexpr std::string_view kHttpRequestOriginUrl = "GET /foo/bar?query1=value1&query2=value2 HTTP/1.1\r\n\r\n";
 
+constexpr std::string_view kFullHttpRequestOriginUrl =
+    "GET http://www.example.org/foo/bar?query1=value1&query2=value2 HTTP/1.1\r\n\r\n";
+
 constexpr std::string_view kHttpRequestAbsoluteUrl =
     "GET http://www.example.org/pub/WWW/TheProject.html HTTP/1.1\r\n\r\n";
 
@@ -41,16 +44,13 @@ UTEST(HttpRequestParserParser, Small) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.GetUrl(), "/");
+        EXPECT_EQ(request->GetUrl(), "/");
 
-        EXPECT_EQ(http_request_impl.GetHttpMajor(), 1);
-        EXPECT_EQ(http_request_impl.GetHttpMinor(), 1);
+        EXPECT_EQ(request->GetHttpMajor(), 1);
+        EXPECT_EQ(request->GetHttpMinor(), 1);
     });
 
     parser->Parse(kHttpRequestSmall);
@@ -61,35 +61,47 @@ UTEST(HttpRequestParserParser, OriginUrl) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.GetUrl(), "/foo/bar?query1=value1&query2=value2");
-        EXPECT_EQ(http_request_impl.GetRequestPath(), "/foo/bar");
-        EXPECT_EQ(http_request_impl.ArgCount(), 2);
-        EXPECT_EQ(http_request_impl.GetArg("query1"), "value1");
-        EXPECT_EQ(http_request_impl.GetArg("query2"), "value2");
+        EXPECT_EQ(request->GetUrl(), "/foo/bar?query1=value1&query2=value2");
+        EXPECT_EQ(request->GetRequestPath(), "/foo/bar");
+        EXPECT_EQ(request->ArgCount(), 2);
+        EXPECT_EQ(request->GetArg("query1"), "value1");
+        EXPECT_EQ(request->GetArg("query2"), "value2");
     });
 
     parser->Parse(kHttpRequestOriginUrl);
     EXPECT_EQ(parsed, true);
 }
 
+UTEST(HttpRequestParserParser, GetRequestPath) {
+    bool parsed = false;
+    auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
+        parsed = true;
+
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
+
+        EXPECT_EQ(request->GetUrl(), "http://www.example.org/foo/bar?query1=value1&query2=value2");
+        EXPECT_EQ(request->GetRequestPath(), "/foo/bar");
+        EXPECT_EQ(request->ArgCount(), 2);
+        EXPECT_EQ(request->GetArg("query1"), "value1");
+        EXPECT_EQ(request->GetArg("query2"), "value2");
+    });
+
+    parser->Parse(kFullHttpRequestOriginUrl);
+    EXPECT_EQ(parsed, true);
+}
+
 UTEST(HttpRequestParserParser, AbsoluteUrl) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.GetUrl(), "http://www.example.org/pub/WWW/TheProject.html");
-        EXPECT_EQ(http_request_impl.GetRequestPath(), "/pub/WWW/TheProject.html");
+        EXPECT_EQ(request->GetUrl(), "http://www.example.org/pub/WWW/TheProject.html");
+        EXPECT_EQ(request->GetRequestPath(), "/pub/WWW/TheProject.html");
     });
 
     parser->Parse(kHttpRequestAbsoluteUrl);
@@ -100,18 +112,15 @@ UTEST(HttpRequestParserParser, HeadersSimple) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.HeaderCount(), 2);
-        EXPECT_EQ(http_request_impl.HasHeader("host"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("host"), "localhost:11235");
+        EXPECT_EQ(request->HeaderCount(), 2);
+        EXPECT_EQ(request->HasHeader("host"), true);
+        EXPECT_EQ(request->GetHeader("host"), "localhost:11235");
 
-        EXPECT_EQ(http_request_impl.HasHeader("user-agent"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("user-agent"), "curl/7.58.0");
+        EXPECT_EQ(request->HasHeader("user-agent"), true);
+        EXPECT_EQ(request->GetHeader("user-agent"), "curl/7.58.0");
     });
 
     parser->Parse(kHttpRequestHeadersSimple);
@@ -122,18 +131,15 @@ UTEST(HttpRequestParserParser, HeadersNoSpaces) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.HeaderCount(), 2);
-        EXPECT_EQ(http_request_impl.HasHeader("host"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("host"), "localhost:11235");
+        EXPECT_EQ(request->HeaderCount(), 2);
+        EXPECT_EQ(request->HasHeader("host"), true);
+        EXPECT_EQ(request->GetHeader("host"), "localhost:11235");
 
-        EXPECT_EQ(http_request_impl.HasHeader("user-agent"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("user-agent"), "curl/7.58.0");
+        EXPECT_EQ(request->HasHeader("user-agent"), true);
+        EXPECT_EQ(request->GetHeader("user-agent"), "curl/7.58.0");
     });
 
     parser->Parse(kHttpRequestHeadersNoSpaces);
@@ -144,18 +150,15 @@ UTEST(HttpRequestParserParser, HeadersCaseInsensitive) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.HeaderCount(), 2);
-        EXPECT_EQ(http_request_impl.HasHeader("host"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("host"), "localhost:11235");
+        EXPECT_EQ(request->HeaderCount(), 2);
+        EXPECT_EQ(request->HasHeader("host"), true);
+        EXPECT_EQ(request->GetHeader("host"), "localhost:11235");
 
-        EXPECT_EQ(http_request_impl.HasHeader("user-agent"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("user-agent"), "curl/7.58.0");
+        EXPECT_EQ(request->HasHeader("user-agent"), true);
+        EXPECT_EQ(request->GetHeader("user-agent"), "curl/7.58.0");
     });
 
     parser->Parse(kHttpRequestHeadersCaseInsensitive);
@@ -166,18 +169,15 @@ UTEST(HttpRequestParserParser, HeaderValues) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.HeaderCount(), 2);
-        EXPECT_EQ(http_request_impl.HasHeader("host"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("host"), "*\"@!%");
+        EXPECT_EQ(request->HeaderCount(), 2);
+        EXPECT_EQ(request->HasHeader("host"), true);
+        EXPECT_EQ(request->GetHeader("host"), "*\"@!%");
 
-        EXPECT_EQ(http_request_impl.HasHeader("user-agent"), true);
-        EXPECT_EQ(http_request_impl.GetHeader("user-agent"), "[-]{~},/");
+        EXPECT_EQ(request->HasHeader("user-agent"), true);
+        EXPECT_EQ(request->GetHeader("user-agent"), "[-]{~},/");
     });
 
     parser->Parse(kHttpRequestHeaderValues);
@@ -188,13 +188,10 @@ UTEST(HttpRequestParserParser, BodySimple) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kGet);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kGet);
 
-        EXPECT_EQ(http_request_impl.RequestBody(), "body");
+        EXPECT_EQ(request->RequestBody(), "body");
     });
 
     parser->Parse(kHttpRequestBodySimple);
@@ -222,11 +219,8 @@ UTEST(HttpRequestParserParser, MethodWrongCase) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kUnknown);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kUnknown);
     });
 
     parser->Parse(kHttpRequestMethodWrongCase);
@@ -237,11 +231,8 @@ UTEST(HttpRequestParserParser, NoURL) {
     bool parsed = false;
     auto parser = server::CreateTestParser([&parsed](std::shared_ptr<server::http::HttpRequest>&& request) {
         parsed = true;
-        auto& http_request_impl =
-            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
-            static_cast<server::http::HttpRequest&>(*request);
 
-        EXPECT_EQ(http_request_impl.GetMethod(), server::http::HttpMethod::kUnknown);
+        EXPECT_EQ(request->GetMethod(), server::http::HttpMethod::kUnknown);
     });
 
     parser->Parse(kHttpRequestNoURL);
diff --git a/core/src/server/http/http_response_benchmark.cpp b/core/src/server/http/http_response_benchmark.cpp
index f483cefb116d..d8d40aeaaf0c 100644
--- a/core/src/server/http/http_response_benchmark.cpp
+++ b/core/src/server/http/http_response_benchmark.cpp
@@ -42,7 +42,7 @@ void OutputHeader(std::string& header, std::string_view key, std::string_view va
     append(kCrlf);
 }
 
-void http_headers_serialization_inplace(benchmark::State& state) {
+void HttpHeadersSerializationInplace(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         USERVER_NAMESPACE::http::headers::HeadersString os;
 
@@ -71,7 +71,7 @@ void http_headers_serialization_inplace(benchmark::State& state) {
     }
 }
 
-void http_headers_serialization_no_ostreams(benchmark::State& state) {
+void HttpHeadersSerializationNoOstreams(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         std::string os;
         os.reserve(1024);
@@ -93,7 +93,7 @@ void http_headers_serialization_no_ostreams(benchmark::State& state) {
     }
 }
 
-void http_headers_serialization_ostreams(benchmark::State& state) {
+void HttpHeadersSerializationOstreams(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         std::ostringstream os;
 
@@ -137,9 +137,9 @@ void HttpResponseSetHeaderBenchmark(benchmark::State& state) {
 
 }  // namespace
 
-BENCHMARK(http_headers_serialization_inplace);
-BENCHMARK(http_headers_serialization_no_ostreams);
-BENCHMARK(http_headers_serialization_ostreams);
+BENCHMARK(HttpHeadersSerializationInplace);
+BENCHMARK(HttpHeadersSerializationNoOstreams);
+BENCHMARK(HttpHeadersSerializationOstreams);
 BENCHMARK(HttpResponseSetHeaderBenchmark);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/http/http_response_cookie_benchmark.cpp b/core/src/server/http/http_response_cookie_benchmark.cpp
index 03664daffcd0..762b2e3a3db5 100644
--- a/core/src/server/http/http_response_cookie_benchmark.cpp
+++ b/core/src/server/http/http_response_cookie_benchmark.cpp
@@ -6,7 +6,7 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void http_cookie_serialization(benchmark::State& state) {
+void HttpCookieSerialization(benchmark::State& state) {
     auto cookie = server::http::Cookie::FromString(
         "name1=value1; Domain=domain.com; Path=/; Expires=Wed, 12 Jun 2019 "
         "16:51:45 GMT; Max-Age=3600; Secure; SameSite=None; HttpOnly"
@@ -18,6 +18,6 @@ void http_cookie_serialization(benchmark::State& state) {
     }
 }
 
-BENCHMARK(http_cookie_serialization);
+BENCHMARK(HttpCookieSerialization);
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/net/connection.cpp b/core/src/server/net/connection.cpp
index 2904609c9e65..aa0023017b19 100644
--- a/core/src/server/net/connection.cpp
+++ b/core/src/server/net/connection.cpp
@@ -148,6 +148,8 @@ void Connection::ListenForRequests() noexcept {
 }
 
 bool Connection::WaitOnSocket(engine::Deadline deadline) {
+    if (!peer_socket_) return false;
+
     bool is_readable = true;
     if (pending_data_size_ != pending_data_.size()) {
         if (is_http2_parser_) {
@@ -213,7 +215,10 @@ void Connection::ProcessRequest(std::shared_ptr<http::HttpRequest>&& request_ptr
     auto task = HandleQueueItem(request_ptr);
     SendResponse(*request_ptr);
 
-    if (request_ptr->IsUpgradeWebsocket()) request_ptr->DoUpgrade(std::move(peer_socket_), std::move(remote_address_));
+    if (request_ptr->IsUpgradeWebsocket()) {
+        request_ptr->DoUpgrade(std::move(peer_socket_), std::move(remote_address_));
+        is_accepting_requests_ = false;
+    }
 }
 
 bool Connection::ReadSome() {
diff --git a/core/src/server/net/listener_config.cpp b/core/src/server/net/listener_config.cpp
index 752e047c5162..4ad5693f0c9f 100644
--- a/core/src/server/net/listener_config.cpp
+++ b/core/src/server/net/listener_config.cpp
@@ -4,6 +4,7 @@
 #include <stdexcept>
 #include <string>
 
+#include <userver/engine/io.hpp>
 #include <userver/formats/parse/common_containers.hpp>
 #include <userver/fs/blocking/read.hpp>
 
@@ -102,6 +103,12 @@ void PortConfig::ReadTlsSettings(const storages::secdist::SecdistConfig& secdist
     }
 }
 
+void PortConfig::InitSslCtx() {
+    if (tls) {
+        ssl_ctx = crypto::SslCtx::CreateServerTlsContext(tls_cert_chain, tls_private_key, tls_certificate_authorities);
+    }
+}
+
 }  // namespace server::net
 
 USERVER_NAMESPACE_END
diff --git a/core/src/server/net/listener_config.hpp b/core/src/server/net/listener_config.hpp
index daa64cd335ed..e6d11e9d2465 100644
--- a/core/src/server/net/listener_config.hpp
+++ b/core/src/server/net/listener_config.hpp
@@ -6,10 +6,13 @@
 #include <boost/filesystem/operations.hpp>
 #include <userver/crypto/certificate.hpp>
 #include <userver/crypto/private_key.hpp>
+#include <userver/crypto/ssl_ctx.hpp>
 #include <userver/server/request/request_config.hpp>
 #include <userver/storages/secdist/secdist.hpp>
 #include <userver/yaml_config/yaml_config.hpp>
 
+#include <userver/crypto/certificate.hpp>
+
 #include "connection_config.hpp"
 
 USERVER_NAMESPACE_BEGIN
@@ -29,7 +32,10 @@ struct PortConfig {
     crypto::PrivateKey tls_private_key;
     std::vector<crypto::Certificate> tls_certificate_authorities;
 
+    std::optional<crypto::SslCtx> ssl_ctx;
+
     void ReadTlsSettings(const storages::secdist::SecdistConfig& secdist);
+    void InitSslCtx();
 };
 
 struct ListenerConfig {
diff --git a/core/src/server/net/listener_impl.cpp b/core/src/server/net/listener_impl.cpp
index f52f08d97863..da55ab3139d4 100644
--- a/core/src/server/net/listener_impl.cpp
+++ b/core/src/server/net/listener_impl.cpp
@@ -34,7 +34,7 @@ ListenerImpl::ListenerImpl(
       stats_(std::make_shared<Stats>()),
       data_accounter_(data_accounter) {
     for (const auto& port : endpoint_info_->listener_config.ports) {
-        socket_listener_tasks.push_back(engine::CriticalAsyncNoSpan(
+        socket_listener_tasks_.push_back(engine::CriticalAsyncNoSpan(
             task_processor_,
             [this](engine::io::Socket&& request_socket) {
                 while (!engine::current_task::ShouldCancel()) {
@@ -58,7 +58,7 @@ ListenerImpl::ListenerImpl(
 
 ListenerImpl::~ListenerImpl() {
     LOG_TRACE() << "Stopping socket listener task";
-    for (auto& task : socket_listener_tasks) task.SyncCancel();
+    for (auto& task : socket_listener_tasks_) task.SyncCancel();
     LOG_TRACE() << "Stopped socket listener task";
 
     connections_.CancelAndWait();
@@ -104,13 +104,10 @@ void ListenerImpl::ProcessConnection(engine::io::Socket peer_socket, const PortC
     std::unique_ptr<engine::io::RwBase> socket;
     auto remote_address = peer_socket.Getpeername();
     if (port_config.tls) {
-        socket = std::make_unique<engine::io::TlsWrapper>(engine::io::TlsWrapper::StartTlsServer(
-            std::move(peer_socket),
-            port_config.tls_cert_chain,
-            port_config.tls_private_key,
-            {},
-            port_config.tls_certificate_authorities
-        ));
+        UASSERT(port_config.ssl_ctx.has_value());
+        socket = std::make_unique<engine::io::TlsWrapper>(
+            engine::io::TlsWrapper::StartTlsServer(std::move(peer_socket), port_config.ssl_ctx.value(), {})
+        );
     } else {
         socket = std::make_unique<engine::io::Socket>(std::move(peer_socket));
     }
diff --git a/core/src/server/net/listener_impl.hpp b/core/src/server/net/listener_impl.hpp
index 70355cd08860..5c6e43e67a59 100644
--- a/core/src/server/net/listener_impl.hpp
+++ b/core/src/server/net/listener_impl.hpp
@@ -38,7 +38,7 @@ class ListenerImpl final {
 
     concurrent::BackgroundTaskStorageCore connections_;
 
-    std::vector<engine::TaskWithResult<void>> socket_listener_tasks;
+    std::vector<engine::TaskWithResult<void>> socket_listener_tasks_;
 };
 
 }  // namespace server::net
diff --git a/core/src/server/request/response_base.cpp b/core/src/server/request/response_base.cpp
index a636a9ae7f0c..2ac5c5d7f6fe 100644
--- a/core/src/server/request/response_base.cpp
+++ b/core/src/server/request/response_base.cpp
@@ -31,22 +31,22 @@ std::chrono::milliseconds ToMsFromStart(std::chrono::steady_clock::time_point tp
 }  // namespace
 
 void ResponseDataAccounter::StartRequest(size_t size, std::chrono::steady_clock::time_point create_time) {
-    count_.Add(1);
-    current_ += size;
+    pending_responses_count_.Add(1);
+    pending_responses_size_in_bytes_ += size;
     auto ms = ToMsFromStart(create_time);
     time_sum_.Add(ms.count());
 }
 
 void ResponseDataAccounter::StopRequest(size_t size, std::chrono::steady_clock::time_point create_time) {
-    current_ -= size;
+    pending_responses_size_in_bytes_ -= size;
     auto ms = ToMsFromStart(create_time);
     time_sum_.Subtract(ms.count());
-    count_.Subtract(1);
+    pending_responses_count_.Subtract(1);
 }
 
 std::chrono::milliseconds ResponseDataAccounter::GetAvgRequestTime() const {
     // TODO: race
-    auto count = count_.NonNegativeRead();
+    auto count = pending_responses_count_.NonNegativeRead();
     auto time_sum = std::chrono::milliseconds(time_sum_.NonNegativeRead());
 
     auto now_ms = ToMsFromStart(std::chrono::steady_clock::now());
@@ -83,7 +83,9 @@ void ResponseBase::SetReady(std::chrono::steady_clock::time_point now) {
     is_ready_ = true;
 }
 
-bool ResponseBase::IsLimitReached() const { return accounter_.GetCurrentLevel() >= accounter_.GetMaxLevel(); }
+bool ResponseBase::IsLimitReached() const {
+    return accounter_.GetPendingResponsesSizeInBytes() >= accounter_.GetMaxPendingResponsesSizeInBytes();
+}
 
 void ResponseBase::SetSendFailed(std::chrono::steady_clock::time_point failure_time) { SetSent(0, failure_time); }
 
diff --git a/core/src/server/requests_view.cpp b/core/src/server/requests_view.cpp
index 6691254ea431..756c4741da8c 100644
--- a/core/src/server/requests_view.cpp
+++ b/core/src/server/requests_view.cpp
@@ -12,7 +12,7 @@ const auto kDequeuePollPeriod = std::chrono::milliseconds(100);
 
 namespace server {
 
-RequestsView::RequestsView() : queue_(std::make_shared<Queue>()), job_requests(kDequeueBulkSize) {}
+RequestsView::RequestsView() : queue_(std::make_shared<Queue>()), job_requests_(kDequeueBulkSize) {}
 
 RequestsView::~RequestsView() { StopBackgroundWorker(); }
 
@@ -69,10 +69,10 @@ void RequestsView::GarbageCollect() {
 void RequestsView::HandleQueue() {
     const std::lock_guard<engine::Mutex> lock(requests_in_flight_mutex_);
     for (;;) {
-        const auto count = queue_->try_dequeue_bulk(job_requests.begin(), job_requests.size());
+        const auto count = queue_->try_dequeue_bulk(job_requests_.begin(), job_requests_.size());
         if (count == 0) break;
 
-        for (size_t i = 0; i < count; ++i) requests_in_flight_.push_back(std::move(job_requests[i]));
+        for (size_t i = 0; i < count; ++i) requests_in_flight_.push_back(std::move(job_requests_[i]));
     }
 }
 
diff --git a/core/src/server/requests_view.hpp b/core/src/server/requests_view.hpp
index fb877bba06b0..577ccdc87e2a 100644
--- a/core/src/server/requests_view.hpp
+++ b/core/src/server/requests_view.hpp
@@ -5,6 +5,7 @@
 
 #include <moodycamel/concurrentqueue.h>
 #include <userver/engine/mutex.hpp>
+#include <userver/engine/task/task_with_result.hpp>
 #include <userver/server/http/http_request.hpp>
 #include <userver/utils/periodic_task.hpp>
 
@@ -37,7 +38,7 @@ class RequestsView final {
 
     std::shared_ptr<Queue> queue_;
     engine::TaskWithResult<void> job_task_;
-    std::vector<RequestWPtr> job_requests;
+    std::vector<RequestWPtr> job_requests_;
 
     engine::Mutex requests_in_flight_mutex_;
     std::list<RequestWPtr> requests_in_flight_;
diff --git a/core/src/server/server.cpp b/core/src/server/server.cpp
index 76e9e5455f50..3879d5e0f9d2 100644
--- a/core/src/server/server.cpp
+++ b/core/src/server/server.cpp
@@ -40,10 +40,10 @@ struct PortInfo final {
 
     bool IsRunning() const noexcept;
 
-    std::optional<http::HttpRequestHandler> request_handler_;
-    std::shared_ptr<net::EndpointInfo> endpoint_info_;
-    request::ResponseDataAccounter data_accounter_;
-    std::vector<net::Listener> listeners_;
+    std::optional<http::HttpRequestHandler> request_handler;
+    std::shared_ptr<net::EndpointInfo> endpoint_info;
+    request::ResponseDataAccounter data_accounter;
+    std::vector<net::Listener> listeners;
 };
 
 void PortInfo::Init(
@@ -58,44 +58,44 @@ void PortInfo::Init(
                                                 ? component_context.GetTaskProcessor(*listener_config.task_processor)
                                                 : engine::current_task::GetTaskProcessor();
 
-    request_handler_.emplace(
+    request_handler.emplace(
         component_context, config.logger_access, config.logger_access_tskv, is_monitor, config.server_name
     );
 
-    endpoint_info_ = std::make_shared<net::EndpointInfo>(listener_config, *request_handler_);
+    endpoint_info = std::make_shared<net::EndpointInfo>(listener_config, *request_handler);
 
     const auto& event_thread_pool = task_processor.EventThreadPool();
     size_t listener_shards = listener_config.shards ? *listener_config.shards : event_thread_pool.GetSize();
 
-    listeners_.reserve(listener_shards);
+    listeners.reserve(listener_shards);
     while (listener_shards--) {
-        listeners_.emplace_back(endpoint_info_, task_processor, data_accounter_);
+        listeners.emplace_back(endpoint_info, task_processor, data_accounter);
     }
 }
 
 void PortInfo::Start() {
-    UASSERT(request_handler_);
-    request_handler_->DisableAddHandler();
-    for (auto& listener : listeners_) {
+    UASSERT(request_handler);
+    request_handler->DisableAddHandler();
+    for (auto& listener : listeners) {
         listener.Start();
     }
 }
 
 void PortInfo::Stop() {
     LOG_TRACE() << "Stopping listeners";
-    listeners_.clear();
+    listeners.clear();
     LOG_TRACE() << "Stopped listeners";
 
-    if (endpoint_info_) {
-        UASSERT_MSG(endpoint_info_->connection_count == 0, "Not all the connections were closed");
+    if (endpoint_info) {
+        UASSERT_MSG(endpoint_info->connection_count == 0, "Not all the connections were closed");
     }
 
     LOG_TRACE() << "Stopping request handlers";
-    request_handler_.reset();
+    request_handler.reset();
     LOG_TRACE() << "Stopped request handlers";
 }
 
-bool PortInfo::IsRunning() const noexcept { return request_handler_ && request_handler_->IsAddHandlerDisabled(); }
+bool PortInfo::IsRunning() const noexcept { return request_handler && request_handler->IsAddHandlerDisabled(); }
 
 void WriteRateAndLegacyMetrics(utils::statistics::Writer&& writer, utils::statistics::Rate metric) {
     writer = metric.value;
@@ -156,11 +156,14 @@ ServerImpl::ServerImpl(
     : config_(std::move(config)) {
     LOG_DEBUG() << "Creating server";
 
-    for (auto& port : config_.listener.ports) port.ReadTlsSettings(secdist);
+    for (auto& port : config_.listener.ports) {
+        port.ReadTlsSettings(secdist);
+        port.InitSslCtx();
+    }
 
     main_port_info_.Init(config_, config_.listener, component_context, false);
     if (config_.max_response_size_in_flight) {
-        main_port_info_.data_accounter_.SetMaxLevel(*config_.max_response_size_in_flight);
+        main_port_info_.data_accounter.SetMaxPendingResponsesSizeInBytes(*config_.max_response_size_in_flight);
     }
     if (config_.monitor_listener) {
         monitor_port_info_.Init(config_, *config_.monitor_listener, component_context, true);
@@ -175,20 +178,20 @@ ServerImpl::ServerImpl(
 ServerImpl::~ServerImpl() { Stop(); }
 
 void ServerImpl::StartPortInfos() {
-    UASSERT(main_port_info_.request_handler_);
+    UASSERT(main_port_info_.request_handler);
 
     if (has_requests_view_watchers_.load()) {
         auto queue = requests_view_.GetQueue();
         requests_view_.StartBackgroundWorker();
         auto hook = [queue](std::shared_ptr<http::HttpRequest> request) mutable { queue->enqueue(std::move(request)); };
-        main_port_info_.request_handler_->SetNewRequestHook(hook);
-        if (monitor_port_info_.request_handler_) {
-            monitor_port_info_.request_handler_->SetNewRequestHook(hook);
+        main_port_info_.request_handler->SetNewRequestHook(hook);
+        if (monitor_port_info_.request_handler) {
+            monitor_port_info_.request_handler->SetNewRequestHook(hook);
         }
     }
 
     main_port_info_.Start();
-    if (monitor_port_info_.request_handler_) {
+    if (monitor_port_info_.request_handler) {
         monitor_port_info_.Start();
     } else {
         LOG_WARNING() << "No 'listener-monitor' in 'server' component";
@@ -211,7 +214,7 @@ void ServerImpl::Stop() {
 void ServerImpl::AddHandler(const handlers::HttpHandlerBase& handler, engine::TaskProcessor& task_processor) {
     UASSERT(!main_port_info_.IsRunning());
 
-    if (handler.IsMonitor() && !monitor_port_info_.request_handler_) {
+    if (handler.IsMonitor() && !monitor_port_info_.request_handler) {
         throw std::logic_error(
             "Attempt to register a handler for 'listener-monitor' that was not "
             "configured in 'server' section of the component config"
@@ -220,14 +223,14 @@ void ServerImpl::AddHandler(const handlers::HttpHandlerBase& handler, engine::Ta
 
     if (handler.IsMonitor()) {
         UINVARIANT(
-            monitor_port_info_.request_handler_,
+            monitor_port_info_.request_handler,
             "Attempt to register monitor handler while the server has no "
             "'listener-monitor'"
         );
-        monitor_port_info_.request_handler_->AddHandler(handler, task_processor);
+        monitor_port_info_.request_handler->AddHandler(handler, task_processor);
     } else {
-        UASSERT(main_port_info_.request_handler_);
-        main_port_info_.request_handler_->AddHandler(handler, task_processor);
+        UASSERT(main_port_info_.request_handler);
+        main_port_info_.request_handler->AddHandler(handler, task_processor);
     }
 
     if (!handler.IsMonitor()) {
@@ -243,17 +246,17 @@ std::size_t ServerImpl::GetThrottlableHandlersCount() const {
 }
 
 std::chrono::milliseconds ServerImpl::GetAvgRequestTimeMs() const {
-    return main_port_info_.data_accounter_.GetAvgRequestTime();
+    return main_port_info_.data_accounter.GetAvgRequestTime();
 }
 
 const http::HttpRequestHandler& ServerImpl::GetHttpRequestHandler(bool is_monitor) const {
     if (is_monitor) {
-        UASSERT(monitor_port_info_.request_handler_);
-        return *monitor_port_info_.request_handler_;
+        UASSERT(monitor_port_info_.request_handler);
+        return *monitor_port_info_.request_handler;
     }
 
-    UASSERT(main_port_info_.request_handler_);
-    return *main_port_info_.request_handler_;
+    UASSERT(main_port_info_.request_handler);
+    return *main_port_info_.request_handler;
 }
 
 net::StatsAggregation ServerImpl::GetServerStats() const {
@@ -261,7 +264,7 @@ net::StatsAggregation ServerImpl::GetServerStats() const {
 
     const std::shared_lock lock{on_stop_mutex_};
     if (is_stopping_) return summary;
-    for (const auto& listener : main_port_info_.listeners_) {
+    for (const auto& listener : main_port_info_.listeners) {
         summary += listener.GetStats();
     }
 
@@ -289,8 +292,8 @@ void ServerImpl::WriteTotalHandlerStatistics(utils::statistics::Writer& writer)
             return;
         }
 
-        UASSERT(main_port_info_.request_handler_);
-        const auto& handlers = main_port_info_.request_handler_->GetHandlerInfoIndex().GetHandlers();
+        UASSERT(main_port_info_.request_handler);
+        const auto& handlers = main_port_info_.request_handler->GetHandlerInfoIndex().GetHandlers();
 
         for (const auto handler_ptr : handlers) {
             for (const auto method : handler_ptr->GetAllowedMethods()) {
@@ -304,13 +307,13 @@ void ServerImpl::WriteTotalHandlerStatistics(utils::statistics::Writer& writer)
 }
 
 void ServerImpl::SetRpsRatelimitStatusCode(http::HttpStatus status_code) {
-    UASSERT(main_port_info_.request_handler_);
-    main_port_info_.request_handler_->SetRpsRatelimitStatusCode(status_code);
+    UASSERT(main_port_info_.request_handler);
+    main_port_info_.request_handler->SetRpsRatelimitStatusCode(status_code);
 }
 
 void ServerImpl::SetRpsRatelimit(std::optional<size_t> rps) {
-    UASSERT(main_port_info_.request_handler_);
-    main_port_info_.request_handler_->SetRpsRatelimit(rps);
+    UASSERT(main_port_info_.request_handler);
+    main_port_info_.request_handler->SetRpsRatelimit(rps);
 }
 
 std::uint64_t ServerImpl::GetTotalRequests() const {
@@ -323,16 +326,16 @@ Server::Server(
     const storages::secdist::SecdistConfig& secdist,
     const components::ComponentContext& component_context
 )
-    : pimpl(std::make_unique<ServerImpl>(std::move(config), secdist, component_context)) {}
+    : pimpl_(std::make_unique<ServerImpl>(std::move(config), secdist, component_context)) {}
 
 Server::~Server() = default;
 
-const ServerConfig& Server::GetConfig() const { return pimpl->GetServerConfig(); }
+const ServerConfig& Server::GetConfig() const { return pimpl_->GetServerConfig(); }
 
-std::vector<std::string> Server::GetCommonMiddlewares() const { return pimpl->GetMiddlewares(); }
+std::vector<std::string> Server::GetCommonMiddlewares() const { return pimpl_->GetMiddlewares(); }
 
 void Server::WriteMonitorData(utils::statistics::Writer& writer) const {
-    const auto server_stats = pimpl->GetServerStats();
+    const auto server_stats = pimpl_->GetServerStats();
     if (auto conn_stats = writer["connections"]) {
         conn_stats["active"] = server_stats.active_connections;
         WriteRateAndLegacyMetrics(conn_stats["opened"], server_stats.connections_created);
@@ -341,7 +344,7 @@ void Server::WriteMonitorData(utils::statistics::Writer& writer) const {
 
     if (auto request_stats = writer["requests"]) {
         request_stats["active"] = server_stats.active_request_count;
-        request_stats["avg-lifetime-ms"] = pimpl->GetAvgRequestTimeMs().count();
+        request_stats["avg-lifetime-ms"] = pimpl_->GetAvgRequestTimeMs().count();
         WriteRateAndLegacyMetrics(request_stats["processed"], server_stats.requests_processed_count);
         request_stats["parsing"] = server_stats.parser_stats.parsing_request_count;
 
@@ -356,36 +359,36 @@ void Server::WriteMonitorData(utils::statistics::Writer& writer) const {
 }
 
 void Server::WriteTotalHandlerStatistics(utils::statistics::Writer& writer) const {
-    pimpl->WriteTotalHandlerStatistics(writer);
+    pimpl_->WriteTotalHandlerStatistics(writer);
 }
 
-net::StatsAggregation Server::GetServerStats() const { return pimpl->GetServerStats(); }
+net::StatsAggregation Server::GetServerStats() const { return pimpl_->GetServerStats(); }
 
 void Server::AddHandler(const handlers::HttpHandlerBase& handler, engine::TaskProcessor& task_processor) {
-    pimpl->AddHandler(handler, task_processor);
+    pimpl_->AddHandler(handler, task_processor);
 }
 
-size_t Server::GetThrottlableHandlersCount() const { return pimpl->GetThrottlableHandlersCount(); }
+size_t Server::GetThrottlableHandlersCount() const { return pimpl_->GetThrottlableHandlersCount(); }
 
 const http::HttpRequestHandler& Server::GetHttpRequestHandler(bool is_monitor) const {
-    return pimpl->GetHttpRequestHandler(is_monitor);
+    return pimpl_->GetHttpRequestHandler(is_monitor);
 }
 
 void Server::Start() {
     LOG_INFO() << "Starting server";
-    pimpl->StartPortInfos();
+    pimpl_->StartPortInfos();
     LOG_INFO() << "Server is started";
 }
 
-void Server::Stop() { pimpl->Stop(); }
+void Server::Stop() { pimpl_->Stop(); }
 
-RequestsView& Server::GetRequestsView() { return pimpl->GetRequestsView(); }
+RequestsView& Server::GetRequestsView() { return pimpl_->GetRequestsView(); }
 
-void Server::SetRpsRatelimit(std::optional<size_t> rps) { pimpl->SetRpsRatelimit(rps); }
+void Server::SetRpsRatelimit(std::optional<size_t> rps) { pimpl_->SetRpsRatelimit(rps); }
 
-void Server::SetRpsRatelimitStatusCode(http::HttpStatus status_code) { pimpl->SetRpsRatelimitStatusCode(status_code); }
+void Server::SetRpsRatelimitStatusCode(http::HttpStatus status_code) { pimpl_->SetRpsRatelimitStatusCode(status_code); }
 
-std::uint64_t Server::GetTotalRequests() const { return pimpl->GetTotalRequests(); }
+std::uint64_t Server::GetTotalRequests() const { return pimpl_->GetTotalRequests(); }
 
 }  // namespace server
 
diff --git a/core/src/server/websocket/protocol.cpp b/core/src/server/websocket/protocol.cpp
index 875e267ba89f..617c5d281d9f 100644
--- a/core/src/server/websocket/protocol.cpp
+++ b/core/src/server/websocket/protocol.cpp
@@ -56,13 +56,23 @@ union Mask32 {
 };
 
 void XorMaskInplace(uint8_t* dest, size_t len, Mask32 mask) {
-    auto* dest32 = reinterpret_cast<uint32_t*>(dest);
-    while (len >= sizeof(uint32_t)) {
-        *(dest32++) ^= mask.mask32;
-        len -= sizeof(uint32_t);
+    // Check if the pointer is aligned for uint32_t operations
+    const auto alignment = reinterpret_cast<std::uintptr_t>(dest) % sizeof(uint32_t);
+
+    if (alignment == 0 && len >= sizeof(uint32_t)) {
+        // Pointer is aligned, we can safely use uint32_t operations
+        auto* dest32 = reinterpret_cast<uint32_t*>(dest);
+        while (len >= sizeof(uint32_t)) {
+            *(dest32++) ^= mask.mask32;
+            len -= sizeof(uint32_t);
+        }
+        dest = reinterpret_cast<uint8_t*>(dest32);
+    }
+
+    // Process remaining bytes (or all bytes if unaligned) using byte operations
+    for (size_t i = 0; i < len; ++i) {
+        dest[i] ^= mask.mask8[i % 4];
     }
-    auto* dest8 = reinterpret_cast<uint8_t*>(dest32);
-    for (unsigned i = 0; i < len; ++i) *(dest8++) ^= mask.mask8[i];
 }
 
 template <class T, class V>
@@ -89,12 +99,12 @@ DataFrameHeader(utils::span<const std::byte> data, bool is_text, Continuation is
     if (is_continuation == Continuation::kYes) hdr->bits.opcode = kContinuation;
 
     if (data.size() <= 125) {
-        hdr->bits.payloadLen = data.size();
+        hdr->bits.payload_len = data.size();
     } else if (data.size() <= INT16_MAX) {
-        hdr->bits.payloadLen = 126;
+        hdr->bits.payload_len = 126;
         PushRaw(boost::endian::native_to_big(static_cast<std::int16_t>(data.size())), frame);
     } else {
-        hdr->bits.payloadLen = 127;
+        hdr->bits.payload_len = 127;
         PushRaw(boost::endian::native_to_big(data.size()), frame);
     }
     return frame;
@@ -106,7 +116,7 @@ std::string CloseFrame(CloseStatusInt status_code) {
     auto* hdr = reinterpret_cast<WSHeader*>(frame.data());
     hdr->bits.fin = 1;
     hdr->bits.opcode = kClose;
-    hdr->bits.payloadLen = sizeof(status_code);
+    hdr->bits.payload_len = sizeof(status_code);
 
     auto* payload = reinterpret_cast<CloseStatusInt*>(&frame[sizeof(WSHeader)]);
     *payload = boost::endian::native_to_big(status_code);
@@ -121,7 +131,7 @@ std::array<char, sizeof(WSHeader)> MakeControlFrame(WSOpcodes opcode, utils::spa
     hdr->bits.fin = 1;
     hdr->bits.opcode = opcode;
 
-    hdr->bits.payloadLen = data.size();
+    hdr->bits.payload_len = data.size();
     return frame;
 }
 
@@ -165,9 +175,9 @@ CloseStatus ReadWSFrameImpl(
     if (engine::current_task::ShouldCancel()) return CloseStatus::kGoingAway;
 
     const bool isDataFrame = (hdr.bits.opcode & (kText | kBinary)) || hdr.bits.opcode == kContinuation;
-    if (hdr.bits.payloadLen <= 125) {
-        payload_len = hdr.bits.payloadLen;
-    } else if (hdr.bits.payloadLen == 126) {
+    if (hdr.bits.payload_len <= 125) {
+        payload_len = hdr.bits.payload_len;
+    } else if (hdr.bits.payload_len == 126) {
         uint16_t payloadLen16 = 0;
         RecvExactly(io, AsWritableBytes(MakeSpan(&payloadLen16, 1)), {});
         payload_len = boost::endian::big_to_native(payloadLen16);
@@ -179,7 +189,7 @@ CloseStatus ReadWSFrameImpl(
     }
     if (engine::current_task::ShouldCancel()) return CloseStatus::kGoingAway;
 
-    if (!isDataFrame && hdr.bits.payloadLen > 125) {
+    if (!isDataFrame && hdr.bits.payload_len > 125) {
         // control frame should not have extended payload
         return CloseStatus::kProtocolError;
     }
@@ -203,7 +213,9 @@ CloseStatus ReadWSFrameImpl(
         RecvExactly(io, MakeSpan(frame.payload->data() + newPayloadOffset, payload_len), {});
         if (engine::current_task::ShouldCancel()) return CloseStatus::kGoingAway;
 
-        if (mask.mask32) XorMaskInplace(reinterpret_cast<uint8_t*>(frame.payload->data()), frame.payload->size(), mask);
+        // Apply masking only to the current frame's data, not to the entire buffer
+        if (mask.mask32)
+            XorMaskInplace(reinterpret_cast<uint8_t*>(frame.payload->data() + newPayloadOffset), payload_len, mask);
     }
     const char opcode = hdr.bits.opcode;
     const char fin = hdr.bits.fin;
diff --git a/core/src/server/websocket/protocol.hpp b/core/src/server/websocket/protocol.hpp
index 8430cdbe5b2e..9a6bfffe433d 100644
--- a/core/src/server/websocket/protocol.hpp
+++ b/core/src/server/websocket/protocol.hpp
@@ -53,7 +53,7 @@ union WSHeader {
         unsigned char reserved : 3;
         unsigned char fin : 1;
 
-        unsigned char payloadLen : 7;
+        unsigned char payload_len : 7;
         unsigned char mask : 1;
     } bits;
     uint16_t bytes = 0;
diff --git a/core/src/server/websocket/server.cpp b/core/src/server/websocket/server.cpp
index e99f2cfa315e..6534be53a71a 100644
--- a/core/src/server/websocket/server.cpp
+++ b/core/src/server/websocket/server.cpp
@@ -39,7 +39,7 @@ Config Parse(const yaml_config::YamlConfig& config, formats::parse::To<Config>)
 class WebSocketConnectionImpl final : public WebSocketConnection {
 public:
 private:
-    std::unique_ptr<engine::io::RwBase> io;
+    std::unique_ptr<engine::io::RwBase> io_;
 
     struct MessageExtended final {
         utils::span<const std::byte> data;
@@ -59,17 +59,17 @@ class WebSocketConnectionImpl final : public WebSocketConnection {
     // only a single task calling Recv().
     impl::FrameParserState frame_;
 
-    Config config;
+    Config config_;
 
     std::atomic<std::size_t> ping_pending_count_{0};
 
 public:
     WebSocketConnectionImpl(
-        std::unique_ptr<engine::io::RwBase> io_,
+        std::unique_ptr<engine::io::RwBase> io,
         const engine::io::Sockaddr& remote_addr,
         const Config& server_config
     )
-        : io(std::move(io_)), remote_addr_(remote_addr), config(server_config) {}
+        : io_(std::move(io)), remote_addr_(remote_addr), config_(server_config) {}
 
     ~WebSocketConnectionImpl() override { LOG_TRACE() << "Websocket connection closed"; }
 
@@ -81,31 +81,31 @@ class WebSocketConnectionImpl final : public WebSocketConnection {
 
         LOG_TRACE() << "Write message " << message.data.size() << " bytes";
         if (message.opcode == impl::WSOpcodes::kPing) {
-            SendExactly(*io, impl::frames::PingFrame(), {});
+            SendExactly(*io_, impl::frames::PingFrame(), {});
         } else if (message.opcode == impl::WSOpcodes::kPong) {
             const auto control_frame = impl::frames::MakeControlFrame(impl::WSOpcodes::kPong, message.data);
-            SendExactly(*io, control_frame, message.data);
+            SendExactly(*io_, control_frame, message.data);
         } else if (message.close_status.has_value()) {
             const auto close_frame = impl::frames::CloseFrame(static_cast<int>(message.close_status.value()));
-            SendExactly(*io, close_frame, {});
+            SendExactly(*io_, close_frame, {});
         } else if (!message.data.empty()) {
             utils::span<const std::byte> data_to_send{message.data};
             auto continuation = impl::frames::Continuation::kNo;
-            while (data_to_send.size() > config.fragment_size && config.fragment_size > 0) {
+            while (data_to_send.size() > config_.fragment_size && config_.fragment_size > 0) {
                 const auto data_frame_header = impl::frames::DataFrameHeader(
-                    data_to_send.first(config.fragment_size),
+                    data_to_send.first(config_.fragment_size),
                     message.opcode == impl::WSOpcodes::kText,
                     continuation,
                     impl::frames::Final::kNo
                 );
-                SendExactly(*io, data_frame_header, data_to_send.first(config.fragment_size));
+                SendExactly(*io_, data_frame_header, data_to_send.first(config_.fragment_size));
                 continuation = impl::frames::Continuation::kYes;
-                data_to_send = data_to_send.last(data_to_send.size() - config.fragment_size);
+                data_to_send = data_to_send.last(data_to_send.size() - config_.fragment_size);
             }
             const auto data_frame_header = impl::frames::DataFrameHeader(
                 data_to_send, message.opcode == impl::WSOpcodes::kText, continuation, impl::frames::Final::kYes
             );
-            SendExactly(*io, data_frame_header, data_to_send);
+            SendExactly(*io_, data_frame_header, data_to_send);
         }
     }
 
@@ -146,12 +146,12 @@ class WebSocketConnectionImpl final : public WebSocketConnection {
 
             if (do_not_wait_for_message_header) {
                 const auto opt_status_raw =
-                    ReadWSFrameDontWaitForHeader(frame_, *io, config.max_remote_payload, payload_len);
+                    ReadWSFrameDontWaitForHeader(frame_, *io_, config_.max_remote_payload, payload_len);
                 if (!opt_status_raw) return false;
                 status_raw = *opt_status_raw;
             } else {
                 // ReadWSFrame() returns kGoingAway in case of task cancellation
-                status_raw = ReadWSFrame(frame_, *io, config.max_remote_payload, payload_len);
+                status_raw = ReadWSFrame(frame_, *io_, config_.max_remote_payload, payload_len);
             }
 
             const auto status = static_cast<CloseStatusInt>(status_raw);
diff --git a/core/src/storages/query.cpp b/core/src/storages/query.cpp
index d4a77d4c54f0..b05fae6986ff 100644
--- a/core/src/storages/query.cpp
+++ b/core/src/storages/query.cpp
@@ -6,11 +6,11 @@ namespace storages {
 
 struct Query::NameViewVisitor {
     std::optional<Query::NameView> operator()(const DynamicStrings& x) const noexcept {
-        return (x.name_ ? std::optional<Query::NameView>{x.name_->GetUnderlying()} : std::nullopt);
+        return (x.name ? std::optional<Query::NameView>{x.name->GetUnderlying()} : std::nullopt);
     }
 
     std::optional<Query::NameView> operator()(const StaticStrings& x) const noexcept {
-        return std::optional<Query::NameView>{x.name_};
+        return std::optional<Query::NameView>{x.name};
     }
 };
 
@@ -19,7 +19,7 @@ std::optional<Query::NameView> Query::GetOptionalNameView() const noexcept {
 }
 
 utils::zstring_view Query::GetStatementView() const noexcept {
-    return std::visit([](const auto& x) { return utils::zstring_view{x.statement_}; }, data_);
+    return std::visit([](const auto& x) { return utils::zstring_view{x.statement}; }, data_);
 }
 
 }  // namespace storages
diff --git a/core/src/testing_test.cpp b/core/src/testing_test.cpp
index cbc4e04efd21..40674dfdeab7 100644
--- a/core/src/testing_test.cpp
+++ b/core/src/testing_test.cpp
@@ -16,7 +16,7 @@ using utest::SimpleServer;
 const std::string kOkRequest = "OK";
 const std::string kOkResponse = "OK RESPONSE DATA";
 
-SimpleServer::Response assert_received_ok(const SimpleServer::Request& r) {
+SimpleServer::Response AssertReceivedOk(const SimpleServer::Request& r) {
     EXPECT_EQ(r, kOkRequest) << "SimpleServer received: " << r;
     return {kOkResponse, SimpleServer::Response::kWriteAndClose};
 }
@@ -24,7 +24,7 @@ SimpleServer::Response assert_received_ok(const SimpleServer::Request& r) {
 }  // namespace
 
 UTEST(SimpleServer, ExampleTcpIpV4) {
-    const SimpleServer s(assert_received_ok);
+    const SimpleServer s(AssertReceivedOk);
 
     // ... invoke code that sends "OK" to localhost
     auto addr = engine::io::Sockaddr::MakeIPv4LoopbackAddress();
@@ -51,7 +51,7 @@ UTEST(SimpleServer, NothingReceived) {
 }
 
 UTEST(SimpleServer, ExampleTcpIpV6) {
-    const SimpleServer s(assert_received_ok, SimpleServer::kTcpIpV6);
+    const SimpleServer s(AssertReceivedOk, SimpleServer::kTcpIpV6);
 
     // ... invoke code that sends "OK" to localhost:8080 or localhost:8042.
     auto addr = engine::io::Sockaddr::MakeLoopbackAddress();
diff --git a/core/src/testsuite/impl/actions/control.cpp b/core/src/testsuite/impl/actions/control.cpp
index aa688ab95cfc..fcc196fb5867 100644
--- a/core/src/testsuite/impl/actions/control.cpp
+++ b/core/src/testsuite/impl/actions/control.cpp
@@ -3,6 +3,7 @@
 #include <userver/components/component.hpp>
 #include <userver/components/statistics_storage.hpp>
 #include <userver/logging/component.hpp>
+#include <userver/logging/log.hpp>
 #include <userver/server/handlers/exceptions.hpp>
 #include <userver/testsuite/testsuite_support.hpp>
 #include <userver/utils/datetime.hpp>
diff --git a/core/src/testsuite/testpoint.cpp b/core/src/testsuite/testpoint.cpp
index 8995e15aa535..145bd4a998e7 100644
--- a/core/src/testsuite/testpoint.cpp
+++ b/core/src/testsuite/testpoint.cpp
@@ -11,6 +11,7 @@
 #include <userver/utils/function_ref.hpp>
 #include <userver/utils/impl/transparent_hash.hpp>
 #include <userver/utils/overloaded.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -76,6 +77,7 @@ void ExecuteTestpointCoro(
     const TestpointScope tp_scope;
     if (!tp_scope) return;
 
+    utils::trx_tracker::CheckDisabler disabler;
     tp_scope.GetClient().Execute(name, json, callback);
 }
 
diff --git a/core/src/tracing/any_value.cpp b/core/src/tracing/any_value.cpp
index 7d7b7ff843c7..9f69d24db609 100644
--- a/core/src/tracing/any_value.cpp
+++ b/core/src/tracing/any_value.cpp
@@ -37,11 +37,11 @@ utils::StringLiteral ToString(ValueIndex index) {
     UINVARIANT(false, fmt::format("Unexpected index: {}", static_cast<std::uint8_t>(index)));
 }
 
-template <ValueIndex expected>
+template <ValueIndex Expected>
 void CheckIndex(std::uint8_t actual) {
     UASSERT_MSG(
-        actual == expected,
-        fmt::format("Expected: '{}', Actual: '{}'", ToString(expected), ToString(static_cast<ValueIndex>(actual)))
+        actual == Expected,
+        fmt::format("Expected: '{}', Actual: '{}'", ToString(Expected), ToString(static_cast<ValueIndex>(actual)))
     );
 }
 
diff --git a/core/src/tracing/span.cpp b/core/src/tracing/span.cpp
index ee6d0de8b0f9..cd9e258650c0 100644
--- a/core/src/tracing/span.cpp
+++ b/core/src/tracing/span.cpp
@@ -68,17 +68,17 @@ TsBuffer StartTsToString(std::chrono::system_clock::time_point start) {
 // Maintain coro-local span stack to identify "current span" in O(1).
 engine::TaskLocalVariable<SpanStack> task_local_spans;
 
-template <std::size_t kSboSize, std::size_t kIdSize>
-utils::SmallString<kSboSize> GenerateId() {
+template <std::size_t SboSize, std::size_t IdSize>
+utils::SmallString<SboSize> GenerateId() {
     using Chunk = utils::RandomBase::result_type;
     static constexpr std::size_t kHexChunkSize = utils::encoding::LengthInHexForm(sizeof(Chunk));
-    static_assert(kIdSize % kHexChunkSize == 0);
+    static_assert(IdSize % kHexChunkSize == 0);
     static_assert(utils::RandomBase::min() == std::numeric_limits<Chunk>::min());
     static_assert(utils::RandomBase::max() == std::numeric_limits<Chunk>::max());
 
-    utils::SmallString<kSboSize> result;
+    utils::SmallString<SboSize> result;
 
-    result.resize_and_overwrite(kIdSize, [](char* data, std::size_t size) {
+    result.resize_and_overwrite(IdSize, [](char* data, std::size_t size) {
         utils::WithDefaultRandom([&](auto& rnd) {
             for (std::size_t pos = 0; pos < size; pos += kHexChunkSize) {
                 const auto random_value = rnd();
@@ -232,7 +232,7 @@ std::optional<std::string_view> Span::Impl::GetSpanIdForChildLogs() const {
 }
 
 void Span::OptionalDeleter::operator()(Span::Impl* impl) const noexcept {
-    if (do_delete) {
+    if (do_delete_) {
         std::default_delete<Impl>{}(impl);
     }
 }
diff --git a/core/src/tracing/tracing_benchmark.cpp b/core/src/tracing/tracing_benchmark.cpp
index 415a37a835cb..b0d2dcedf109 100644
--- a/core/src/tracing/tracing_benchmark.cpp
+++ b/core/src/tracing/tracing_benchmark.cpp
@@ -16,7 +16,7 @@ class NoopLogger : public logging::impl::TextLogger {
     void Flush() override {}
 };
 
-void tracing_noop_ctr(benchmark::State& state) {
+void TracingNoopCtr(benchmark::State& state) {
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
             tracing::Span tmp = tracing::Span::MakeRootSpan("name");
@@ -25,9 +25,9 @@ void tracing_noop_ctr(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(tracing_noop_ctr);
+BENCHMARK(TracingNoopCtr);
 
-void tracing_happy_log(benchmark::State& state) {
+void TracingHappyLog(benchmark::State& state) {
     const logging::DefaultLoggerGuard guard{std::make_shared<NoopLogger>()};
 
     engine::RunStandalone([&] {
@@ -37,7 +37,7 @@ void tracing_happy_log(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(tracing_happy_log);
+BENCHMARK(TracingHappyLog);
 
 tracing::Span GetSpanWithOpentracingHttpTags() {
     auto span = tracing::Span::MakeRootSpan("name");
@@ -47,7 +47,7 @@ tracing::Span GetSpanWithOpentracingHttpTags() {
     return span;
 }
 
-void tracing_opentracing_ctr(benchmark::State& state) {
+void TracingOpentracingCtr(benchmark::State& state) {
     auto logger = logging::MakeNullLogger();
     engine::RunStandalone([&] {
         for ([[maybe_unused]] auto _ : state) {
@@ -56,7 +56,7 @@ void tracing_opentracing_ctr(benchmark::State& state) {
         }
     });
 }
-BENCHMARK(tracing_opentracing_ctr);
+BENCHMARK(TracingOpentracingCtr);
 
 }  // namespace
 
diff --git a/core/src/utils/async.cpp b/core/src/utils/async.cpp
index fd80821c9e06..afe2ea31e9d0 100644
--- a/core/src/utils/async.cpp
+++ b/core/src/utils/async.cpp
@@ -13,19 +13,19 @@ namespace utils::impl {
 struct SpanWrapCall::Impl {
     explicit Impl(std::string&& name, InheritVariables inherit_variables, const SourceLocation& location);
 
-    tracing::InPlaceSpan span_;
-    engine::impl::task_local::Storage storage_;
+    tracing::InPlaceSpan span;
+    engine::impl::task_local::Storage storage;
 };
 
 SpanWrapCall::Impl::Impl(std::string&& name, InheritVariables inherit_variables, const SourceLocation& location)
-    : span_(std::move(name), tracing::InPlaceSpan::DetachedTag{}, location) {
+    : span(std::move(name), tracing::InPlaceSpan::DetachedTag{}, location) {
     if (!engine::current_task::IsTaskProcessorThread()) {
         return;
     }
     if (inherit_variables == InheritVariables::kYes) {
-        storage_.InheritFrom(engine::impl::task_local::GetCurrentStorage());
+        storage.InheritFrom(engine::impl::task_local::GetCurrentStorage());
     } else {
-        baggage::kInheritedBaggage.InheritTo(storage_, engine::impl::task_local::InternalTag{});
+        baggage::kInheritedBaggage.InheritTo(storage, engine::impl::task_local::InternalTag{});
     }
 }
 
@@ -33,8 +33,8 @@ SpanWrapCall::SpanWrapCall(std::string&& name, InheritVariables inherit_variable
     : pimpl_(std::move(name), inherit_variables, location) {}
 
 void SpanWrapCall::DoBeforeInvoke() {
-    engine::impl::task_local::GetCurrentStorage().InitializeFrom(std::move(pimpl_->storage_));
-    pimpl_->span_.Get().AttachToCoroStack();
+    engine::impl::task_local::GetCurrentStorage().InitializeFrom(std::move(pimpl_->storage));
+    pimpl_->span.Get().AttachToCoroStack();
 }
 
 SpanWrapCall::~SpanWrapCall() = default;
diff --git a/core/src/utils/datetime.cpp b/core/src/utils/datetime.cpp
index f3709007819e..8f5cd675070f 100644
--- a/core/src/utils/datetime.cpp
+++ b/core/src/utils/datetime.cpp
@@ -24,7 +24,7 @@ namespace {
 
 std::optional<cctz::time_zone> DoGetOptionalTimezone(const std::string& tzname) {
 #if defined(BSD) && !defined(__APPLE__)
-    if (tzname == "GMT") return GetOptionalTimezone("UTC");
+    if (tzname == "GMT") return DoGetOptionalTimezone("UTC");
 #endif
     cctz::time_zone tz;
     if (!load_time_zone(tzname, &tz)) {
@@ -33,23 +33,6 @@ std::optional<cctz::time_zone> DoGetOptionalTimezone(const std::string& tzname)
     return tz;
 }
 
-std::optional<cctz::time_zone> GetOptionalTimezone(const std::string& tzname) {
-    if (engine::current_task::IsTaskProcessorThread()) {
-        static rcu::RcuMap<std::string, std::optional<cctz::time_zone>> map;
-        auto it = map.Get(tzname);
-        if (it) return *it;
-
-        // DoGetOptionalTimezone() may access filesystem, run it in blocking task processor
-        auto [value, _] =
-            map.Emplace(tzname, engine::AsyncNoSpan(engine::current_task::GetBlockingTaskProcessor(), [&tzname] {
-                                    return DoGetOptionalTimezone(tzname);
-                                }).Get());
-        return *value;
-    } else {
-        return DoGetOptionalTimezone(tzname);
-    }
-}
-
 cctz::time_zone GetTimezone(const std::string& tzname) {
     auto tz = GetOptionalTimezone(tzname);
     if (!tz.has_value()) {
@@ -57,6 +40,7 @@ cctz::time_zone GetTimezone(const std::string& tzname) {
     }
     return *tz;
 }
+
 }  // namespace
 
 std::string
@@ -99,6 +83,23 @@ time_t Unlocalize(const cctz::civil_second& local_tp, const std::string& timezon
     return Timestamp(cctz::convert(local_tp, GetTimezone(timezone)));
 }
 
+std::optional<cctz::time_zone> GetOptionalTimezone(const std::string& tzname) {
+    if (engine::current_task::IsTaskProcessorThread()) {
+        static rcu::RcuMap<std::string, std::optional<cctz::time_zone>> map;
+        auto it = map.Get(tzname);
+        if (it) return *it;
+
+        // DoGetOptionalTimezone() may access filesystem, run it in blocking task processor
+        auto [value, _] =
+            map.Emplace(tzname, engine::AsyncNoSpan(engine::current_task::GetBlockingTaskProcessor(), [&tzname] {
+                                    return DoGetOptionalTimezone(tzname);
+                                }).Get());
+        return *value;
+    } else {
+        return DoGetOptionalTimezone(tzname);
+    }
+}
+
 }  // namespace utils::datetime
 
 USERVER_NAMESPACE_END
diff --git a/core/src/utils/hedged_request_test.cpp b/core/src/utils/hedged_request_test.cpp
index 43c88a3f8228..5168e657fa27 100644
--- a/core/src/utils/hedged_request_test.cpp
+++ b/core/src/utils/hedged_request_test.cpp
@@ -87,20 +87,20 @@ class TestStrategy {
     }
 
     std::optional<std::chrono::milliseconds> ProcessReply(RequestType&& request) {
-        reply_ = std::move(request).Get();
+        reply = std::move(request).Get();
         event_log.push_back({Event::ProcessReply, request.attempt});
         if (attempt_program.size() <= request.attempt) return std::nullopt;
         return attempt_program[request.attempt].process_reply_result;
     }
 
-    std::optional<ReplyType> ExtractReply() { return reply_; }
+    std::optional<ReplyType> ExtractReply() { return reply; }
 
     void Finish(RequestType&& request) {
         event_log.push_back({Event::Finish, request.attempt});
         if (request.task.IsValid()) request.task.SyncCancel();
     }
 
-    std::optional<ReplyType> reply_;
+    std::optional<ReplyType> reply;
     AttemptProgram attempt_program;
     EventLog& event_log;
 };
diff --git a/core/src/utils/jemalloc.cpp b/core/src/utils/jemalloc.cpp
index 4fb8316bc01c..c451f4990e02 100644
--- a/core/src/utils/jemalloc.cpp
+++ b/core/src/utils/jemalloc.cpp
@@ -16,8 +16,11 @@ namespace utils::jemalloc {
 namespace {
 
 #ifndef USERVER_FEATURE_JEMALLOC_ENABLED
+
+// NOLINTNEXTLINE(readability-identifier-naming)
 int mallctl(const char*, void*, size_t*, void*, size_t) { return ENOTSUP; }
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 void malloc_stats_print(void (*write_cb)(void*, const char*), void* je_cbopaque, const char*) {
     write_cb(je_cbopaque, "(libjemalloc support is disabled)");
 }
diff --git a/core/src/utils/periodic_task.cpp b/core/src/utils/periodic_task.cpp
index bced8cb9b43c..0d47d4f61c82 100644
--- a/core/src/utils/periodic_task.cpp
+++ b/core/src/utils/periodic_task.cpp
@@ -6,9 +6,13 @@
 #include <fmt/format.h>
 
 #include <userver/engine/async.hpp>
+#include <userver/engine/condition_variable.hpp>
+#include <userver/engine/single_consumer_event.hpp>
 #include <userver/engine/sleep.hpp>
 #include <userver/engine/task/cancel.hpp>
+#include <userver/engine/task/task_with_result.hpp>
 #include <userver/logging/log.hpp>
+#include <userver/rcu/rcu.hpp>
 #include <userver/testsuite/periodic_task_control.hpp>
 #include <userver/tracing/span.hpp>
 #include <userver/tracing/tracer.hpp>
@@ -28,6 +32,38 @@ auto TieSettings(const PeriodicTask::Settings& settings) {
 
 }  // namespace
 
+class PeriodicTask::Impl final {
+public:
+    enum class SuspendState { kRunning, kSuspended };
+
+    std::string name;
+    std::atomic<bool> is_name_set{false};
+    PeriodicTask::Callback callback;
+    engine::TaskWithResult<void> task;
+    rcu::Variable<PeriodicTask::Settings> settings;
+    engine::SingleConsumerEvent changed_event;
+    std::atomic<bool> should_force_step{false};
+    std::optional<std::minstd_rand> mutate_period_random;
+
+    // For kNow only
+    engine::Mutex step_mutex;
+    std::atomic<SuspendState> suspend_state;
+
+    std::optional<USERVER_NAMESPACE::testsuite::PeriodicTaskRegistrationHolder> registration_holder;
+
+    Impl() : settings(std::chrono::seconds(1)), suspend_state(SuspendState::kRunning) {}
+
+    void DoStart();
+    void Run();
+    bool Step();
+    bool StepDebug(bool preserve_span);
+    bool DoStep();
+    std::chrono::milliseconds MutatePeriod(std::chrono::milliseconds period);
+    std::string_view GetName() const noexcept;
+    void SuspendDebug();
+    void ResumeDebug();
+};
+
 bool PeriodicTask::Settings::operator==(const Settings& other) const noexcept {
     return TieSettings(*this) == TieSettings(other);
 }
@@ -36,58 +72,59 @@ bool PeriodicTask::Settings::operator!=(const Settings& other) const noexcept {
     return TieSettings(*this) != TieSettings(other);
 }
 
-PeriodicTask::PeriodicTask() : settings_(std::chrono::seconds(1)), suspend_state_(SuspendState::kRunning) {}
+PeriodicTask::PeriodicTask() : impl_() {}
 
-PeriodicTask::PeriodicTask(std::string name, Settings settings, Callback callback)
-    : name_(std::move(name)),
-      is_name_set_(true),
-      callback_(std::move(callback)),
-      settings_(std::move(settings)),
-      suspend_state_(SuspendState::kRunning) {
-    DoStart();
+PeriodicTask::PeriodicTask(std::string name, Settings settings, Callback callback) : impl_() {
+    impl_->name = std::move(name);
+    impl_->is_name_set = true;
+    impl_->callback = std::move(callback);
+    impl_->settings.Assign(std::move(settings));
+    impl_->suspend_state = Impl::SuspendState::kRunning;
+    impl_->DoStart();
 }
 
 PeriodicTask::~PeriodicTask() {
-    registration_holder_ = std::nullopt;
+    impl_->registration_holder = std::nullopt;
     Stop();
 }
 
 void PeriodicTask::Start(std::string name, Settings settings, Callback callback) {
     UASSERT_MSG(!name.empty(), "Periodic task must have a name");
-    auto settings_ptr = settings_.StartWriteEmplace(std::move(settings));
+    auto settings_ptr = impl_->settings.StartWriteEmplace(std::move(settings));
     // Set name_ under the 'settings_' mutex.
-    if (!is_name_set_) {
-        name_ = std::move(name);
-        is_name_set_ = true;
+    if (!impl_->is_name_set) {
+        impl_->name = std::move(name);
+        impl_->is_name_set = true;
     } else {
         UINVARIANT(
-            name_ == name, fmt::format("PeriodicTask name must not be changed on the fly, old={}, new={}", name_, name)
+            impl_->name == name,
+            fmt::format("PeriodicTask name must not be changed on the fly, old={}, new={}", impl_->name, name)
         );
     }
     // Stop here so that if the invariant above fails, the task is not affected.
     Stop();
-    callback_ = std::move(callback);
+    impl_->callback = std::move(callback);
     settings_ptr.Commit();
-    DoStart();
+    impl_->DoStart();
 }
 
-void PeriodicTask::DoStart() {
+void PeriodicTask::Impl::DoStart() {
     LOG_DEBUG() << "Starting PeriodicTask with name=" << GetName();
-    auto settings_ptr = settings_.Read();
+    auto settings_ptr = settings.Read();
     auto& task_processor =
         settings_ptr->task_processor ? *settings_ptr->task_processor : engine::current_task::GetTaskProcessor();
-    task_ = engine::CriticalAsyncNoSpan(task_processor, &PeriodicTask::Run, this);
+    task = engine::CriticalAsyncNoSpan(task_processor, &PeriodicTask::Impl::Run, this);
 }
 
 void PeriodicTask::Stop() noexcept {
-    const auto name = GetName();
+    const auto name = impl_->GetName();
     try {
         if (IsRunning()) {
             LOG_INFO() << "Stopping PeriodicTask with name=" << name;
-            task_.SyncCancel();
-            changed_event_.Reset();
-            should_force_step_ = false;
-            task_ = engine::TaskWithResult<void>();
+            impl_->task.SyncCancel();
+            impl_->changed_event.Reset();
+            impl_->should_force_step = false;
+            impl_->task = engine::TaskWithResult<void>();
             LOG_INFO() << "Stopped PeriodicTask with name=" << name;
         }
     } catch (std::exception& e) {
@@ -100,7 +137,7 @@ void PeriodicTask::Stop() noexcept {
 void PeriodicTask::SetSettings(Settings settings) {
     bool should_notify_task{};
     {
-        auto writer = settings_.StartWrite();
+        auto writer = impl_->settings.StartWrite();
         if (settings == *writer) {
             // Updating an RCU is slow, better to avoid it when possible.
             return;
@@ -112,14 +149,14 @@ void PeriodicTask::SetSettings(Settings settings) {
     }
 
     if (should_notify_task) {
-        LOG_DEBUG() << "periodic task settings have changed, signalling name=" << GetName();
-        changed_event_.Send();
+        LOG_DEBUG() << "periodic task settings have changed, signalling name=" << impl_->GetName();
+        impl_->changed_event.Send();
     }
 }
 
 void PeriodicTask::ForceStepAsync() {
-    should_force_step_ = true;
-    changed_event_.Send();
+    impl_->should_force_step = true;
+    impl_->changed_event.Send();
 }
 
 bool PeriodicTask::SynchronizeDebug(bool preserve_span) {
@@ -127,16 +164,16 @@ bool PeriodicTask::SynchronizeDebug(bool preserve_span) {
         return false;
     }
 
-    return StepDebug(preserve_span);
+    return impl_->StepDebug(preserve_span);
 }
 
-bool PeriodicTask::IsRunning() const { return task_.IsValid(); }
+bool PeriodicTask::IsRunning() const { return impl_->task.IsValid(); }
 
-void PeriodicTask::Run() {
+void PeriodicTask::Impl::Run() {
     bool skip_step = false;
     {
-        auto settings = settings_.Read();
-        if (!(settings->flags & Flags::kNow)) {
+        auto l_settings = settings.Read();
+        if (!(l_settings->flags & Flags::kNow)) {
             skip_step = true;
         }
     }
@@ -149,40 +186,40 @@ void PeriodicTask::Run() {
             no_exception = Step();
         }
 
-        const auto settings = settings_.Read();
-        auto period = settings->period;
-        const auto exception_period = settings->exception_period.value_or(period);
+        const auto l_settings = settings.Read();
+        auto period = l_settings->period;
+        const auto exception_period = l_settings->exception_period.value_or(period);
 
         if (!no_exception) period = exception_period;
 
         std::chrono::steady_clock::time_point start;
-        if (settings->flags & Flags::kStrong) {
+        if (l_settings->flags & Flags::kStrong) {
             start = before;
         } else {
             start = std::chrono::steady_clock::now();
         }
 
-        while (changed_event_.WaitForEventUntil(start + MutatePeriod(period))) {
-            if (should_force_step_.exchange(false)) {
+        while (changed_event.WaitForEventUntil(start + MutatePeriod(period))) {
+            if (should_force_step.exchange(false)) {
                 break;
             }
             // The config variable value has been changed, reload
-            const auto settings = settings_.Read();
-            period = settings->period;
-            const auto exception_period = settings->exception_period.value_or(period);
+            const auto l_settings = settings.Read();
+            period = l_settings->period;
+            const auto exception_period = l_settings->exception_period.value_or(period);
             if (!no_exception) period = exception_period;
         }
     }
 }
 
-bool PeriodicTask::DoStep() {
-    auto settings_ptr = settings_.Read();
+bool PeriodicTask::Impl::DoStep() {
+    auto settings_ptr = settings.Read();
     const auto span_log_level = settings_ptr->span_level;
     const auto name = GetName();
     tracing::Span span(std::string{name});
     span.SetLogLevel(span_log_level);
     try {
-        callback_();
+        callback();
         return true;
     } catch (const std::exception& e) {
         LOG_ERROR() << "Exception in PeriodicTask with name=" << name << ": " << e;
@@ -190,10 +227,10 @@ bool PeriodicTask::DoStep() {
     }
 }
 
-bool PeriodicTask::Step() {
-    const std::lock_guard lock_step(step_mutex_);
+bool PeriodicTask::Impl::Step() {
+    const std::lock_guard lock_step(step_mutex);
 
-    if (suspend_state_.load() == SuspendState::kSuspended) {
+    if (suspend_state.load() == SuspendState::kSuspended) {
         LOG_INFO() << "Skipping suspended PeriodicTask with name=" << GetName();
         return true;
     }
@@ -201,8 +238,8 @@ bool PeriodicTask::Step() {
     return DoStep();
 }
 
-bool PeriodicTask::StepDebug(bool preserve_span) {
-    const std::lock_guard lock_step(step_mutex_);
+bool PeriodicTask::Impl::StepDebug(bool preserve_span) {
+    const std::lock_guard lock_step(step_mutex);
 
     std::optional<tracing::Span> testsuite_oneshot_span;
     if (preserve_span) {
@@ -213,49 +250,53 @@ bool PeriodicTask::StepDebug(bool preserve_span) {
     return DoStep();
 }
 
-std::chrono::milliseconds PeriodicTask::MutatePeriod(std::chrono::milliseconds period) {
-    auto settings_ptr = settings_.Read();
+std::chrono::milliseconds PeriodicTask::Impl::MutatePeriod(std::chrono::milliseconds period) {
+    auto settings_ptr = settings.Read();
     if (!(settings_ptr->flags & Flags::kChaotic)) return period;
 
-    if (!mutate_period_random_) {
-        mutate_period_random_.emplace(
+    if (!mutate_period_random) {
+        mutate_period_random.emplace(
             utils::WithDefaultRandom(std::uniform_int_distribution<std::minstd_rand::result_type>{})
         );
     }
 
     const auto jitter = settings_ptr->distribution;
     std::uniform_int_distribution distribution{(period - jitter).count(), (period + jitter).count()};
-    const auto ms = distribution(*mutate_period_random_);
+    const auto ms = distribution(*mutate_period_random);
     return std::chrono::milliseconds(ms);
 }
 
-std::string_view PeriodicTask::GetName() const noexcept {
-    return is_name_set_ ? std::string_view{name_} : "<name not set>";
+std::string_view PeriodicTask::Impl::GetName() const noexcept {
+    return is_name_set ? std::string_view{name} : "<name not set>";
 }
 
-void PeriodicTask::SuspendDebug() {
+void PeriodicTask::SuspendDebug() { impl_->SuspendDebug(); }
+
+void PeriodicTask::ResumeDebug() { impl_->ResumeDebug(); }
+
+void PeriodicTask::Impl::SuspendDebug() {
     // step_mutex_ waits, for a potentially long time, for Step() call completion
-    const std::lock_guard lock_step(step_mutex_);
-    auto prior_state = suspend_state_.exchange(SuspendState::kSuspended);
+    const std::lock_guard lock_step(step_mutex);
+    auto prior_state = suspend_state.exchange(SuspendState::kSuspended);
     if (prior_state != SuspendState::kSuspended) {
         LOG_DEBUG() << "Periodic task " << GetName() << " suspended";
     }
 }
 
-void PeriodicTask::ResumeDebug() {
-    auto prior_state = suspend_state_.exchange(SuspendState::kRunning);
+void PeriodicTask::Impl::ResumeDebug() {
+    auto prior_state = suspend_state.exchange(SuspendState::kRunning);
     if (prior_state != SuspendState::kRunning) {
         LOG_DEBUG() << "Periodic task " << GetName() << " resumed";
     }
 }
 
 void PeriodicTask::RegisterInTestsuite(testsuite::PeriodicTaskControl& periodic_task_control) {
-    UINVARIANT(is_name_set_, "PeriodicTask::RegisterInTestsuite should be called after Start");
-    registration_holder_.emplace(periodic_task_control, std::string{GetName()}, *this);
+    UINVARIANT(impl_->is_name_set, "PeriodicTask::RegisterInTestsuite should be called after Start");
+    impl_->registration_holder.emplace(periodic_task_control, std::string{impl_->GetName()}, *this);
 }
 
 PeriodicTask::Settings PeriodicTask::GetCurrentSettings() const {
-    auto settings_ptr = settings_.Read();
+    auto settings_ptr = impl_->settings.Read();
     return *settings_ptr;
 }
 
diff --git a/core/src/utils/periodic_task_test.cpp b/core/src/utils/periodic_task_test.cpp
index ca1d58d83067..8a4c09308103 100644
--- a/core/src/utils/periodic_task_test.cpp
+++ b/core/src/utils/periodic_task_test.cpp
@@ -7,6 +7,7 @@
 #include <userver/engine/mutex.hpp>
 #include <userver/engine/sleep.hpp>
 #include <userver/logging/log.hpp>
+#include <userver/tracing/span.hpp>
 #include <userver/utils/periodic_task.hpp>
 
 using namespace std::chrono_literals;
diff --git a/core/src/utils/statistics/busy.cpp b/core/src/utils/statistics/busy.cpp
index 6e50749a836e..8b0b0fcfec94 100644
--- a/core/src/utils/statistics/busy.cpp
+++ b/core/src/utils/statistics/busy.cpp
@@ -49,30 +49,30 @@ struct BusyStorage::Impl {
 };
 
 BusyStorage::BusyStorage(Duration epoch_duration, Duration history_period)
-    : pimpl(std::make_unique<Impl>(epoch_duration, history_period)) {}
+    : pimpl_(std::make_unique<Impl>(epoch_duration, history_period)) {}
 
 BusyStorage::~BusyStorage() { UASSERT_MSG(!IsAlreadyStarted(), "BusyStorage was not stopped before destruction"); }
 
 double BusyStorage::GetCurrentLoad() const {
-    pimpl->recent_period.UpdateEpochIfOld();
+    pimpl_->recent_period.UpdateEpochIfOld();
 
     const Duration current_load_duration = GetNotCommittedLoad();
 
-    const auto result = pimpl->recent_period.GetStatsForPeriod(Timer::duration::min(), true);
+    const auto result = pimpl_->recent_period.GetStatsForPeriod(Timer::duration::min(), true);
     auto duration = result.Total();
-    if (duration.count() == 0) duration = pimpl->recent_period.GetMaxDuration();
+    if (duration.count() == 0) duration = pimpl_->recent_period.GetMaxDuration();
 
     auto load_duration = result.Get() + std::min(current_load_duration, duration);
     return static_cast<double>(load_duration.count()) / duration.count();
 }
 
-bool BusyStorage::IsAlreadyStarted() const noexcept { return pimpl->refcount.load() != 0; }
+bool BusyStorage::IsAlreadyStarted() const noexcept { return pimpl_->refcount.load() != 0; }
 
 void BusyStorage::StartWork() {
-    if (++pimpl->refcount != 1) {
+    if (++pimpl_->refcount != 1) {
 #ifndef NDEBUG
         UASSERT_MSG(
-            pimpl->thread_id.load() == std::this_thread::get_id(),
+            pimpl_->thread_id.load() == std::this_thread::get_id(),
             "BusyStorage should be started and stopped at the same thread"
         );
 #endif
@@ -80,19 +80,19 @@ void BusyStorage::StartWork() {
     }
 
 #ifndef NDEBUG
-    pimpl->thread_id = std::this_thread::get_id();
+    pimpl_->thread_id = std::this_thread::get_id();
 #endif
 
-    pimpl->start_work = utils::datetime::SteadyNow();
+    pimpl_->start_work = utils::datetime::SteadyNow();
 }
 
 void BusyStorage::StopWork() noexcept {
-    const auto refcount_snapshot = pimpl->refcount--;
+    const auto refcount_snapshot = pimpl_->refcount--;
     UASSERT_MSG(refcount_snapshot != 0, "Stop was called more times than start");
     if (refcount_snapshot != 1) {
 #ifndef NDEBUG
         UASSERT_MSG(
-            pimpl->thread_id.load() == std::this_thread::get_id(),
+            pimpl_->thread_id.load() == std::this_thread::get_id(),
             "BusyStorage should be started and stopped at the same thread"
         );
 #endif
@@ -100,14 +100,14 @@ void BusyStorage::StopWork() noexcept {
     }
 
     auto not_committed_load = GetNotCommittedLoad();
-    auto& value = pimpl->recent_period.GetCurrentCounter().value;
+    auto& value = pimpl_->recent_period.GetCurrentCounter().value;
     value = value.load() + not_committed_load;
 
-    pimpl->start_work = Timer::time_point{};
+    pimpl_->start_work = Timer::time_point{};
 }
 
 Duration BusyStorage::GetNotCommittedLoad() const noexcept {
-    const auto start_work = pimpl->start_work.load();
+    const auto start_work = pimpl_->start_work.load();
     if (start_work == Timer::time_point{}) {
         return Duration(0);
     } else {
diff --git a/core/src/utils/statistics/min_max_avg_test.cpp b/core/src/utils/statistics/min_max_avg_test.cpp
index 4e94aba3c5dc..c3f97c78cf21 100644
--- a/core/src/utils/statistics/min_max_avg_test.cpp
+++ b/core/src/utils/statistics/min_max_avg_test.cpp
@@ -18,10 +18,10 @@ constexpr auto kStressTestDuration = std::chrono::milliseconds{500};
 
 static_assert(utils::statistics::kHasWriterSupport<utils::statistics::MinMaxAvg<int>>);
 
-template <int... values>
+template <int... Values>
 auto GetFilledMma() {
     utils::statistics::MinMaxAvg<int> mma;
-    (mma.Account(values), ...);
+    (mma.Account(Values), ...);
     return mma;
 }
 
diff --git a/core/src/utils/statistics/visitation.cpp b/core/src/utils/statistics/visitation.cpp
index 034873171af8..cd8fd9e1bea0 100644
--- a/core/src/utils/statistics/visitation.cpp
+++ b/core/src/utils/statistics/visitation.cpp
@@ -116,16 +116,11 @@ class DfsLabelsBag {
 };
 
 struct DfsNode {
-    DfsNode(
-        const formats::json::Value& next,
-        std::string&& path_node_,
-        Label&& label_,
-        std::string&& children_label_name_
-    )
+    DfsNode(const formats::json::Value& next, std::string&& path_node, Label&& label, std::string&& children_label_name)
         : current(next),
-          path_node(std::move(path_node_)),
-          label(std::move(label_)),
-          children_label_name(std::move(children_label_name_)) {}
+          path_node(std::move(path_node)),
+          label(std::move(label)),
+          children_label_name(std::move(children_label_name)) {}
 
     bool is_in_subtree{false};
     const formats::json::Value current;
diff --git a/core/src/utils/trx_tracker.cpp b/core/src/utils/trx_tracker.cpp
new file mode 100644
index 000000000000..9b59f9317223
--- /dev/null
+++ b/core/src/utils/trx_tracker.cpp
@@ -0,0 +1,161 @@
+#include <userver/utils/trx_tracker.hpp>
+
+#include <userver/compiler/thread_local.hpp>
+#include <userver/engine/task/local_variable.hpp>
+#include <userver/formats/json.hpp>
+#include <userver/logging/log.hpp>
+#include <userver/testsuite/testpoint.hpp>
+#include <userver/utils/function_ref.hpp>
+#include <userver/utils/statistics/rate_counter.hpp>
+#include <userver/utils/statistics/writer.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace utils::trx_tracker {
+
+namespace {
+
+compiler::ThreadLocal local_task_counter = []() -> std::uint64_t { return 0; };
+
+struct TransactionTracker final {
+    std::uint32_t trx_count = 0;
+    std::uint32_t disabler_count = 0;
+    impl::TaskId task_id;
+};
+
+struct TransactionTrackerStatisticsInternal final {
+    utils::statistics::RateCounter triggers{0};
+};
+
+engine::TaskLocalVariable<TransactionTracker> transaction_tracker{};
+TransactionTrackerStatisticsInternal transaction_tracker_statistics{};
+
+void CheckNoTransactions(utils::function_ref<std::string()> get_location) {
+    if (!impl::IsEnabled()) {
+        return;
+    }
+
+    auto* tracker = transaction_tracker.GetOptional();
+    if (tracker && !tracker->disabler_count && tracker->trx_count > 0) {
+        const std::string location = get_location();
+        logging::LogExtra log_extra;
+        log_extra.Extend("location", location);
+        LOG_LIMITED_WARNING() << "Long call while having active transactions" << std::move(log_extra);
+        ++transaction_tracker_statistics.triggers;
+
+        TESTPOINT("long_call_in_trx", [&location] {
+            formats::json::ValueBuilder builder;
+            builder["location"] = location;
+            return builder.ExtractValue();
+        }());
+    }
+}
+
+std::optional<impl::TaskId> StartTransaction() {
+    if (impl::IsEnabled()) {
+        ++transaction_tracker->trx_count;
+        return transaction_tracker->task_id;
+    }
+    return std::nullopt;
+}
+
+bool EndTransaction(const impl::TaskId& task_id) noexcept {
+    if (impl::IsEnabled()) {
+        if (transaction_tracker.GetOptional() == nullptr || transaction_tracker->task_id != task_id) {
+            // EndTransaction is called in different task than StartTransaction
+            return false;
+        }
+        --transaction_tracker->trx_count;
+        return true;
+    }
+    return true;
+}
+
+bool trx_tracker_enabled = false;
+bool trx_tracker_enabler_exists = false;
+
+}  // namespace
+
+namespace impl {
+
+GlobalEnabler::GlobalEnabler(bool enable) {
+    UASSERT(!trx_tracker_enabler_exists);
+    trx_tracker_enabled = enable;
+    trx_tracker_enabler_exists = true;
+}
+
+GlobalEnabler::~GlobalEnabler() {
+    trx_tracker_enabled = false;
+    trx_tracker_enabler_exists = false;
+}
+
+bool IsEnabled() noexcept { return trx_tracker_enabled; }
+
+TaskId::TaskId() : created_thread_id_{std::this_thread::get_id()} {
+    auto counter_scope{local_task_counter.Use()};
+    thread_local_counter_ = (*counter_scope)++;
+}
+
+bool TaskId::operator==(const TaskId& other) const {
+    return created_thread_id_ == other.created_thread_id_ && thread_local_counter_ == other.thread_local_counter_;
+}
+
+bool TaskId::operator!=(const TaskId& other) const { return !(*this == other); }
+
+}  // namespace impl
+
+TransactionLock::~TransactionLock() { Unlock(); }
+
+void TransactionLock::Lock() noexcept {
+    if (!task_id_.has_value()) {
+        task_id_ = StartTransaction();
+    }
+}
+
+void TransactionLock::Unlock() noexcept {
+    if (task_id_.has_value() && EndTransaction(task_id_.value())) {
+        task_id_ = std::nullopt;
+    }
+}
+
+TransactionLock::TransactionLock(TransactionLock&& other) noexcept
+    : task_id_(std::exchange(other.task_id_, std::nullopt)) {}
+
+TransactionLock& TransactionLock::operator=(TransactionLock&& other) noexcept {
+    if (&other == this) {
+        return *this;
+    }
+
+    Unlock();
+    task_id_ = std::exchange(other.task_id_, std::nullopt);
+    return *this;
+}
+
+void CheckNoTransactions(utils::impl::SourceLocation location) {
+    CheckNoTransactions([&location]() { return utils::impl::ToString(location); });
+}
+
+void CheckNoTransactions(std::string_view location) {
+    CheckNoTransactions([&location]() { return std::string(location); });
+}
+
+TransactionTrackerStatistics GetStatistics() noexcept {
+    return TransactionTrackerStatistics{transaction_tracker_statistics.triggers.Load()};
+}
+
+void ResetStatistics() { utils::statistics::ResetMetric(transaction_tracker_statistics.triggers); }
+
+CheckDisabler::CheckDisabler() { ++transaction_tracker->disabler_count; }
+
+CheckDisabler::~CheckDisabler() { Reenable(); }
+
+void CheckDisabler::Reenable() noexcept {
+    if (!reenabled_) {
+        --transaction_tracker->disabler_count;
+        reenabled_ = true;
+    }
+}
+
+}  // namespace utils::trx_tracker
+
+USERVER_NAMESPACE_END
diff --git a/core/src/utils/trx_tracker_test.cpp b/core/src/utils/trx_tracker_test.cpp
new file mode 100644
index 000000000000..2b94392045e1
--- /dev/null
+++ b/core/src/utils/trx_tracker_test.cpp
@@ -0,0 +1,308 @@
+#include <userver/utils/trx_tracker.hpp>
+
+#include <gmock/gmock.h>
+
+#include <userver/logging/log.hpp>
+#include <userver/utest/log_capture_fixture.hpp>
+#include <userver/utest/utest.hpp>
+#include <userver/utils/async.hpp>
+#include <userver/utils/statistics/writer.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+utils::statistics::Rate GetTriggers() { return utils::trx_tracker::GetStatistics().triggers; }
+
+using TrxTrackerFixture = utest::LogCaptureFixture<>;
+
+}  // namespace
+
+UTEST_F(TrxTrackerFixture, AssertInTransaction) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    /// [Sample TransactionTracker usage]
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(utils::trx_tracker::GetStatistics().triggers, 1);
+    EXPECT_THAT(GetLogCapture().Filter("Long call while having active transactions"), testing::SizeIs(1));
+    /// [Sample TransactionTracker usage]
+}
+
+UTEST(TrxTracker, AssertTwoInTransaction) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(GetTriggers(), 2);
+}
+
+UTEST(TrxTracker, AssertOutOfTransaction) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    trx.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 0);
+}
+
+UTEST(TrxTracker, UnlockOnDestruction) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    {
+        utils::trx_tracker::TransactionLock trx{};
+        trx.Lock();
+        utils::trx_tracker::CheckNoTransactions();
+    }
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, AssertNestedTransactions) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx_1{};
+    trx_1.Lock();
+    utils::trx_tracker::TransactionLock trx_2{};
+    trx_2.Lock();
+    trx_2.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx_1.Unlock();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, CopyConstructorLocked) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::TransactionLock trx_copy{std::move(trx)};
+    utils::trx_tracker::CheckNoTransactions();
+    trx_copy.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, CopyConstructorUnlocked) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+    utils::trx_tracker::TransactionLock trx_copy{std::move(trx)};
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, CopyAssignmentLockedToLocked) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx_1{};
+    trx_1.Lock();
+    utils::trx_tracker::TransactionLock trx_2{};
+    trx_2.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx_2 = std::move(trx_1);
+    utils::trx_tracker::CheckNoTransactions();
+    trx_2.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 2);
+}
+
+UTEST(TrxTracker, CopyAssignmentLockedToUnlocked) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx_1{};
+    trx_1.Lock();
+    utils::trx_tracker::TransactionLock trx_2{};
+    utils::trx_tracker::CheckNoTransactions();
+    trx_2 = std::move(trx_1);
+    utils::trx_tracker::CheckNoTransactions();
+    trx_2.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 2);
+}
+
+UTEST(TrxTracker, CopyAssignmentUnlockedToLocked) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx_1{};
+    utils::trx_tracker::TransactionLock trx_2{};
+    trx_2.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx_2 = std::move(trx_1);
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, CopyAssignmentUnlockedToUnlocked) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx_1{};
+    utils::trx_tracker::TransactionLock trx_2{};
+    trx_2 = std::move(trx_1);
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 0);
+}
+
+UTEST(TrxTracker, CopyAssignmentSelf) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    auto& trx_ref = trx;
+    trx = std::move(trx_ref);
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, AssertWithDisabler) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    const utils::trx_tracker::CheckDisabler disabler;
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(GetTriggers(), 0);
+}
+
+UTEST(TrxTracker, AssertDisablerReenabled) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::CheckDisabler disabler;
+    utils::trx_tracker::CheckNoTransactions();
+    disabler.Reenable();
+    utils::trx_tracker::CheckNoTransactions(utils::impl::SourceLocation::Current());
+    trx.Unlock();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, AssertDisablerDestroyed) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    {
+        const utils::trx_tracker::CheckDisabler disabler;
+        utils::trx_tracker::CheckNoTransactions();
+    }
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, AssertMultipleDisablers) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    const utils::trx_tracker::CheckDisabler disabler;
+    {
+        const utils::trx_tracker::CheckDisabler disabler;
+        utils::trx_tracker::CheckNoTransactions();
+    }
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(GetTriggers(), 0);
+}
+
+UTEST(TrxTracker, NoGlobalEnabler) {
+    utils::trx_tracker::ResetStatistics();
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(utils::trx_tracker::GetStatistics().triggers, 0);
+}
+
+UTEST(TrxTracker, GlobalEnablerFalse) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler(false);
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+
+    EXPECT_EQ(utils::trx_tracker::GetStatistics().triggers, 0);
+}
+
+UTEST(TrxTracker, UnlockInAsync) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    utils::trx_tracker::TransactionLock trx{};
+    trx.Lock();
+    auto task = utils::Async("", [&trx]() { trx.Unlock(); });
+    task.Get();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 1);
+}
+
+UTEST(TrxTracker, LockInAsync) {
+    utils::trx_tracker::ResetStatistics();
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    auto task = utils::Async("", []() {
+        utils::trx_tracker::TransactionLock trx{};
+        trx.Lock();
+        return trx;
+    });
+    auto trx = task.Get();
+    utils::trx_tracker::CheckNoTransactions();
+    trx.Unlock();
+    utils::trx_tracker::CheckNoTransactions();
+
+    EXPECT_EQ(GetTriggers(), 0);
+}
+
+USERVER_NAMESPACE_END
diff --git a/core/utest/src/utest/test_case_macros.cpp b/core/utest/src/utest/test_case_macros.cpp
index df98a19e47a2..ef2b9ff5cfe6 100644
--- a/core/utest/src/utest/test_case_macros.cpp
+++ b/core/utest/src/utest/test_case_macros.cpp
@@ -89,14 +89,6 @@ void DoRunTest(
     });
 }
 
-bool IsStackUsageMonitorEnabled() {
-    // NOLINTNEXTLINE(concurrency-mt-unsafe)
-    auto* enable = std::getenv("USERVER_GTEST_ENABLE_STACK_USAGE_MONITOR");
-    if (!enable) return true;
-    if (std::string_view(enable) == "0") return false;
-    return true;
-}
-
 }  // namespace
 
 void DoRunTest(
@@ -115,7 +107,6 @@ void DoRunTest(
         // work with gtest's `waitpid()` calls.
         config.ev_default_loop_disabled = true;
     }
-    config.is_stack_usage_monitor_enabled = IsStackUsageMonitorEnabled();
     return DoRunTest(thread_count, config, std::move(factory));
 }
 
diff --git a/grpc/CMakeLists.txt b/grpc/CMakeLists.txt
index 4c8fe7b6f342..ee9d170823c5 100644
--- a/grpc/CMakeLists.txt
+++ b/grpc/CMakeLists.txt
@@ -197,3 +197,5 @@ _userver_directory_install(
     FILES "${USERVER_ROOT_DIR}/cmake/modules/FindUserverGrpc.cmake"
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/userver/modules
 )
+
+_userver_install_component(MODULE grpc DEPENDS core)
diff --git a/grpc/benchmarks/format_log_message.cpp b/grpc/benchmarks/format_log_message.cpp
index 5b3cfb1e4a5b..03d7b1447d9e 100644
--- a/grpc/benchmarks/format_log_message.cpp
+++ b/grpc/benchmarks/format_log_message.cpp
@@ -1,5 +1,6 @@
 #include <ugrpc/server/impl/format_log_message.hpp>
 
+#include <userver/logging/log_extra.hpp>
 #include <userver/utils/assert.hpp>
 #include <userver/utils/text_light.hpp>
 
@@ -20,25 +21,28 @@ void FormatLogMessage(benchmark::State& state) {
     // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
     for (auto _ : state) {
         auto result =
-            ugrpc::server::impl::FormatLogMessage(metadata, peer, start_time, call_name, grpc::StatusCode::OK);
+            ugrpc::server::impl::FormatLogMessage(metadata, peer, start_time, call_name, grpc::StatusCode::OK, nullptr);
         benchmark::DoNotOptimize(result);
     }
 
-    auto result = ugrpc::server::impl::FormatLogMessage(metadata, peer, start_time, call_name, grpc::StatusCode::OK);
+    auto result =
+        ugrpc::server::impl::FormatLogMessage(metadata, peer, start_time, call_name, grpc::StatusCode::OK, nullptr);
 
-    UINVARIANT(utils::text::StartsWith(result, "tskv\ttimestamp=1971-05-"), "Fail");
-    UINVARIANT(result.find("\ttimezone=") != std::string::npos, "Fail 1");
+    const std::string_view log_line_view{result.ExtractTextLogItem().log_line};  // Convert SmallString to string_view
+
+    UINVARIANT(utils::text::StartsWith(log_line_view, "tskv\ttimestamp=1971-05-"), "Fail");
+    UINVARIANT(log_line_view.find("\ttimezone=") != std::string::npos, "Fail 1");
     UINVARIANT(
-        result.find("\tuser_agent=grpc-go/1.45.0\t"
-                    "ip=2a02:aaaa:aaaa:aaaa::1:1f\t"
-                    "x_real_ip=2a02:aaaa:aaaa:aaaa::1:1f\t"
-                    "request=hello.HelloService/SayHello\t"
-                    "request_time=") != std::string::npos,
+        log_line_view.find("\tuser_agent=grpc-go/1.45.0\t"
+                           "ip=2a02:aaaa:aaaa:aaaa::1:1f\t"
+                           "x_real_ip=2a02:aaaa:aaaa:aaaa::1:1f\t"
+                           "request=hello.HelloService/SayHello\t"
+                           "request_time=") != std::string::npos,
         "Fail 2"
     );
 
-    UINVARIANT(result.find("\tgrpc_status=0\t") != std::string::npos, "Fail 3");
-    UINVARIANT(result.find("\tgrpc_status_code=OK\n") != std::string::npos, "Fail 4");
+    UINVARIANT(log_line_view.find("\tgrpc_status=0\t") != std::string::npos, "Fail 3");
+    UINVARIANT(log_line_view.find("\tgrpc_status_code=OK\n") != std::string::npos, "Fail 4");
 }
 
 BENCHMARK(FormatLogMessage);
diff --git a/grpc/benchmarks/logging.cpp b/grpc/benchmarks/logging.cpp
index b5ebe6b97227..3e13cb8397bd 100644
--- a/grpc/benchmarks/logging.cpp
+++ b/grpc/benchmarks/logging.cpp
@@ -1,9 +1,8 @@
 #include <benchmark/benchmark.h>
 
+#include <userver/ugrpc/protobuf_logging.hpp>
 #include <userver/utils/log.hpp>
 
-#include <ugrpc/impl/protobuf_utils.hpp>
-
 #include <tests/logging.pb.h>
 
 USERVER_NAMESPACE_BEGIN
@@ -53,7 +52,7 @@ void BenchCustomLimit(benchmark::State& state) {
     // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
     for (auto _ : state) {
         {
-            auto log = impl::ToLimitedDebugString(kMessage, 1024);
+            auto log = ugrpc::ToLimitedDebugString(kMessage, 1024);
             benchmark::DoNotOptimize(log);
         }
     }
diff --git a/grpc/dynamic_configs/EGRESS_GRPC_PROXY_ENABLED.yaml b/grpc/dynamic_configs/EGRESS_GRPC_PROXY_ENABLED.yaml
new file mode 100644
index 000000000000..35ff566e5c41
--- /dev/null
+++ b/grpc/dynamic_configs/EGRESS_GRPC_PROXY_ENABLED.yaml
@@ -0,0 +1,4 @@
+default: false
+description: ''
+schema:
+    type: boolean
diff --git a/grpc/functional_tests/basic_chaos/client.hpp b/grpc/functional_tests/basic_chaos/client.hpp
index 41574e798b58..0a9f9e17d40b 100644
--- a/grpc/functional_tests/basic_chaos/client.hpp
+++ b/grpc/functional_tests/basic_chaos/client.hpp
@@ -9,6 +9,7 @@
 
 #include <userver/ugrpc/client/client_factory_component.hpp>
 #include <userver/ugrpc/client/impl/client_data.hpp>
+#include <userver/ugrpc/client/impl/client_data_accessor.hpp>
 #include <userver/ugrpc/client/simple_client_component.hpp>
 
 #include <samples/greeter_client.usrv.pb.hpp>
@@ -31,7 +32,7 @@ class GreeterClient final : public components::ComponentBase {
         // Tests dedicated-channel-count from SimpleClientComponent
         auto& client =
             context.FindComponent<ugrpc::client::SimpleClientComponent<Client>>("greeter-client-component").GetClient();
-        const auto& data = ugrpc::client::impl::GetClientData(client);
+        const auto& data = ugrpc::client::impl::ClientDataAccessor::GetClientData(client);
         const auto stub_state = data.GetStubState();
         UASSERT(stub_state->dedicated_stubs[0].Size() == 3);
         UASSERT(stub_state->dedicated_stubs[1].Size() == 0);
diff --git a/grpc/functional_tests/basic_chaos/tests-grpcserver/requests_server.py b/grpc/functional_tests/basic_chaos/tests-grpcserver/requests_server.py
index 8deb47c67435..adbca613484b 100644
--- a/grpc/functional_tests/basic_chaos/tests-grpcserver/requests_server.py
+++ b/grpc/functional_tests/basic_chaos/tests-grpcserver/requests_server.py
@@ -2,7 +2,6 @@
 import logging
 
 import grpc
-import pytest
 
 import samples.greeter_pb2 as greeter_pb2  # noqa: E402, E501
 
@@ -26,35 +25,6 @@ async def _say_hello(grpc_client, gate):
     assert gate.connections_count() > 0
 
 
-@pytest.mark.parametrize(
-    'metadata,logs,',
-    [
-        [(('x-yatraceid', 'traceid'),), {'trace_id': 'traceid'}],
-        [
-            (('x-yatraceid', 'traceid'), ('x-yaspanid', 'span')),
-            {'trace_id': 'traceid', 'parent_id': 'span'},
-        ],
-    ],
-)
-async def test_tracing_metadata(
-    grpc_client,
-    service_client,
-    gate,
-    metadata,
-    logs,
-):
-    request = greeter_pb2.GreetingRequest(name='Python')
-    async with service_client.capture_logs() as capture:
-        response = await grpc_client.SayHello(
-            request,
-            wait_for_ready=True,
-            metadata=metadata,
-        )
-        assert response.greeting == 'Hello, Python!'
-
-    assert capture.select(**logs)
-
-
 async def _say_hello_response_stream(grpc_client, gate):
     request = greeter_pb2.GreetingRequest(name='Python')
     reference = '!'
diff --git a/grpc/functional_tests/basic_chaos/tests-grpcserver/test_tracing_metadata.py b/grpc/functional_tests/basic_chaos/tests-grpcserver/test_tracing_metadata.py
new file mode 100644
index 000000000000..20a0f3fb2e4d
--- /dev/null
+++ b/grpc/functional_tests/basic_chaos/tests-grpcserver/test_tracing_metadata.py
@@ -0,0 +1,32 @@
+import pytest
+
+import samples.greeter_pb2 as greeter_pb2  # noqa: E402, E501
+
+
+@pytest.mark.parametrize(
+    'metadata,logs,',
+    [
+        [(('x-yatraceid', 'traceid'),), {'trace_id': 'traceid'}],
+        [
+            (('x-yatraceid', 'traceid'), ('x-yaspanid', 'span')),
+            {'trace_id': 'traceid', 'parent_id': 'span'},
+        ],
+    ],
+)
+async def test_tracing_metadata(
+    grpc_client,
+    service_client,
+    gate,
+    metadata,
+    logs,
+):
+    request = greeter_pb2.GreetingRequest(name='Python')
+    async with service_client.capture_logs() as capture:
+        response = await grpc_client.SayHello(
+            request,
+            wait_for_ready=True,
+            metadata=metadata,
+        )
+        assert response.greeting == 'Hello, Python!'
+
+    assert capture.select(**logs)
diff --git a/grpc/functional_tests/basic_server/CMakeLists.txt b/grpc/functional_tests/basic_server/CMakeLists.txt
index 9c50d101bf5b..e35b2f8642b8 100644
--- a/grpc/functional_tests/basic_server/CMakeLists.txt
+++ b/grpc/functional_tests/basic_server/CMakeLists.txt
@@ -5,7 +5,8 @@ target_link_libraries(${PROJECT_NAME} userver::core)
 
 include(UserverGrpcTargets)
 userver_add_grpc_library(${PROJECT_NAME}-proto PROTOS samples/greeter.proto)
-target_link_libraries(${PROJECT_NAME} ${PROJECT_NAME}-proto)
+add_subdirectory(unused_proto)  # Test for https://github.com/userver-framework/userver/pull/1014
+target_link_libraries(${PROJECT_NAME} ${PROJECT_NAME}-proto ${PROJECT_NAME}-unused-proto)
 
 userver_chaos_testsuite_add(TESTS_DIRECTORY tests-tls)
 userver_chaos_testsuite_add(TESTS_DIRECTORY tests-unix-socket)
diff --git a/grpc/functional_tests/basic_server/unused_proto/CMakeLists.txt b/grpc/functional_tests/basic_server/unused_proto/CMakeLists.txt
new file mode 100644
index 000000000000..08c23af9686d
--- /dev/null
+++ b/grpc/functional_tests/basic_server/unused_proto/CMakeLists.txt
@@ -0,0 +1,2 @@
+include(UserverGrpcTargets)
+userver_add_grpc_library(${PROJECT_NAME}-unused-proto PROTOS samples/unused.proto)
diff --git a/grpc/functional_tests/basic_server/unused_proto/proto/samples/unused.proto b/grpc/functional_tests/basic_server/unused_proto/proto/samples/unused.proto
new file mode 100644
index 000000000000..32e5c311976d
--- /dev/null
+++ b/grpc/functional_tests/basic_server/unused_proto/proto/samples/unused.proto
@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package unused.api;
+
+service GreeterService {
+  rpc SayHello(GreetingRequest) returns(GreetingResponse) {}
+  rpc CallEchoNobody(GreetingRequest) returns(GreetingResponse) {}
+}
+
+message GreetingRequest {
+  string name = 1;
+}
+
+message GreetingResponse {
+  string greeting = 1;
+}
diff --git a/grpc/functional_tests/basic_server/unused_proto/proto/ya.make b/grpc/functional_tests/basic_server/unused_proto/proto/ya.make
new file mode 100644
index 000000000000..338c9f9ddbb7
--- /dev/null
+++ b/grpc/functional_tests/basic_server/unused_proto/proto/ya.make
@@ -0,0 +1,35 @@
+PROTO_LIBRARY(userver-functional-test-service-grpc-unused-proto)
+
+SUBSCRIBER(g:taxi-common)
+
+EXCLUDE_TAGS(GO_PROTO JAVA_PROTO)
+
+SRCDIR(taxi/uservices/userver/grpc/functional_tests/basic_server/unused_proto/proto)
+
+SRCS(
+    samples/unused.proto
+)
+
+PROTO_NAMESPACE(taxi/uservices/userver/grpc/functional_tests/basic_server/unused_proto/proto)
+PY_NAMESPACE(.)
+
+GRPC()
+
+CPP_PROTO_PLUGIN2(
+    usrv_service
+    taxi/uservices/userver-arc-utils/scripts/grpc/arc-generate-service
+    _service.usrv.pb.hpp
+    _service.usrv.pb.cpp
+    DEPS taxi/uservices/userver/grpc
+)
+CPP_PROTO_PLUGIN2(
+    usrv_client
+    taxi/uservices/userver-arc-utils/scripts/grpc/arc-generate-client
+    _client.usrv.pb.hpp
+    _client.usrv.pb.cpp
+    DEPS taxi/uservices/userver/grpc
+)
+
+END()
+
+
diff --git a/grpc/functional_tests/lowlevel/static_config.yaml b/grpc/functional_tests/lowlevel/static_config.yaml
index 11d157282917..4c7dba72a631 100644
--- a/grpc/functional_tests/lowlevel/static_config.yaml
+++ b/grpc/functional_tests/lowlevel/static_config.yaml
@@ -15,6 +15,8 @@ components_manager:
             # The TaskProcessor for blocking connection initiation
             blocking-task-processor: grpc-blocking-task-processor
 
+        # /// [retry configuration]
+        # yaml
         # Creates gRPC clients
         grpc-client-factory:
             disable-all-pipeline-middlewares: true
@@ -27,6 +29,7 @@ components_manager:
             # https://grpc.github.io/grpc/core/group__grpc__arg__keys.html
             channel-args: {}
 
+            # Transparent retries configuration
             default-service-config: >
                 {
                     "methodConfig": [{
@@ -46,6 +49,7 @@ components_manager:
                         }
                    }]
                 }
+        # /// [retry configuration]
 
         grpc-client-middlewares-pipeline: {}
 
diff --git a/grpc/functional_tests/middleware_client/static_config.yaml b/grpc/functional_tests/middleware_client/static_config.yaml
index 1149d5238243..b6a34e164686 100644
--- a/grpc/functional_tests/middleware_client/static_config.yaml
+++ b/grpc/functional_tests/middleware_client/static_config.yaml
@@ -26,11 +26,16 @@ components_manager:
         grpc-client-headers-propagator:
             skip-headers:
                 skipped-header: true
+        # /// [grpc client factory]
+        # yaml
         grpc-client-factory:
             middlewares:
                 grpc-client-deadline-propagation:
                     enabled: false
+            retry-config:
+                attempts: 2
             channel-args: {}
+        # /// [grpc client factory]
 
         greeter-client:
             endpoint: $greeter-client-endpoint
diff --git a/grpc/functional_tests/middleware_client/tests/test_error_status.py b/grpc/functional_tests/middleware_client/tests/test_error_status.py
index 73d28dd13008..fe13ebf474f9 100644
--- a/grpc/functional_tests/middleware_client/tests/test_error_status.py
+++ b/grpc/functional_tests/middleware_client/tests/test_error_status.py
@@ -16,13 +16,17 @@ async def mock_say_hello(request, context: grpc.aio.ServicerContext):
     with pytest.raises(pytest_userver.client.TestsuiteTaskFailed) as ex_info:
         await service_client.run_task('call-say-hello')
     ex_info.match("'samples.api.GreeterService/SayHello' failed: code=UNAVAILABLE, message='Greeter is down'")
-    assert mock_say_hello.times_called == 1
+    assert mock_say_hello.times_called == 2
     # /// [Mocked error status]
 
 
 async def test_error_status_via_result(service_client, grpc_mockserver):
     @grpc_mockserver(greeter_services.GreeterServiceServicer.SayHello)
     async def mock_say_hello(request, context: grpc.aio.ServicerContext):
+        # Be aware of using `context.set_code()`!
+        # Maybe you should use `await context.abort()` instead
+        # e.g. using `context.set_code()` as an unexpected side effect disables grpc-core client retries
+        # but does not disable userver grpc retries
         context.set_code(grpc.StatusCode.UNAVAILABLE)
         context.set_details('Greeter is down')
         return greeter_protos.GreetingResponse()  # Message is ignored.
@@ -30,4 +34,5 @@ async def mock_say_hello(request, context: grpc.aio.ServicerContext):
     with pytest.raises(pytest_userver.client.TestsuiteTaskFailed) as ex_info:
         await service_client.run_task('call-say-hello')
     ex_info.match("'samples.api.GreeterService/SayHello' failed: code=UNAVAILABLE, message='Greeter is down'")
-    assert mock_say_hello.times_called == 1
+    # using `context.set_code()` does not disable userver grpc retries
+    assert mock_say_hello.times_called == 2
diff --git a/grpc/functional_tests/middleware_client/tests/test_mocked_fail.py b/grpc/functional_tests/middleware_client/tests/test_mocked_fail.py
index 4197f674479a..6105622ee37a 100644
--- a/grpc/functional_tests/middleware_client/tests/test_mocked_fail.py
+++ b/grpc/functional_tests/middleware_client/tests/test_mocked_fail.py
@@ -14,6 +14,7 @@ async def mock_say_hello(request, context):
     with pytest.raises(pytest_userver.client.TestsuiteTaskFailed) as ex_info:
         await service_client.run_task('call-say-hello')
     ex_info.match("'samples.api.GreeterService/SayHello' failed: interrupted at Testsuite network")
+    assert mock_say_hello.times_called == 1
     # /// [Mocked network failure]
 
 
@@ -26,4 +27,5 @@ async def mock_say_hello(request, context):
     with pytest.raises(pytest_userver.client.TestsuiteTaskFailed) as ex_info:
         await service_client.run_task('call-say-hello')
     ex_info.match("'samples.api.GreeterService/SayHello' failed: interrupted at Testsuite timeout")
+    assert mock_say_hello.times_called == 1
     # /// [Mocked timeout failure]
diff --git a/grpc/handlers/CMakeLists.txt b/grpc/handlers/CMakeLists.txt
index bbd226db2744..696c854e3731 100644
--- a/grpc/handlers/CMakeLists.txt
+++ b/grpc/handlers/CMakeLists.txt
@@ -6,6 +6,7 @@ userver_module(
     INSTALL_COMPONENT grpc
     LINK_LIBRARIES userver-grpc-internal
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    DEPENDS grpc
 )
 
 userver_add_grpc_library(${PROJECT_NAME}-proto PROTOS health/v1/health.proto)
diff --git a/grpc/include/userver/ugrpc/client/call_context.hpp b/grpc/include/userver/ugrpc/client/call_context.hpp
index 78be335fa1c7..4304e3936dd0 100644
--- a/grpc/include/userver/ugrpc/client/call_context.hpp
+++ b/grpc/include/userver/ugrpc/client/call_context.hpp
@@ -19,10 +19,13 @@ class CallState;
 /// @brief gRPC call context
 class CallContext {
 public:
-    CallContext(utils::impl::InternalTag, impl::CallState& state);
+    /// @cond
+    // For internal use only
+    CallContext(utils::impl::InternalTag, impl::CallState& state) noexcept;
+    /// @endcond
 
     /// @returns the `ClientContext` used for this RPC
-    grpc::ClientContext& GetClientContext() noexcept;
+    grpc::ClientContext& GetClientContext();
 
     /// @returns client name
     std::string_view GetClientName() const noexcept;
diff --git a/grpc/include/userver/ugrpc/client/call_options.hpp b/grpc/include/userver/ugrpc/client/call_options.hpp
index ceaeae75a55b..e50de2700362 100644
--- a/grpc/include/userver/ugrpc/client/call_options.hpp
+++ b/grpc/include/userver/ugrpc/client/call_options.hpp
@@ -24,6 +24,12 @@ class CallOptionsAccessor;
 /// @brief Options passed to interface calls
 class CallOptions {
 public:
+    /// @{
+    /// Set and get retry attempts. Maximum number of retry attempts, including the original attempt.
+    void SetAttempts(int attempts);
+    int GetAttempts() const;
+    /// @}
+
     /// @{
     /// Set and get operation timeout.
     ///
@@ -47,6 +53,8 @@ class CallOptions {
 private:
     friend class impl::CallOptionsAccessor;
 
+    int attempts_{0};
+
     std::chrono::milliseconds timeout_{std::chrono::milliseconds::max()};
 
     std::vector<std::pair<grpc::string, grpc::string>> metadata_;
diff --git a/grpc/include/userver/ugrpc/client/channels.hpp b/grpc/include/userver/ugrpc/client/channels.hpp
index 10ee09edc102..a800826427cc 100644
--- a/grpc/include/userver/ugrpc/client/channels.hpp
+++ b/grpc/include/userver/ugrpc/client/channels.hpp
@@ -9,7 +9,7 @@
 #include <userver/engine/deadline.hpp>
 #include <userver/engine/task/task_processor_fwd.hpp>
 
-#include <userver/ugrpc/client/impl/client_data.hpp>
+#include <userver/ugrpc/client/impl/client_data_accessor.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -17,8 +17,11 @@ namespace ugrpc::client {
 
 namespace impl {
 
-[[nodiscard]] bool
-TryWaitForConnected(ClientData& client_data, engine::Deadline deadline, engine::TaskProcessor& blocking_task_processor);
+[[nodiscard]] bool TryWaitForConnected(
+    const ClientData& client_data,
+    engine::Deadline deadline,
+    engine::TaskProcessor& blocking_task_processor
+);
 
 }  // namespace impl
 
@@ -48,7 +51,9 @@ std::shared_ptr<grpc::Channel> MakeChannel(
 template <typename Client>
 [[nodiscard]] bool
 TryWaitForConnected(Client& client, engine::Deadline deadline, engine::TaskProcessor& blocking_task_processor) {
-    return impl::TryWaitForConnected(impl::GetClientData(client), deadline, blocking_task_processor);
+    return impl::TryWaitForConnected(
+        impl::ClientDataAccessor::GetClientData(client), deadline, blocking_task_processor
+    );
 }
 
 }  // namespace ugrpc::client
diff --git a/grpc/include/userver/ugrpc/client/client_factory_component.hpp b/grpc/include/userver/ugrpc/client/client_factory_component.hpp
index 3329c19bbeaa..15e210c22909 100644
--- a/grpc/include/userver/ugrpc/client/client_factory_component.hpp
+++ b/grpc/include/userver/ugrpc/client/client_factory_component.hpp
@@ -53,6 +53,7 @@ using MiddlewareRunnerComponentBase = USERVER_NAMESPACE::middlewares::RunnerComp
 /// ---- | ----------- | -------------
 /// auth-type | authentication method, see @ref grpc_ssl_authentication "Authentication" | -
 /// ssl-credentials-options | TLS/SSL options, see @ref grpc_ssl_authentication "Authentication" | -
+/// retry-config | retry configuration for outgoing RPCs | {}
 /// channel-args | a map of channel arguments, see gRPC Core docs | {}
 /// default-service-config | default service config, see above | -
 /// channel-count | Number of underlying grpc::Channel objects | 1
diff --git a/grpc/include/userver/ugrpc/client/client_factory_settings.hpp b/grpc/include/userver/ugrpc/client/client_factory_settings.hpp
index beee7465360c..b10ad12c5a13 100644
--- a/grpc/include/userver/ugrpc/client/client_factory_settings.hpp
+++ b/grpc/include/userver/ugrpc/client/client_factory_settings.hpp
@@ -11,6 +11,8 @@
 #include <grpcpp/security/credentials.h>
 #include <grpcpp/support/channel_arguments.h>
 
+#include <userver/ugrpc/client/retry_config.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client {
@@ -22,7 +24,10 @@ struct ClientFactorySettings final {
 
     /// gRPC channel credentials by client_name. If not set, default `credentials`
     /// is used instead.
-    std::unordered_map<std::string, std::shared_ptr<grpc::ChannelCredentials>> client_credentials{};
+    std::unordered_map<std::string, std::shared_ptr<grpc::ChannelCredentials>> client_credentials;
+
+    /// Retry configuration for outgoing RPCs
+    RetryConfig retry_config;
 
     /// Optional grpc-core channel args
     /// @see https://grpc.github.io/grpc/core/group__grpc__arg__keys.html
diff --git a/grpc/include/userver/ugrpc/client/generic_client.hpp b/grpc/include/userver/ugrpc/client/generic_client.hpp
index 7db93ed8dfe2..792a1203278f 100644
--- a/grpc/include/userver/ugrpc/client/generic_client.hpp
+++ b/grpc/include/userver/ugrpc/client/generic_client.hpp
@@ -8,9 +8,11 @@
 
 #include <grpcpp/support/byte_buffer.h>
 
+#include <userver/utils/box.hpp>
+
 #include <userver/ugrpc/client/call_options.hpp>
 #include <userver/ugrpc/client/generic_options.hpp>
-#include <userver/ugrpc/client/impl/client_data.hpp>
+#include <userver/ugrpc/client/impl/fwd.hpp>
 #include <userver/ugrpc/client/response_future.hpp>
 #include <userver/ugrpc/impl/static_service_metadata.hpp>
 
@@ -47,8 +49,10 @@ namespace ugrpc::client {
 /// For a more complete sample, see @ref grpc_generic_api.
 class GenericClient final {
 public:
-    GenericClient(GenericClient&&) noexcept = default;
-    GenericClient& operator=(GenericClient&&) noexcept = delete;
+    GenericClient(GenericClient&&) noexcept;
+    GenericClient& operator=(GenericClient&&) noexcept;
+
+    ~GenericClient();
 
     /// Initiate a `single request -> single response` RPC with the given name.
     ResponseFuture<grpc::ByteBuffer> AsyncUnaryCall(
@@ -74,10 +78,9 @@ class GenericClient final {
     /// @endcond
 
 private:
-    template <typename Client>
-    friend impl::ClientData& impl::GetClientData(Client& client);
+    friend class impl::ClientDataAccessor;
 
-    impl::ClientData impl_;
+    utils::Box<impl::ClientData> client_data_;
 };
 
 }  // namespace ugrpc::client
diff --git a/grpc/include/userver/ugrpc/client/impl/async_methods.hpp b/grpc/include/userver/ugrpc/client/impl/async_methods.hpp
index a9d75d563889..9aaf43569ea4 100644
--- a/grpc/include/userver/ugrpc/client/impl/async_methods.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/async_methods.hpp
@@ -1,36 +1,13 @@
 #pragma once
 
-#include <string_view>
 #include <type_traits>
 
 #include <google/protobuf/message.h>
-#include <grpcpp/support/async_stream.h>
-#include <grpcpp/support/async_unary_call.h>
-
-#include <userver/ugrpc/client/impl/call_state.hpp>
-#include <userver/ugrpc/impl/async_method_invocation.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client::impl {
 
-/// @{
-/// @brief Helper type aliases for low-level asynchronous gRPC streams
-/// @see <grpcpp/impl/codegen/async_unary_call_impl.h>
-/// @see <grpcpp/impl/codegen/async_stream_impl.h>
-template <typename Response>
-using RawResponseReader = std::unique_ptr<grpc::ClientAsyncResponseReader<Response>>;
-
-template <typename Response>
-using RawReader = std::unique_ptr<grpc::ClientAsyncReader<Response>>;
-
-template <typename Request>
-using RawWriter = std::unique_ptr<grpc::ClientAsyncWriter<Request>>;
-
-template <typename Request, typename Response>
-using RawReaderWriter = std::unique_ptr<grpc::ClientAsyncReaderWriter<Request, Response>>;
-/// @}
-
 template <typename Message>
 const google::protobuf::Message* ToBaseMessage(const Message* message) {
     if constexpr (std::is_base_of_v<google::protobuf::Message, Message>) {
@@ -40,25 +17,6 @@ const google::protobuf::Message* ToBaseMessage(const Message* message) {
     }
 }
 
-ugrpc::impl::AsyncMethodInvocation::WaitStatus WaitAndTryCancelIfNeeded(
-    ugrpc::impl::AsyncMethodInvocation& invocation,
-    engine::Deadline deadline,
-    grpc::ClientContext& context
-) noexcept;
-
-ugrpc::impl::AsyncMethodInvocation::WaitStatus
-WaitAndTryCancelIfNeeded(ugrpc::impl::AsyncMethodInvocation& invocation, grpc::ClientContext& context) noexcept;
-
-void ProcessFinish(CallState& state, const google::protobuf::Message* final_response);
-
-void ProcessFinishAbandoned(CallState& state) noexcept;
-
-void CheckFinishStatus(CallState& state);
-
-void ProcessCancelled(CallState& state, std::string_view stage) noexcept;
-
-void ProcessNetworkError(CallState& state, std::string_view stage) noexcept;
-
 }  // namespace ugrpc::client::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/async_stream_methods.hpp b/grpc/include/userver/ugrpc/client/impl/async_stream_methods.hpp
index 20f18d6f43bd..e342e327b4bb 100644
--- a/grpc/include/userver/ugrpc/client/impl/async_stream_methods.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/async_stream_methods.hpp
@@ -1,19 +1,48 @@
 #pragma once
 
-#include <userver/ugrpc/client/impl/async_methods.hpp>
+#include <string_view>
+
+#include <grpcpp/support/async_stream.h>
 
 #include <userver/utils/assert.hpp>
 
 #include <userver/ugrpc/client/exceptions.hpp>
 #include <userver/ugrpc/client/impl/async_method_invocation.hpp>
+#include <userver/ugrpc/client/impl/async_methods.hpp>
 #include <userver/ugrpc/client/impl/call_state.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client::impl {
 
+/// @{
+/// @brief Helper type aliases for low-level asynchronous gRPC streams
+/// @see <grpcpp/impl/codegen/async_stream_impl.h>
+template <typename Response>
+using RawReader = std::unique_ptr<grpc::ClientAsyncReader<Response>>;
+
+template <typename Request>
+using RawWriter = std::unique_ptr<grpc::ClientAsyncWriter<Request>>;
+
+template <typename Request, typename Response>
+using RawReaderWriter = std::unique_ptr<grpc::ClientAsyncReaderWriter<Request, Response>>;
+/// @}
+
+ugrpc::impl::AsyncMethodInvocation::WaitStatus
+WaitAndTryCancelIfNeeded(ugrpc::impl::AsyncMethodInvocation& invocation, grpc::ClientContext& context) noexcept;
+
 void CheckOk(StreamingCallState& state, ugrpc::impl::AsyncMethodInvocation::WaitStatus status, std::string_view stage);
 
+void CheckFinishStatus(CallState& state);
+
+void ProcessFinish(CallState& state, const google::protobuf::Message* final_response);
+
+void ProcessFinishAbandoned(CallState& state) noexcept;
+
+void ProcessCancelled(CallState& state, std::string_view stage) noexcept;
+
+void ProcessNetworkError(CallState& state, std::string_view stage) noexcept;
+
 template <typename GrpcStream>
 void StartCall(GrpcStream& stream, StreamingCallState& state) {
     ugrpc::impl::AsyncMethodInvocation start_call;
diff --git a/grpc/include/userver/ugrpc/client/impl/async_unary_call_adapter.hpp b/grpc/include/userver/ugrpc/client/impl/async_unary_call_adapter.hpp
new file mode 100644
index 000000000000..ecc3f28c17ee
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/async_unary_call_adapter.hpp
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <userver/engine/task/cancel.hpp>
+#include <userver/engine/task/task_with_result.hpp>
+#include <userver/utils/async.hpp>
+#include <userver/utils/trx_tracker.hpp>
+
+#include <userver/ugrpc/client/impl/response_future_impl_base.hpp>
+#include <userver/ugrpc/client/impl/unary_call.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+template <typename Stub, typename Request, typename Response>
+class AsyncUnaryCallAdapter final : public ResponseFutureImplBase<Response> {
+public:
+    AsyncUnaryCallAdapter(
+        CallParams&& params,
+        PrepareUnaryCallProxy<Stub, Request, Response>&& prepare_unary_call,
+        const Request& request
+    )
+        : request_{request},
+          unary_call_{std::move(params), std::move(prepare_unary_call), request_},
+          perform_task_{utils::CriticalAsync(
+              "async-unary-call-perform",
+              [this] {
+                  // TODO: get rid of span for perform_task
+                  // we use `utils::CriticalAsync` to inherit TaskInheritedVariable, but it create span,
+                  // so set LogLevel=None
+                  tracing::Span::CurrentSpan().SetLogLevel(logging::Level::kNone);
+
+                  unary_call_.Perform();
+                  return unary_call_.ExtractResponse();
+              }
+          )},
+          cancellation_token_{perform_task_} {}
+
+    ~AsyncUnaryCallAdapter() override { unary_call_.Abandon(); }
+
+    AsyncUnaryCallAdapter(AsyncUnaryCallAdapter&&) = delete;
+    AsyncUnaryCallAdapter& operator=(AsyncUnaryCallAdapter&&) = delete;
+
+    CallContext& GetContext() noexcept override { return unary_call_.GetContext(); }
+    const CallContext& GetContext() const noexcept override { return unary_call_.GetContext(); }
+
+    bool IsReady() const override { return perform_task_.IsFinished(); }
+
+    engine::FutureStatus WaitUntil(engine::Deadline deadline) const noexcept override {
+        utils::trx_tracker::CheckNoTransactions(unary_call_.GetContext().GetCallName());
+        return perform_task_.WaitNothrowUntil(deadline);
+    }
+
+    Response Get() override {
+        const auto status = WaitUntil(engine::Deadline{});
+        if (status != engine::FutureStatus::kReady) {
+            perform_task_.RequestCancel();
+        }
+        const engine::TaskCancellationBlocker cancel_blocker;
+        return perform_task_.Get();
+    }
+
+    void Cancel() override { cancellation_token_.RequestCancel(); }
+
+    engine::impl::ContextAccessor* TryGetContextAccessor() noexcept override {
+        return perform_task_.TryGetContextAccessor();
+    }
+
+private:
+    Request request_;
+    UnaryCall<Stub, Request, Response> unary_call_;
+    engine::TaskWithResult<Response> perform_task_;
+    engine::TaskCancellationToken cancellation_token_;
+};
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/call_params.hpp b/grpc/include/userver/ugrpc/client/impl/call_params.hpp
index f4755aa19586..69cb82972a83 100644
--- a/grpc/include/userver/ugrpc/client/impl/call_params.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/call_params.hpp
@@ -29,6 +29,7 @@ struct CallParams {
     StubHandle stub;
     const Middlewares& middlewares;
     ugrpc::impl::MethodStatistics& statistics;
+    const testsuite::GrpcControl& testsuite_grpc;
 };
 
 CallParams CreateCallParams(const ClientData& client_data, std::size_t method_id, CallOptions&& call_options);
diff --git a/grpc/include/userver/ugrpc/client/impl/call_state.hpp b/grpc/include/userver/ugrpc/client/impl/call_state.hpp
index 190a2d3dc274..4b3367f0a820 100644
--- a/grpc/include/userver/ugrpc/client/impl/call_state.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/call_state.hpp
@@ -11,7 +11,6 @@
 #include <userver/engine/single_waiting_task_mutex.hpp>
 #include <userver/tracing/in_place_span.hpp>
 
-#include <userver/ugrpc/client/impl/async_method_invocation.hpp>
 #include <userver/ugrpc/client/impl/call_kind.hpp>
 #include <userver/ugrpc/client/impl/middleware_pipeline.hpp>
 #include <userver/ugrpc/client/impl/stub_handle.hpp>
@@ -21,6 +20,10 @@
 
 USERVER_NAMESPACE_BEGIN
 
+namespace ugrpc::client {
+class CallOptions;
+}  // namespace ugrpc::client
+
 namespace ugrpc::client::impl {
 
 struct CallParams;
@@ -42,6 +45,8 @@ class CallState {
 
     StubHandle& GetStub() noexcept;
 
+    void SetClientContext(std::unique_ptr<grpc::ClientContext> client_context) noexcept;
+
     const grpc::ClientContext& GetClientContext() const noexcept;
 
     grpc::ClientContext& GetClientContext() noexcept;
@@ -58,6 +63,8 @@ class CallState {
 
     const MiddlewarePipeline& GetMiddlewarePipeline() const noexcept;
 
+    const testsuite::GrpcControl& GetTestsuiteControl() const noexcept;
+
     CallKind GetCallKind() const noexcept;
 
     void ResetSpan() noexcept;
@@ -70,6 +77,10 @@ class CallState {
 
     grpc::Status& GetStatus() noexcept;
 
+    void Commit() noexcept;
+
+    grpc::ClientContext& GetClientContextCommitted();
+
 private:
     StubHandle stub_;
 
@@ -90,45 +101,18 @@ class CallState {
 
     MiddlewarePipeline middleware_pipeline_;
 
+    const testsuite::GrpcControl& testsuite_grpc_;
+
     CallKind call_kind_{};
 
     grpc::Status status_;
-};
-
-class UnaryCallState final : public CallState {
-public:
-    explicit UnaryCallState(CallParams&& params) : CallState(std::move(params), CallKind::kUnaryCall) {}
-
-    ~UnaryCallState() noexcept;
-
-    UnaryCallState(UnaryCallState&&) noexcept = delete;
-    UnaryCallState& operator=(UnaryCallState&&) noexcept = delete;
 
-    bool IsFinishProcessed() const noexcept;
-    void SetFinishProcessed() noexcept;
-
-    bool IsStatusExtracted() const noexcept;
-    void SetStatusExtracted() noexcept;
-
-    void EmplaceFinishAsyncMethodInvocation();
-
-    FinishAsyncMethodInvocation& GetFinishAsyncMethodInvocation() noexcept;
-
-private:
-    bool finish_processed_{false};
-
-    bool status_extracted_{false};
-
-    // In unary call the call is finished as soon as grpc core
-    // gives us back a response - so for unary call
-    // We use FinishAsyncMethodInvocation that will correctly close all our
-    // tracing::Span objects and account everything in statistics.
-    std::optional<FinishAsyncMethodInvocation> invocation_;
+    std::atomic<bool> committed_{false};
 };
 
 class StreamingCallState final : public CallState {
 public:
-    StreamingCallState(CallParams&& params, CallKind call_kind) : CallState(std::move(params), call_kind) {}
+    StreamingCallState(CallParams&& params, CallKind call_kind);
 
     ~StreamingCallState() noexcept;
 
@@ -192,6 +176,8 @@ bool IsWriteAvailable(const StreamingCallState&) noexcept;
 
 bool IsWriteAndCheckAvailable(const StreamingCallState&) noexcept;
 
+void SetupClientContext(CallState& state, const CallOptions& call_options);
+
 void HandleCallStatistics(CallState& state, const grpc::Status& status) noexcept;
 
 void RunMiddlewarePipeline(CallState& state, const MiddlewareHooks& hooks);
diff --git a/grpc/include/userver/ugrpc/client/impl/channel_argument_utils.hpp b/grpc/include/userver/ugrpc/client/impl/channel_argument_utils.hpp
new file mode 100644
index 000000000000..f6b7af72dd28
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/channel_argument_utils.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <optional>
+#include <string>
+
+#include <grpcpp/support/channel_arguments.h>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+grpc::ChannelArguments
+BuildChannelArguments(const grpc::ChannelArguments& channel_args, const std::optional<std::string>& service_config);
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/client_data.hpp b/grpc/include/userver/ugrpc/client/impl/client_data.hpp
index e86ffce7a608..04ca8c490256 100644
--- a/grpc/include/userver/ugrpc/client/impl/client_data.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/client_data.hpp
@@ -13,8 +13,9 @@
 #include <userver/utils/fixed_array.hpp>
 
 #include <userver/ugrpc/client/client_qos.hpp>
-#include <userver/ugrpc/client/impl/channel_arguments_builder.hpp>
+#include <userver/ugrpc/client/impl/channel_argument_utils.hpp>
 #include <userver/ugrpc/client/impl/client_internals.hpp>
+#include <userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp>
 #include <userver/ugrpc/client/impl/stub_any.hpp>
 #include <userver/ugrpc/client/impl/stub_handle.hpp>
 #include <userver/ugrpc/client/impl/stub_pool.hpp>
@@ -52,9 +53,9 @@ class ClientData final {
               std::in_place,
               internals_.channel_args,
               internals_.default_service_config,
+              internals_.retry_config,
               metadata
-          ),
-          stub_state_(std::make_unique<rcu::Variable<StubState>>()) {
+          ) {
         if (internals_.qos) {
             SubscribeOnConfigUpdate<Service>(*internals_.qos);
         } else {
@@ -64,20 +65,19 @@ class ClientData final {
 
     template <typename Service>
     ClientData(ClientInternals&& internals, GenericClientTag, std::in_place_type_t<Service>)
-        : internals_(std::move(internals)), stub_state_(std::make_unique<rcu::Variable<StubState>>()) {
+        : internals_(std::move(internals)) {
         ConstructStubState<Service>();
     }
 
     ~ClientData();
 
-    ClientData(ClientData&&) noexcept = default;
-    ClientData& operator=(ClientData&&) = delete;
-
+    ClientData(ClientData&&) noexcept = delete;
     ClientData(const ClientData&) = delete;
+    ClientData& operator=(ClientData&&) = delete;
     ClientData& operator=(const ClientData&) = delete;
 
     StubHandle NextStubFromMethodId(std::size_t method_id) const {
-        auto stub_state = stub_state_->Read();
+        auto stub_state = stub_state_.Read();
         auto& dedicated_stubs = stub_state->dedicated_stubs[method_id];
         auto& stubs = dedicated_stubs.Size() ? dedicated_stubs : stub_state->stubs;
         auto& stub = stubs.NextStub();
@@ -85,7 +85,7 @@ class ClientData final {
     }
 
     StubHandle NextStub() const {
-        auto stub_state = stub_state_->Read();
+        auto stub_state = stub_state_.Read();
         auto& stub = stub_state->stubs.NextStub();
         return StubHandle{std::move(stub_state), stub};
     }
@@ -108,7 +108,9 @@ class ClientData final {
 
     const dynamic_config::Key<ClientQos>* GetClientQos() const;
 
-    rcu::ReadablePtr<StubState> GetStubState() const { return stub_state_->Read(); }
+    const RetryConfig& GetRetryConfig() const { return internals_.retry_config; }
+
+    rcu::ReadablePtr<StubState> GetStubState() const { return stub_state_.Read(); }
 
 private:
     template <typename Stub>
@@ -159,26 +161,21 @@ class ClientData final {
                   )
                 : utils::FixedArray<StubPool>{};
 
-        stub_state_->Assign({client_qos, std::move(stubs), std::move(dedicated_stubs)});
+        stub_state_.Assign({client_qos, std::move(stubs), std::move(dedicated_stubs)});
     }
 
     ClientInternals internals_;
-    std::optional<ugrpc::impl::StaticServiceMetadata> metadata_{std::nullopt};
+    std::optional<ugrpc::impl::StaticServiceMetadata> metadata_;
     ugrpc::impl::ServiceStatistics* service_statistics_{nullptr};
 
-    std::optional<ChannelArgumentsBuilder> channel_arguments_builder_;
+    std::optional<compat::ChannelArgumentsBuilder> channel_arguments_builder_;
 
-    std::unique_ptr<rcu::Variable<StubState>> stub_state_;
+    rcu::Variable<StubState> stub_state_;
 
     // These fields must be the last ones
     concurrent::AsyncEventSubscriberScope config_subscription_;
 };
 
-template <typename Client>
-ClientData& GetClientData(Client& client) {
-    return client.impl_;
-}
-
 }  // namespace ugrpc::client::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/client_data_accessor.hpp b/grpc/include/userver/ugrpc/client/impl/client_data_accessor.hpp
new file mode 100644
index 000000000000..6cbc2f68a991
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/client_data_accessor.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+class ClientData;
+
+class ClientDataAccessor final {
+public:
+    template <typename Client>
+    static const ClientData& GetClientData(const Client& client) {
+        return *client.client_data_;
+    }
+};
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/client_internals.hpp b/grpc/include/userver/ugrpc/client/impl/client_internals.hpp
index 205bd6a2eabb..e5cbabc6da27 100644
--- a/grpc/include/userver/ugrpc/client/impl/client_internals.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/client_internals.hpp
@@ -11,6 +11,7 @@
 #include <userver/ugrpc/client/client_settings.hpp>
 #include <userver/ugrpc/client/impl/channel_factory.hpp>
 #include <userver/ugrpc/client/middlewares/fwd.hpp>
+#include <userver/ugrpc/client/retry_config.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -33,7 +34,8 @@ struct ClientInternals final {
     std::size_t channel_count{};
     DedicatedMethodsConfig dedicated_methods_config;
     ChannelFactory channel_factory;
-    const grpc::ChannelArguments& channel_args{};
+    const RetryConfig& retry_config;
+    const grpc::ChannelArguments& channel_args;
     const std::optional<std::string>& default_service_config;
 };
 
diff --git a/grpc/include/userver/ugrpc/client/impl/codegen_declarations.hpp b/grpc/include/userver/ugrpc/client/impl/codegen_declarations.hpp
index b475ed946d0b..ab151e615c26 100644
--- a/grpc/include/userver/ugrpc/client/impl/codegen_declarations.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/codegen_declarations.hpp
@@ -5,8 +5,10 @@
 //
 // Do not include this header in your code, use non-impl includes instead!
 
+#include <userver/utils/box.hpp>
+
 #include <userver/ugrpc/client/call_options.hpp>
-#include <userver/ugrpc/client/impl/client_data.hpp>
+#include <userver/ugrpc/client/impl/fwd.hpp>
 #include <userver/ugrpc/client/response_future.hpp>
 #include <userver/ugrpc/client/stream.hpp>
 #include <userver/ugrpc/impl/static_service_metadata.hpp>
diff --git a/grpc/include/userver/ugrpc/client/impl/codegen_definitions.hpp b/grpc/include/userver/ugrpc/client/impl/codegen_definitions.hpp
index 69ccfd65f2bd..d534cb9efd44 100644
--- a/grpc/include/userver/ugrpc/client/impl/codegen_definitions.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/codegen_definitions.hpp
@@ -6,9 +6,10 @@
 // Do not include this header in your code, use non-impl includes instead!
 
 #include <array>
-#include <string_view>
+#include <string>
 #include <utility>
 
 #include <userver/ugrpc/client/impl/call_params.hpp>
+#include <userver/ugrpc/client/impl/client_data.hpp>
 #include <userver/ugrpc/client/impl/perform_unary_call.hpp>
 #include <userver/ugrpc/impl/protobuf_collector.hpp>
diff --git a/grpc/include/userver/ugrpc/client/impl/channel_arguments_builder.hpp b/grpc/include/userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp
similarity index 86%
rename from grpc/include/userver/ugrpc/client/impl/channel_arguments_builder.hpp
rename to grpc/include/userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp
index 916c815bb3fa..c78e71dc4307 100644
--- a/grpc/include/userver/ugrpc/client/impl/channel_arguments_builder.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp
@@ -9,11 +9,12 @@
 #include <userver/formats/json/value.hpp>
 
 #include <userver/ugrpc/client/fwd.hpp>
+#include <userver/ugrpc/client/retry_config.hpp>
 #include <userver/ugrpc/impl/static_service_metadata.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
-namespace ugrpc::client::impl {
+namespace ugrpc::client::impl::compat {
 
 class ServiceConfigBuilder final {
 public:
@@ -25,10 +26,11 @@ class ServiceConfigBuilder final {
 
     ServiceConfigBuilder(
         const ugrpc::impl::StaticServiceMetadata& metadata,
+        const RetryConfig& retry_config,
         const std::optional<std::string>& static_service_config
     );
 
-    ServiceConfigBuilder(ServiceConfigBuilder&&) noexcept = default;
+    ServiceConfigBuilder(ServiceConfigBuilder&&) noexcept = delete;
     ServiceConfigBuilder(const ServiceConfigBuilder&) = delete;
     ServiceConfigBuilder& operator=(ServiceConfigBuilder&&) = delete;
     ServiceConfigBuilder& operator=(const ServiceConfigBuilder&) = delete;
@@ -40,6 +42,8 @@ class ServiceConfigBuilder final {
 
     ugrpc::impl::StaticServiceMetadata metadata_;
 
+    RetryConfig retry_config_;
+
     formats::json::Value static_service_config_;
 
     PreparedMethodConfigs prepared_method_configs_;
@@ -50,10 +54,11 @@ class ChannelArgumentsBuilder final {
     ChannelArgumentsBuilder(
         const grpc::ChannelArguments& channel_args,
         const std::optional<std::string>& static_service_config,
+        const RetryConfig& retry_config,
         const ugrpc::impl::StaticServiceMetadata& metadata
     );
 
-    ChannelArgumentsBuilder(ChannelArgumentsBuilder&&) noexcept = default;
+    ChannelArgumentsBuilder(ChannelArgumentsBuilder&&) noexcept = delete;
     ChannelArgumentsBuilder(const ChannelArgumentsBuilder&) = delete;
     ChannelArgumentsBuilder& operator=(ChannelArgumentsBuilder&&) = delete;
     ChannelArgumentsBuilder& operator=(const ChannelArgumentsBuilder&) = delete;
@@ -66,9 +71,6 @@ class ChannelArgumentsBuilder final {
     ServiceConfigBuilder service_config_builder_;
 };
 
-grpc::ChannelArguments
-BuildChannelArguments(const grpc::ChannelArguments& channel_args, const std::optional<std::string>& service_config);
-
-}  // namespace ugrpc::client::impl
+}  // namespace ugrpc::client::impl::compat
 
 USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/fwd.hpp b/grpc/include/userver/ugrpc/client/impl/fwd.hpp
new file mode 100644
index 000000000000..c55b8d9bae00
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/fwd.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+class ClientData;
+class ClientDataAccessor;
+
+struct ClientInternals;
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/perform_unary_call.hpp b/grpc/include/userver/ugrpc/client/impl/perform_unary_call.hpp
index a223a7054429..a61d3b33d260 100644
--- a/grpc/include/userver/ugrpc/client/impl/perform_unary_call.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/perform_unary_call.hpp
@@ -2,7 +2,7 @@
 
 #include <utility>
 
-#include <userver/ugrpc/client/impl/rpc.hpp>
+#include <userver/ugrpc/client/impl/unary_call.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -14,8 +14,10 @@ Response PerformUnaryCall(
     PrepareUnaryCallProxy<Stub, Request, Response>&& prepare_unary_call,
     const Request& request
 ) {
+    utils::trx_tracker::CheckNoTransactions(params.call_name.Get());
     UnaryCall unary_call{std::move(params), std::move(prepare_unary_call), request};
-    return unary_call.Finish();
+    unary_call.Perform();
+    return unary_call.ExtractResponse();
 }
 
 }  // namespace ugrpc::client::impl
diff --git a/grpc/include/userver/ugrpc/client/impl/response_future_impl_base.hpp b/grpc/include/userver/ugrpc/client/impl/response_future_impl_base.hpp
new file mode 100644
index 000000000000..662be675d3c6
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/response_future_impl_base.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <userver/engine/deadline.hpp>
+#include <userver/engine/future_status.hpp>
+#include <userver/engine/impl/context_accessor.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client {
+class CallContext;
+}  // namespace ugrpc::client
+
+namespace ugrpc::client::impl {
+
+template <typename Response>
+class ResponseFutureImplBase {
+public:
+    virtual ~ResponseFutureImplBase() = default;
+
+    virtual bool IsReady() const = 0;
+
+    virtual engine::FutureStatus WaitUntil(engine::Deadline deadline) const noexcept = 0;
+
+    virtual Response Get() = 0;
+
+    virtual void Cancel() = 0;
+
+    virtual CallContext& GetContext() noexcept = 0;
+    virtual const CallContext& GetContext() const noexcept = 0;
+
+    virtual engine::impl::ContextAccessor* TryGetContextAccessor() noexcept = 0;
+};
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/retry_backoff.hpp b/grpc/include/userver/ugrpc/client/impl/retry_backoff.hpp
new file mode 100644
index 000000000000..59b0c7e6611c
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/retry_backoff.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <chrono>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+class RetryBackoff final {
+public:
+    RetryBackoff();
+
+    std::chrono::milliseconds NextAttemptDelay();
+
+    void Reset();
+
+private:
+    bool initial_{};
+    std::int64_t current_backoff_ms_{};
+};
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/retry_policy.hpp b/grpc/include/userver/ugrpc/client/impl/retry_policy.hpp
new file mode 100644
index 000000000000..32d426477795
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/retry_policy.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <grpcpp/support/status_code_enum.h>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+/*
+  Retryable Status Codes:
+
+   - grpc::StatusCode::CANCELLED
+   - grpc::StatusCode::UNKNOWN
+   - grpc::StatusCode::DEADLINE_EXCEEDED
+   - grpc::StatusCode::ABORTED
+   - grpc::StatusCode::INTERNAL
+   - grpc::StatusCode::UNAVAILABLE
+ */
+bool IsRetryable(grpc::StatusCode status_code) noexcept;
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/impl/rpc.hpp b/grpc/include/userver/ugrpc/client/impl/rpc.hpp
index a7b9ab5c83ec..f5700933d365 100644
--- a/grpc/include/userver/ugrpc/client/impl/rpc.hpp
+++ b/grpc/include/userver/ugrpc/client/impl/rpc.hpp
@@ -3,15 +3,10 @@
 /// @file userver/ugrpc/client/impl/rpc.hpp
 /// @brief Classes representing an outgoing RPC
 
-#include <exception>
-#include <string_view>
 #include <utility>
 
 #include <grpcpp/impl/codegen/proto_utils.h>
 
-#include <userver/engine/deadline.hpp>
-#include <userver/engine/future_status.hpp>
-#include <userver/utils/assert.hpp>
 #include <userver/utils/impl/internal_tag.hpp>
 
 #include <userver/ugrpc/client/call_context.hpp>
@@ -27,81 +22,6 @@ USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client::impl {
 
-// Contains the implementation of UnaryFinishFuture that is not dependent on template parameters.
-class UnaryFinishFuture {
-public:
-    UnaryFinishFuture(UnaryCallState& state, const google::protobuf::Message* response) noexcept;
-
-    ~UnaryFinishFuture();
-
-    UnaryFinishFuture(UnaryFinishFuture&&) = delete;
-    UnaryFinishFuture& operator=(UnaryFinishFuture&&) = delete;
-
-    [[nodiscard]] bool IsReady() const noexcept;
-
-    [[nodiscard]] engine::FutureStatus WaitUntil(engine::Deadline deadline) const noexcept;
-
-    void Get();
-
-    engine::impl::ContextAccessor* TryGetContextAccessor() noexcept;
-
-private:
-    void Destroy() noexcept;
-
-    UnaryCallState& state_;
-    const google::protobuf::Message* response_;
-    mutable std::exception_ptr exception_;
-};
-
-/// @brief Controls a single request -> single response RPC
-///
-/// This class is not thread-safe, it cannot be used from multiple tasks at the same time.
-///
-/// The RPC is cancelled on destruction unless the RPC is already finished. In
-/// that case the connection is not closed (it will be reused for new RPCs), and
-/// the server receives `RpcInterruptedError` immediately.
-template <typename Response>
-class [[nodiscard]] UnaryCall final {
-    // Implementation note. For consistency with other RPC objects, UnaryCall should have been exposed to the user
-    // directly. However, in 90-99% use cases it's more intuitive to treat the RPC as a future (see ResponseFuture).
-    // If we decide to expose more controls, like lazy Finish or ReadInitialMetadata, then they should be added
-    // to UnaryCall, and UnaryCall should be exposed via ResponseFuture::GetCall.
-
-public:
-    template <typename Stub, typename Request>
-    UnaryCall(
-        CallParams&& params,
-        PrepareUnaryCallProxy<Stub, Request, Response>&& prepare_unary_call,
-        const Request& request
-    );
-
-    ~UnaryCall() = default;
-
-    UnaryCall(UnaryCall&&) = delete;
-    UnaryCall& operator=(UnaryCall&&) = delete;
-
-    CallContext& GetContext() noexcept { return context_; }
-    const CallContext& GetContext() const noexcept { return context_; }
-
-    /// @brief Returns the future created earlier using @ref FinishAsync.
-    UnaryFinishFuture& GetFinishFuture();
-    const UnaryFinishFuture& GetFinishFuture() const;
-
-    Response Finish();
-
-private:
-    // Asynchronously finish the call.
-    // `FinishAsync` should not be called multiple times for the same RPC.
-    // Creates the future inside this `UnaryCall`. It can be retrieved using @ref GetFinishFuture.
-    void FinishAsync();
-
-    UnaryCallState state_;
-    CallContext context_;
-    Response response_;
-    RawResponseReader<Response> reader_;
-    std::optional<UnaryFinishFuture> finish_future_;
-};
-
 /// @brief Controls a single request -> response stream RPC
 ///
 /// This class is not thread-safe except for `GetContext`.
@@ -326,51 +246,6 @@ class [[nodiscard]] BidirectionalStream final {
     RawReaderWriter<Request, Response> stream_;
 };
 
-template <typename Response>
-template <typename Stub, typename Request>
-UnaryCall<Response>::UnaryCall(
-    CallParams&& params,
-    PrepareUnaryCallProxy<Stub, Request, Response>&& prepare_unary_call,
-    const Request& request
-)
-    : state_{std::move(params)}, context_{utils::impl::InternalTag{}, state_} {
-    RunMiddlewarePipeline(state_, StartCallHooks(ToBaseMessage(&request)));
-
-    // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-    reader_ = prepare_unary_call(state_.GetStub(), &state_.GetClientContext(), request, &state_.GetQueue());
-    reader_->StartCall();
-
-    FinishAsync();
-}
-
-template <typename Response>
-UnaryFinishFuture& UnaryCall<Response>::GetFinishFuture() {
-    UASSERT(finish_future_);
-    return *finish_future_;
-}
-
-template <typename Response>
-const UnaryFinishFuture& UnaryCall<Response>::GetFinishFuture() const {
-    UASSERT(finish_future_);
-    return *finish_future_;
-}
-
-template <typename Response>
-Response UnaryCall<Response>::Finish() {
-    GetFinishFuture().Get();
-    return std::move(response_);
-}
-
-template <typename Response>
-void UnaryCall<Response>::FinishAsync() {
-    state_.EmplaceFinishAsyncMethodInvocation();
-    auto& status = state_.GetStatus();
-    auto& finish = state_.GetFinishAsyncMethodInvocation();
-    UASSERT(reader_);
-    reader_->Finish(&response_, &status, finish.GetCompletionTag());
-    finish_future_.emplace(state_, ToBaseMessage(&response_));
-}
-
 template <typename Response>
 template <typename Stub, typename Request>
 InputStream<Response>::InputStream(
diff --git a/grpc/include/userver/ugrpc/client/impl/unary_call.hpp b/grpc/include/userver/ugrpc/client/impl/unary_call.hpp
new file mode 100644
index 000000000000..c41aa62006c1
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/impl/unary_call.hpp
@@ -0,0 +1,177 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <google/protobuf/message.h>
+#include <grpcpp/support/async_unary_call.h>
+
+#include <userver/engine/sleep.hpp>
+#include <userver/server/request/task_inherited_data.hpp>
+#include <userver/tracing/tags.hpp>
+#include <userver/utils/impl/internal_tag.hpp>
+
+#include <userver/ugrpc/client/call_context.hpp>
+#include <userver/ugrpc/client/client_qos.hpp>
+#include <userver/ugrpc/client/exceptions.hpp>
+#include <userver/ugrpc/client/impl/async_methods.hpp>
+#include <userver/ugrpc/client/impl/call_params.hpp>
+#include <userver/ugrpc/client/impl/call_state.hpp>
+#include <userver/ugrpc/client/impl/middleware_pipeline.hpp>
+#include <userver/ugrpc/client/impl/prepare_call.hpp>
+#include <userver/ugrpc/client/impl/retry_backoff.hpp>
+#include <userver/ugrpc/client/impl/retry_policy.hpp>
+#include <userver/ugrpc/client/impl/tracing.hpp>
+#include <userver/ugrpc/impl/async_method_invocation.hpp>
+#include <userver/ugrpc/status_codes.hpp>
+#include <userver/ugrpc/time_utils.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+template <typename Stub, typename Request, typename Response>
+class UnaryCall final {
+public:
+    using PrepareUnaryCall = PrepareUnaryCallProxy<Stub, Request, Response>;
+
+    UnaryCall(CallParams&& params, PrepareUnaryCall&& prepare_unary_call, const Request& request)
+        : call_options_{std::move(params.call_options)},
+          state_{std::move(params), CallKind::kUnaryCall},
+          context_{utils::impl::InternalTag{}, state_},
+          prepare_unary_call_{std::move(prepare_unary_call)},
+          request_{request} {}
+
+    ~UnaryCall() = default;
+
+    UnaryCall(UnaryCall&&) = delete;
+    UnaryCall& operator=(UnaryCall&&) = delete;
+
+    CallContext& GetContext() noexcept { return context_; }
+    const CallContext& GetContext() const noexcept { return context_; }
+
+    void Perform() { CallWithRetries(); }
+
+    Response&& ExtractResponse() {
+        if (!done_) {
+            throw RpcCancelledError{state_.GetCallName(), "UnaryCall"};
+        }
+        if (!status_.ok()) {
+            ugrpc::client::ThrowErrorWithStatus(state_.GetCallName(), std::move(status_));
+        }
+        return std::move(response_);
+    }
+
+    void Abandon() { abandoned_ = true; }
+
+private:
+    void CallWithRetries() {
+        const utils::FastScopeGuard commit_state_guard([this]() noexcept { state_.Commit(); });
+
+        const auto task_deadline = USERVER_NAMESPACE::server::request::GetTaskInheritedDeadline();
+        const int max_attempts = call_options_.GetAttempts();
+        state_.GetSpan().AddTag(tracing::kMaxAttempts, max_attempts);
+
+        int attempt = 1;
+        RetryBackoff retry_backoff;
+
+        while (!engine::current_task::ShouldCancel()) {
+            state_.GetSpan().AddTag(tracing::kAttempts, attempt);
+            impl::SetupClientContext(state_, call_options_);
+
+            const bool completed = PerformAttempt();
+            if (!completed) {
+                break;
+            }
+
+            if (status_.ok()) {
+                OnDone(status_);
+                return;
+            }
+
+            if (max_attempts <= attempt || !IsRetryable(status_.error_code())) {
+                OnDone(status_);
+                return;
+            }
+
+            const auto delay = retry_backoff.NextAttemptDelay();
+            if (task_deadline.IsReachable() && task_deadline.TimeLeft() <= delay) {
+                OnDone(status_);
+                return;
+            }
+
+            ++attempt;
+            engine::InterruptibleSleepFor(delay);
+        }
+
+        OnCancelled();
+    }
+
+    std::unique_ptr<grpc::ClientAsyncResponseReader<Response>> StartCall() {
+        auto call = prepare_unary_call_(state_.GetStub(), &state_.GetClientContext(), request_, &state_.GetQueue());
+        call->StartCall();
+        return call;
+    }
+
+    bool PerformAttempt() {
+        RunStartCallHooks();
+
+        auto response_reader = StartCall();
+
+        ugrpc::impl::AsyncMethodInvocation invocation;
+        response_reader->Finish(&response_, &status_, invocation.GetCompletionTag());
+        const auto wait_status = invocation.Wait();
+        if (ugrpc::impl::AsyncMethodInvocation::WaitStatus::kCancelled == wait_status) {
+            state_.GetClientContext().TryCancel();
+            return false;
+        }
+
+        if (status_.ok() && ugrpc::impl::AsyncMethodInvocation::WaitStatus::kError == wait_status) {
+            // CompletionQueue returned ok=false. For Client-side Finish ok should always be true.
+            // If a GRPC status has been set despite ok=false, or if it has been set by a previous attempt, keep it.
+            // Otherwise, propagate ok=false to a failure status.
+            status_ = grpc::Status{grpc::StatusCode::INTERNAL, "Client-side Finish CompletionQueue status failed"};
+        }
+
+        RunFinishHooks(status_);
+
+        return true;
+    }
+
+    void RunStartCallHooks() { impl::RunMiddlewarePipeline(state_, StartCallHooks(ToBaseMessage(&request_))); }
+
+    void RunFinishHooks(const grpc::Status& status) {
+        impl::RunMiddlewarePipeline(state_, FinishHooks(status, ToBaseMessage(&response_)));
+    }
+
+    void OnDone(const grpc::Status& status) {
+        done_ = true;
+        impl::HandleCallStatistics(state_, status);
+        impl::SetStatusForSpan(state_.GetSpan(), status);
+    }
+
+    void OnCancelled() {
+        if (abandoned_) {
+            impl::SetErrorForSpan(state_.GetSpan(), "Call abandoned");
+        } else {
+            state_.GetStatsScope().OnCancelled();
+            impl::SetErrorForSpan(state_.GetSpan(), "Call cancelled");
+        }
+        state_.GetStatsScope().Flush();
+    }
+
+    CallOptions call_options_;
+    CallState state_;
+    CallContext context_;
+
+    PrepareUnaryCall prepare_unary_call_;
+    const Request& request_;
+
+    Response response_;
+    grpc::Status status_;
+    bool done_{false};
+
+    std::atomic<bool> abandoned_{false};
+};
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/qos.hpp b/grpc/include/userver/ugrpc/client/qos.hpp
index 148e782130fa..1309beea06fb 100644
--- a/grpc/include/userver/ugrpc/client/qos.hpp
+++ b/grpc/include/userver/ugrpc/client/qos.hpp
@@ -42,10 +42,6 @@ Qos Parse(const formats::json::Value& value, formats::parse::To<Qos>);
 
 formats::json::Value Serialize(const Qos& qos, formats::serialize::To<formats::json::Value>);
 
-std::optional<std::uint32_t> GetAttempts(const Qos& qos);
-
-std::optional<std::chrono::milliseconds> GetTotalTimeout(const Qos& qos);
-
 }  // namespace ugrpc::client
 
 USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/response_future.hpp b/grpc/include/userver/ugrpc/client/response_future.hpp
index 97ee5d66abdc..b02d5d0020f4 100644
--- a/grpc/include/userver/ugrpc/client/response_future.hpp
+++ b/grpc/include/userver/ugrpc/client/response_future.hpp
@@ -5,7 +5,7 @@
 
 #include <memory>
 
-#include <userver/ugrpc/client/impl/rpc.hpp>
+#include <userver/ugrpc/client/impl/async_unary_call_adapter.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -29,13 +29,13 @@ class [[nodiscard]] ResponseFuture final {
     /// @brief Checks if the asynchronous call has completed
     ///        Note, that once user gets result, IsReady should not be called
     /// @return true if result ready
-    [[nodiscard]] bool IsReady() const noexcept { return call_->GetFinishFuture().IsReady(); }
+    [[nodiscard]] bool IsReady() const { return impl_->IsReady(); }
 
     /// @brief Await response until specified timepoint
     ///
     /// @throws ugrpc::client::RpcError on an RPC error
-    [[nodiscard]] engine::FutureStatus WaitUntil(engine::Deadline deadline) const {
-        return call_->GetFinishFuture().WaitUntil(deadline);
+    [[nodiscard]] engine::FutureStatus WaitUntil(engine::Deadline deadline) const noexcept {
+        return impl_->WaitUntil(deadline);
     }
 
     /// @brief Await and read the response
@@ -47,13 +47,16 @@ class [[nodiscard]] ResponseFuture final {
     /// @returns the response on success
     /// @throws ugrpc::client::RpcError on an RPC error
     /// @throws ugrpc::client::RpcCancelledError on task cancellation
-    Response Get() { return call_->Finish(); }
+    Response Get() { return impl_->Get(); }
+
+    /// @brief Cancel call
+    void Cancel() { return impl_->Cancel(); }
 
     /// @brief Get call context, useful e.g. for accessing metadata.
-    CallContext& GetContext() { return call_->GetContext(); }
+    CallContext& GetContext() { return impl_->GetContext(); }
 
     /// @overload
-    const CallContext& GetContext() const { return call_->GetContext(); }
+    const CallContext& GetContext() const { return impl_->GetContext(); }
 
     /// @cond
     // For internal use only
@@ -63,17 +66,18 @@ class [[nodiscard]] ResponseFuture final {
         impl::PrepareUnaryCallProxy<Stub, Request, Response>&& prepare_unary_call,
         const Request& request
     )
-        : call_(std::make_unique<impl::UnaryCall<Response>>(std::move(params), std::move(prepare_unary_call), request)
-          ) {}
+        : impl_{std::make_unique<impl::AsyncUnaryCallAdapter<Stub, Request, Response>>(
+              std::move(params),
+              std::move(prepare_unary_call),
+              request
+          )} {}
 
     // For internal use only.
-    engine::impl::ContextAccessor* TryGetContextAccessor() noexcept {
-        return call_->GetFinishFuture().TryGetContextAccessor();
-    }
+    engine::impl::ContextAccessor* TryGetContextAccessor() noexcept { return impl_->TryGetContextAccessor(); }
     /// @endcond
 
 private:
-    std::unique_ptr<impl::UnaryCall<Response>> call_;
+    std::unique_ptr<impl::ResponseFutureImplBase<Response>> impl_;
 };
 
 }  // namespace ugrpc::client
diff --git a/grpc/include/userver/ugrpc/client/retry_config.hpp b/grpc/include/userver/ugrpc/client/retry_config.hpp
new file mode 100644
index 000000000000..939c21fac2ed
--- /dev/null
+++ b/grpc/include/userver/ugrpc/client/retry_config.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+/// @file userver/ugrpc/client/retry_config.hpp
+/// @brief @copybrief ugrpc::client::RetryConfig
+
+#include <userver/yaml_config/fwd.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client {
+
+/// Retry configuration for outgoing RPCs
+struct RetryConfig final {
+    /// The maximum number of RPC attempts, including the original attempt
+    int attempts{1};
+};
+
+RetryConfig Parse(const yaml_config::YamlConfig& value, formats::parse::To<RetryConfig>);
+
+}  // namespace ugrpc::client
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/client/simple_client_component.hpp b/grpc/include/userver/ugrpc/client/simple_client_component.hpp
index a73e3d3e5c3b..6a00f0ce00dc 100644
--- a/grpc/include/userver/ugrpc/client/simple_client_component.hpp
+++ b/grpc/include/userver/ugrpc/client/simple_client_component.hpp
@@ -77,7 +77,8 @@ class SimpleClientComponent : public impl::SimpleClientComponentAny {
         : SimpleClientComponentAny(config, context),
           client_(FindFactory(config, context).MakeClient<Client>(MakeClientSettings(config, nullptr))) {}
 
-    /// To use a ClientQos config,
+    /// To use a ClientQos config, derive from SimpleClientComponent and provide the parameter at construction:
+    /// @snippet samples/grpc_service/src/greeter_client.hpp  component
     SimpleClientComponent(
         const components::ComponentConfig& config,
         const components::ComponentContext& context,
@@ -86,7 +87,7 @@ class SimpleClientComponent : public impl::SimpleClientComponentAny {
         : SimpleClientComponentAny(config, context),
           client_(FindFactory(config, context).MakeClient<Client>(MakeClientSettings(config, &client_qos))) {}
 
-    /// @@brief Get gRPC service client
+    /// @brief Get gRPC service client
     Client& GetClient() { return client_; }
 
 private:
diff --git a/grpc/include/userver/ugrpc/client/stream.hpp b/grpc/include/userver/ugrpc/client/stream.hpp
index 77f0ee54ac75..91482f573781 100644
--- a/grpc/include/userver/ugrpc/client/stream.hpp
+++ b/grpc/include/userver/ugrpc/client/stream.hpp
@@ -15,11 +15,11 @@ namespace ugrpc::client {
 ///
 /// This class is not thread-safe except for `GetContext`.
 ///
-/// The RPC is cancelled on destruction unless the stream is closed (`Read` has
-/// returned `false`). In that case the connection is not closed (it will be
-/// reused for new RPCs), and the server receives `RpcInterruptedError`
-/// immediately. gRPC provides no way to early-close a server-streaming RPC
-/// gracefully.
+/// The RPC should be completed by reading until @ref ugrpc::client::Reader::Read returns `false`.
+/// If destroyed early, the RPC is cancelled. The server gets @ref ugrpc::client::RpcInterruptedError
+/// and the `abandoned-error` metric is incremented. The connection stays open for reuse.
+/// gRPC provides no way to early-close a server-streaming RPC gracefully.
+/// See @ref ugrpc::client::ReadRemainingAndFinish for graceful completion.
 template <class Response>
 class [[nodiscard]] Reader final {
 public:
@@ -62,9 +62,9 @@ class [[nodiscard]] Reader final {
 ///
 /// This class is not thread-safe except for `GetContext`.
 ///
-/// The RPC is cancelled on destruction unless `Finish` has been called. In that
-/// case the connection is not closed (it will be reused for new RPCs), and the
-/// server receives `RpcInterruptedError` immediately.
+/// The RPC should be completed by calling @ref ugrpc::client::Writer::Finish.
+/// If destroyed early, the RPC is cancelled. The server gets @ref ugrpc::client::RpcInterruptedError
+/// and the `abandoned-error` metric is incremented. When properly finished, the connection stays open for reuse.
 template <typename Request, typename Response>
 class [[nodiscard]] Writer final {
 public:
@@ -141,11 +141,11 @@ class [[nodiscard]] Writer final {
 ///
 /// `WriteAndCheck` is NOT thread-safe.
 ///
-/// The RPC is cancelled on destruction unless the stream is closed (`Read` has
-/// returned `false`). In that case the connection is not closed (it will be
-/// reused for new RPCs), and the server receives `RpcInterruptedError`
-/// immediately. gRPC provides no way to early-close a server-streaming RPC
-/// gracefully.
+/// The RPC should be completed by reading until @ref ugrpc::client::Reader::Read returns `false`.
+/// If destroyed early, the RPC is cancelled. The server gets @ref ugrpc::client::RpcInterruptedError
+/// and the `abandoned-error` metric is incremented. The connection stays open for reuse.
+/// gRPC provides no way to early-close a server-streaming RPC gracefully.
+// See @ref ugrpc::client::ReadRemainingAndFinish and @ref ugrpc::client::PingPongFinish for graceful completion.
 ///
 /// `Read` and `AsyncRead` can throw if error status is received from server.
 /// User MUST NOT call `Read` or `AsyncRead` again after failure of any of these
diff --git a/grpc/include/userver/ugrpc/impl/rpc_type.hpp b/grpc/include/userver/ugrpc/impl/rpc_type.hpp
new file mode 100644
index 000000000000..9d4709ccab22
--- /dev/null
+++ b/grpc/include/userver/ugrpc/impl/rpc_type.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::impl {
+
+/// Type categorizes RPCs by unary or streaming type
+enum class RpcType {
+    kUnary,
+    kClientStreaming,
+    kServerStreaming,
+    kBidiStreaming,
+};
+
+}  // namespace ugrpc::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/impl/static_service_metadata.hpp b/grpc/include/userver/ugrpc/impl/static_service_metadata.hpp
index 738892f83cbb..0ee74f541e4e 100644
--- a/grpc/include/userver/ugrpc/impl/static_service_metadata.hpp
+++ b/grpc/include/userver/ugrpc/impl/static_service_metadata.hpp
@@ -5,35 +5,46 @@
 
 #include <userver/utils/span.hpp>
 
+#include <userver/ugrpc/impl/rpc_type.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::impl {
 
+/// Descriptor of an RPC method
+struct MethodDescriptor final {
+    std::string_view method_full_name;
+    RpcType method_type;
+};
+
 /// Per-gRPC-service statically generated data
 struct StaticServiceMetadata final {
     std::string_view service_full_name;
-    utils::span<const std::string_view> method_full_names;
+    utils::span<const MethodDescriptor> methods;
 };
 
 template <typename GrpcppService>
-constexpr StaticServiceMetadata MakeStaticServiceMetadata(utils::span<const std::string_view> method_full_names
-) noexcept {
-    return {GrpcppService::service_full_name(), method_full_names};
+constexpr StaticServiceMetadata MakeStaticServiceMetadata(utils::span<const MethodDescriptor> methods) noexcept {
+    return {GrpcppService::service_full_name(), methods};
 }
 
 constexpr std::size_t GetMethodsCount(const StaticServiceMetadata& metadata) noexcept {
-    return metadata.method_full_names.size();
+    return metadata.methods.size();
 }
 
 constexpr std::string_view GetMethodFullName(const StaticServiceMetadata& metadata, std::size_t method_id) {
-    return metadata.method_full_names[method_id];
+    return metadata.methods[method_id].method_full_name;
 }
 
 constexpr std::string_view GetMethodName(const StaticServiceMetadata& metadata, std::size_t method_id) {
-    const auto& method_full_name = metadata.method_full_names[method_id];
+    auto method_full_name = GetMethodFullName(metadata, method_id);
     return method_full_name.substr(metadata.service_full_name.size() + 1);
 }
 
+constexpr RpcType GetMethodType(const StaticServiceMetadata& metadata, std::size_t method_id) {
+    return metadata.methods[method_id].method_type;
+}
+
 std::optional<std::size_t>
 FindMethod(const ugrpc::impl::StaticServiceMetadata& metadata, std::string_view method_full_name);
 
diff --git a/grpc/include/userver/ugrpc/protobuf_logging.hpp b/grpc/include/userver/ugrpc/protobuf_logging.hpp
new file mode 100644
index 000000000000..15553b113b2e
--- /dev/null
+++ b/grpc/include/userver/ugrpc/protobuf_logging.hpp
@@ -0,0 +1,91 @@
+#pragma once
+
+/// @file
+/// @brief Public API for protobuf logging utilities.
+
+#include <fmt/format.h>
+#include <google/protobuf/message.h>
+#include <grpcpp/support/status.h>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc {
+
+inline constexpr std::size_t kDefaultDebugStringLimit = 1024;
+
+/// @brief Convert protobuf message to limited debug string for logging.
+///
+/// Differences from built-in `DebugString`:
+/// - Fields marked with `[debug_redact]` option are hidden (`DebugString` only does so since Protobuf v30).
+/// - When the character limit is reached, serialization stops immediately (`DebugString` still wastes CPU on
+/// serializing the entire message regardless).
+///
+/// @param message The protobuf message to convert.
+/// @param limit Maximum size of the resulting string.
+/// Avoid setting this to very large values as it may cause OOM (Out of Memory) issues.
+/// @returns String representation of the message, truncated if necessary.
+///
+/// @warning This is a debug representation of protobuf that is unstable and should only be used for diagnostics.
+/// The order of keys in maps is unstable; the format itself can change even within a single run.
+/// You CANNOT parse back from this debug text representation.
+/// You CANNOT use it for equality match with reference values in gtest.
+std::string ToLimitedDebugString(const google::protobuf::Message& message, std::size_t limit);
+
+/// @brief Convert protobuf message to unlimited debug string for logging.
+///
+/// Differences from built-in `DebugString`:
+/// - Fields marked with `[debug_redact]` option are hidden (`DebugString` only does so since Protobuf v30).
+///
+/// @param message The protobuf message to convert.
+/// @returns String representation of the message.
+///
+/// @warning This is a debug representation of protobuf that is unstable and should only be used for diagnostics.
+/// The order of keys in maps is unstable; the format itself can change even within a single run.
+/// You CANNOT parse back from this debug text representation.
+/// You CANNOT use it for equality match with reference values in gtest.
+std::string ToUnlimitedDebugString(const google::protobuf::Message& message);
+
+/// @brief Get error details from `grpc::Status` for logging with size limit.
+/// @param status The `grpc::Status` to extract details from.
+/// @param max_size Maximum size of the resulting string.
+/// Avoid setting this to very large values as it may cause OOM (Out of Memory) issues.
+/// @returns String representation of error details, truncated if necessary.
+///
+/// @warning This is a debug representation of protobuf that is unstable and should only be used for diagnostics.
+/// The order of keys in maps is unstable; the format itself can change even within a single run.
+/// You CANNOT parse back from this debug text representation.
+/// You CANNOT use it for equality match with reference values in gtest.
+std::string ToLimitedDebugString(const grpc::Status& status, std::size_t max_size = kDefaultDebugStringLimit);
+
+/// @brief Get error details from `grpc::Status` for logging without size limit.
+/// @param status The `grpc::Status` to extract details from.
+/// @returns String representation of error details.
+///
+/// @warning This is a debug representation of protobuf that is unstable and should only be used for diagnostics.
+/// The order of keys in maps is unstable; the format itself can change even within a single run.
+/// You CANNOT parse back from this debug text representation.
+/// You CANNOT use it for equality match with reference values in gtest.
+std::string ToUnlimitedDebugString(const grpc::Status& status);
+
+}  // namespace ugrpc
+
+USERVER_NAMESPACE_END
+
+namespace fmt {
+
+/// @brief `fmt::format` support for protobuf messages
+template <typename T>
+struct formatter<T, typename std::enable_if_t<std::is_base_of_v<google::protobuf::Message, std::decay_t<T>>, char>> {
+    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
+
+    template <typename FormatContext>
+    auto format(const T& message, FormatContext& ctx) const {
+        return fmt::format_to(
+            ctx.out(),
+            "{}",
+            USERVER_NAMESPACE::ugrpc::ToLimitedDebugString(message, USERVER_NAMESPACE::ugrpc::kDefaultDebugStringLimit)
+        );
+    }
+};
+
+}  // namespace fmt
diff --git a/grpc/include/userver/ugrpc/server/impl/call_state.hpp b/grpc/include/userver/ugrpc/server/impl/call_state.hpp
index e4775495af41..31e2ab7772e9 100644
--- a/grpc/include/userver/ugrpc/server/impl/call_state.hpp
+++ b/grpc/include/userver/ugrpc/server/impl/call_state.hpp
@@ -17,6 +17,7 @@
 #include <userver/ugrpc/server/impl/call_kind.hpp>
 #include <userver/ugrpc/server/middlewares/fwd.hpp>
 #include <userver/ugrpc/server/storage_context.hpp>
+#include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -37,6 +38,7 @@ struct CallParams {
     std::optional<tracing::InPlaceSpan>& span_storage;
     const Middlewares& middlewares;
     const dynamic_config::Source& config_source;
+    const boost::container::flat_map<grpc::StatusCode, logging::Level>& status_codes_log_level;
 };
 
 // Non-templated state of CallProcessor. Can be non-movable.
diff --git a/grpc/include/userver/ugrpc/server/impl/service_internals.hpp b/grpc/include/userver/ugrpc/server/impl/service_internals.hpp
index 95691cb39d2e..ae47cb5e2f83 100644
--- a/grpc/include/userver/ugrpc/server/impl/service_internals.hpp
+++ b/grpc/include/userver/ugrpc/server/impl/service_internals.hpp
@@ -1,10 +1,14 @@
 #pragma once
 
+#include <boost/container/flat_map.hpp>
+
 #include <userver/dynamic_config/source.hpp>
 #include <userver/engine/task/task_processor_fwd.hpp>
 #include <userver/logging/fwd.hpp>
+#include <userver/logging/level.hpp>
 
 #include <userver/ugrpc/server/middlewares/fwd.hpp>
+#include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -23,6 +27,7 @@ struct ServiceInternals final {
     ugrpc::impl::StatisticsStorage& statistics_storage;
     Middlewares middlewares;
     const dynamic_config::Source config_source;
+    boost::container::flat_map<grpc::StatusCode, logging::Level> status_codes_log_level;
 };
 
 }  // namespace ugrpc::server::impl
diff --git a/grpc/include/userver/ugrpc/server/impl/service_worker_impl.hpp b/grpc/include/userver/ugrpc/server/impl/service_worker_impl.hpp
index 4406f8868876..66cc227525ec 100644
--- a/grpc/include/userver/ugrpc/server/impl/service_worker_impl.hpp
+++ b/grpc/include/userver/ugrpc/server/impl/service_worker_impl.hpp
@@ -170,6 +170,7 @@ class CallData final {
                 span_storage_,
                 method_data_.service_data.internals.middlewares,
                 method_data_.service_data.internals.config_source,
+                method_data_.service_data.internals.status_codes_log_level,
             },
             raw_responder_,
             initial_request_,
@@ -233,13 +234,13 @@ class ServiceWorkerImpl final : public ServiceWorker {
 template <typename GrpcppService, typename Service, typename... ServiceMethods>
 std::unique_ptr<ServiceWorker> MakeServiceWorker(
     ServiceInternals&& internals,
-    const std::array<std::string_view, sizeof...(ServiceMethods)>& method_full_names,
+    const std::array<ugrpc::impl::MethodDescriptor, sizeof...(ServiceMethods)>& methods,
     Service& service,
     ServiceMethods... service_methods
 ) {
     return std::make_unique<ServiceWorkerImpl<GrpcppService>>(
         std::move(internals),
-        ugrpc::impl::MakeStaticServiceMetadata<GrpcppService>(method_full_names),
+        ugrpc::impl::MakeStaticServiceMetadata<GrpcppService>(methods),
         service,
         service_methods...
     );
diff --git a/grpc/include/userver/ugrpc/server/middlewares/access_log/component.hpp b/grpc/include/userver/ugrpc/server/middlewares/access_log/component.hpp
index 3d21b8fb2bd1..4f9d0fb3ad3e 100644
--- a/grpc/include/userver/ugrpc/server/middlewares/access_log/component.hpp
+++ b/grpc/include/userver/ugrpc/server/middlewares/access_log/component.hpp
@@ -14,6 +14,10 @@ USERVER_NAMESPACE_BEGIN
 /// @see @ref ugrpc::server::middlewares::access_log::Component
 namespace ugrpc::server::middlewares::access_log {
 
+/// @brief Storage to handle additional fields in access_log
+/// @snippet grpc/tests/logging_test.cpp grpc log extra tag
+inline const utils::AnyStorageDataTag<ugrpc::server::StorageContext, logging::LogExtra> kLogExtraTag;
+
 /// @ingroup userver_components userver_base_classes
 ///
 /// @brief gRPC server access log middleware component. Writes one TSKV log line per handled RPC in a static format.
diff --git a/grpc/include/userver/ugrpc/server/middlewares/access_log/log_extra.hpp b/grpc/include/userver/ugrpc/server/middlewares/access_log/log_extra.hpp
new file mode 100644
index 000000000000..03b489c548a3
--- /dev/null
+++ b/grpc/include/userver/ugrpc/server/middlewares/access_log/log_extra.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <userver/logging/log_extra.hpp>
+#include <userver/ugrpc/server/middlewares/base.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::server::middlewares::access_log {
+/// @brief Adds or extends log extra fields for gRPC access logging
+/// @param context Middleware call context containing the storage
+/// @param log_extra Additional log fields to add (will be moved from)
+/// @snippet grpc/tests/logging_test.cpp grpc log extra tag
+///
+/// If log extra fields already exist in the context, extends them with new fields.
+/// Otherwise, creates new log extra storage with the provided fields.
+void SetAdditionalLogKeys(MiddlewareCallContext& context, logging::LogExtra&& log_extra);
+}  // namespace ugrpc::server::middlewares::access_log
+
+USERVER_NAMESPACE_END
diff --git a/grpc/include/userver/ugrpc/server/middlewares/log/component.hpp b/grpc/include/userver/ugrpc/server/middlewares/log/component.hpp
index b23113c26d2d..fa8b850cb92a 100644
--- a/grpc/include/userver/ugrpc/server/middlewares/log/component.hpp
+++ b/grpc/include/userver/ugrpc/server/middlewares/log/component.hpp
@@ -29,6 +29,7 @@ namespace ugrpc::server::middlewares::log {
 /// msg-log-level | logging level to use for request and response messages themselves | debug
 /// msg-size-log-limit | max message size to log, the rest will be truncated | 512
 /// local-log-level | local log level of the span for user-provided handler | debug
+/// status-codes-log-level | gRPC status code string -> response log level map | {}
 ///
 /// ## Static configuration example:
 ///
diff --git a/grpc/include/userver/ugrpc/server/service_base.hpp b/grpc/include/userver/ugrpc/server/service_base.hpp
index 95850246ee3d..6b366a8e25d9 100644
--- a/grpc/include/userver/ugrpc/server/service_base.hpp
+++ b/grpc/include/userver/ugrpc/server/service_base.hpp
@@ -3,11 +3,14 @@
 /// @file userver/ugrpc/server/service_base.hpp
 /// @brief @copybrief ugrpc::server::ServiceBase
 
+#include <boost/container/flat_map.hpp>
+
 #include <userver/engine/task/task_processor_fwd.hpp>
 
 #include <userver/ugrpc/server/call_context.hpp>
 #include <userver/ugrpc/server/impl/service_worker.hpp>
 #include <userver/ugrpc/server/middlewares/fwd.hpp>
+#include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -24,6 +27,10 @@ struct ServiceConfig final {
 
     /// Server middlewares to use for the gRPC service.
     Middlewares middlewares;
+
+    /// map of "status_code": log_level items to override span log level for specific status codes
+    /// see @ref ugrpc::kStatusCodesMap for available statuses
+    boost::container::flat_map<grpc::StatusCode, logging::Level> status_codes_log_level;
 };
 
 /// @brief The type-erased base class for all gRPC service implementations
diff --git a/grpc/include/userver/ugrpc/server/service_component_base.hpp b/grpc/include/userver/ugrpc/server/service_component_base.hpp
index 32fb85890b20..b42ce93b241f 100644
--- a/grpc/include/userver/ugrpc/server/service_component_base.hpp
+++ b/grpc/include/userver/ugrpc/server/service_component_base.hpp
@@ -43,6 +43,7 @@ using MiddlewareRunnerComponentBase = USERVER_NAMESPACE::middlewares::RunnerComp
 /// disable-user-pipeline-middlewares | flag to disable `groups::User` middlewares from pipeline | false
 /// disable-all-pipeline-middlewares | flag to disable all middlewares from pipeline | false
 /// middlewares | middlewares names to use | `{}` (use server defaults)
+/// status-codes-log-level | gRPC status code string -> span log level map | {}
 
 // clang-format on
 
diff --git a/grpc/include/userver/ugrpc/status_codes.hpp b/grpc/include/userver/ugrpc/status_codes.hpp
index 0017ae8bcb66..cb394fa7afe3 100644
--- a/grpc/include/userver/ugrpc/status_codes.hpp
+++ b/grpc/include/userver/ugrpc/status_codes.hpp
@@ -5,6 +5,9 @@
 
 #include <grpcpp/support/status.h>
 
+#include <userver/formats/json_fwd.hpp>
+#include <userver/yaml_config/fwd.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc {
@@ -34,4 +37,20 @@ bool IsServerError(grpc::StatusCode code) noexcept;
 
 }  // namespace ugrpc
 
+namespace formats::parse {
+
+/// @ref yaml_config::YamlConfig parsing support for `grpc::StatusCode`.
+grpc::StatusCode Parse(const yaml_config::YamlConfig& value, To<grpc::StatusCode>);
+
+/// Support for parsing `grpc::StatusCode` from string. Used for headers and map keys.
+grpc::StatusCode Parse(std::string_view value, To<grpc::StatusCode>);
+
+}  // namespace formats::parse
+
+namespace formats::serialize {
+
+formats::json::Value Serialize(const grpc::StatusCode& value, formats::serialize::To<formats::json::Value>);
+
+}
+
 USERVER_NAMESPACE_END
diff --git a/grpc/library.yaml b/grpc/library.yaml
index 5a346b676fbe..c5e8c0277f57 100644
--- a/grpc/library.yaml
+++ b/grpc/library.yaml
@@ -10,5 +10,6 @@ libraries:
 
 configs:
     names:
+      - EGRESS_GRPC_PROXY_ENABLED
       - USERVER_GRPC_CLIENT_ENABLE_DEADLINE_PROPAGATION
       - USERVER_GRPC_SERVER_CANCEL_TASK_BY_DEADLINE
diff --git a/grpc/src/ugrpc/client/call_context.cpp b/grpc/src/ugrpc/client/call_context.cpp
index dd91907fff08..5d0edb0ec3e0 100644
--- a/grpc/src/ugrpc/client/call_context.cpp
+++ b/grpc/src/ugrpc/client/call_context.cpp
@@ -8,9 +8,9 @@ USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client {
 
-CallContext::CallContext(utils::impl::InternalTag, impl::CallState& state) : state_(state) {}
+CallContext::CallContext(utils::impl::InternalTag, impl::CallState& state) noexcept : state_(state) {}
 
-grpc::ClientContext& CallContext::GetClientContext() noexcept { return state_.GetClientContext(); }
+grpc::ClientContext& CallContext::GetClientContext() { return state_.GetClientContextCommitted(); }
 
 std::string_view CallContext::GetClientName() const noexcept { return state_.GetClientName(); }
 
diff --git a/grpc/src/ugrpc/client/call_options.cpp b/grpc/src/ugrpc/client/call_options.cpp
index 3ac05ed2c9d0..ace162e7f8b2 100644
--- a/grpc/src/ugrpc/client/call_options.cpp
+++ b/grpc/src/ugrpc/client/call_options.cpp
@@ -6,18 +6,18 @@ USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client {
 
-void CallOptions::AddMetadata(std::string_view meta_key, std::string_view meta_value) {
-    metadata_.emplace_back(ugrpc::impl::ToGrpcString(meta_key), ugrpc::impl::ToGrpcString(meta_value));
-}
-
-// void CallOptions::SetAttempts(int attempts) { attempts_ = attempts; }
+void CallOptions::SetAttempts(int attempts) { attempts_ = attempts; }
 
-// int CallOptions::GetAttempts() const { return attempts_; }
+int CallOptions::GetAttempts() const { return attempts_; }
 
 void CallOptions::SetTimeout(std::chrono::milliseconds timeout) { timeout_ = timeout; }
 
 std::chrono::milliseconds CallOptions::GetTimeout() const { return timeout_; }
 
+void CallOptions::AddMetadata(std::string_view meta_key, std::string_view meta_value) {
+    metadata_.emplace_back(ugrpc::impl::ToGrpcString(meta_key), ugrpc::impl::ToGrpcString(meta_value));
+}
+
 void CallOptions::SetClientContextFactory(ClientContextFactory&& client_context_factory) {
     client_context_factory_ = std::move(client_context_factory);
 }
diff --git a/grpc/src/ugrpc/client/channels.cpp b/grpc/src/ugrpc/client/channels.cpp
index 5227c7a68697..1aee55a60456 100644
--- a/grpc/src/ugrpc/client/channels.cpp
+++ b/grpc/src/ugrpc/client/channels.cpp
@@ -7,6 +7,7 @@
 #include <userver/engine/async.hpp>
 #include <userver/engine/get_all.hpp>
 
+#include <userver/ugrpc/client/impl/client_data.hpp>
 #include <userver/ugrpc/impl/async_method_invocation.hpp>
 #include <userver/ugrpc/impl/to_string.hpp>
 #include <userver/ugrpc/time_utils.hpp>
@@ -37,7 +38,7 @@ DoTryWaitForConnected(grpc::Channel& channel, grpc::CompletionQueue& queue, engi
 }  // namespace
 
 [[nodiscard]] bool TryWaitForConnected(
-    ClientData& client_data,
+    const ClientData& client_data,
     engine::Deadline deadline,
     engine::TaskProcessor& blocking_task_processor
 ) {
diff --git a/grpc/src/ugrpc/client/client_factory.cpp b/grpc/src/ugrpc/client/client_factory.cpp
index 10b4c785b1f1..a2365ebec873 100644
--- a/grpc/src/ugrpc/client/client_factory.cpp
+++ b/grpc/src/ugrpc/client/client_factory.cpp
@@ -56,6 +56,7 @@ impl::ClientInternals ClientFactory::MakeClientInternals(
         client_factory_settings_.channel_count,
         std::move(client_settings.dedicated_methods_config),
         std::move(channel_factory),
+        client_factory_settings_.retry_config,
         client_factory_settings_.channel_args,
         client_factory_settings_.default_service_config,
     };
diff --git a/grpc/src/ugrpc/client/client_factory_component.cpp b/grpc/src/ugrpc/client/client_factory_component.cpp
index ce863439f058..dc6000f41a0c 100644
--- a/grpc/src/ugrpc/client/client_factory_component.cpp
+++ b/grpc/src/ugrpc/client/client_factory_component.cpp
@@ -3,13 +3,17 @@
 #include <userver/components/component_config.hpp>
 #include <userver/components/component_context.hpp>
 #include <userver/dynamic_config/storage/component.hpp>
+#include <userver/logging/log.hpp>
 #include <userver/storages/secdist/component.hpp>
 #include <userver/testsuite/testsuite_support.hpp>
 #include <userver/yaml_config/merge_schemas.hpp>
 
-#include <ugrpc/client/impl/client_factory_config.hpp>
 #include <userver/ugrpc/client/common_component.hpp>
 #include <userver/ugrpc/client/middlewares/pipeline.hpp>
+#include <userver/ugrpc/impl/to_string.hpp>
+
+#include <ugrpc/client/impl/client_factory_config.hpp>
+#include <ugrpc/client/secdist.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -24,6 +28,43 @@ const storages::secdist::SecdistConfig* GetSecdist(const components::ComponentCo
     return nullptr;
 }
 
+std::shared_ptr<grpc::ChannelCredentials>
+MakeCredentials(impl::AuthType auth_type, const grpc::SslCredentialsOptions& ssl_credentials_options) {
+    if (auth_type == impl::AuthType::kSsl) {
+        LOG_INFO() << "GRPC client (SSL) initialized...";
+        return grpc::SslCredentials(ssl_credentials_options);
+    } else {
+        LOG_INFO() << "GRPC client (non SSL) initialized...";
+        return grpc::InsecureChannelCredentials();
+    }
+}
+
+ClientFactorySettings
+MakeClientFactorySettings(impl::ClientFactoryConfig&& config, const storages::secdist::SecdistConfig* secdist) {
+    std::shared_ptr<grpc::ChannelCredentials> credentials =
+        MakeCredentials(config.auth_type, config.ssl_credentials_options);
+    std::unordered_map<std::string, std::shared_ptr<grpc::ChannelCredentials>> client_credentials;
+
+    if (secdist) {
+        const auto& tokens = secdist->Get<Secdist>();
+
+        for (const auto& [client_name, token] : tokens.tokens) {
+            client_credentials[client_name] = grpc::CompositeChannelCredentials(
+                credentials, grpc::AccessTokenCredentials(ugrpc::impl::ToGrpcString(token))
+            );
+        }
+    }
+
+    return ClientFactorySettings{
+        std::move(credentials),
+        std::move(client_credentials),
+        std::move(config.retry_config),
+        std::move(config.channel_args),
+        std::move(config.default_service_config),
+        config.channel_count,
+    };
+}
+
 }  // namespace
 
 ClientFactoryComponent::ClientFactoryComponent(
@@ -44,7 +85,7 @@ ClientFactoryComponent::ClientFactoryComponent(
     const auto* secdist = GetSecdist(context);
 
     factory_.emplace(
-        MakeFactorySettings(std::move(factory_config), secdist),
+        MakeClientFactorySettings(std::move(factory_config), secdist),
         client_common_component.blocking_task_processor_,
         *this,  // impl::PipelineCreatorInterface&
         client_common_component.completion_queues_,
@@ -87,6 +128,17 @@ additionalProperties: false
                 type: string
                 description: The path to file containing the PEM encoding of the client's certificate chain
                 defaultDescription: absent
+    retry-config:
+        type: object
+        description: Retry configuration for outgoing RPCs
+        defaultDescription: '{}'
+        additionalProperties: false
+        properties:
+            attempts:
+                type: integer
+                description: The maximum number of RPC attempts, including the original attempt
+                defaultDescription: 1
+                minimum: 1
     channel-args:
         type: object
         description: a map of channel arguments, see gRPC Core docs
diff --git a/grpc/src/ugrpc/client/generic_client.cpp b/grpc/src/ugrpc/client/generic_client.cpp
index 28c29ce5f4ea..b49860e89c31 100644
--- a/grpc/src/ugrpc/client/generic_client.cpp
+++ b/grpc/src/ugrpc/client/generic_client.cpp
@@ -5,6 +5,7 @@
 #include <grpcpp/generic/generic_stub.h>
 
 #include <userver/ugrpc/client/impl/call_params.hpp>
+#include <userver/ugrpc/client/impl/client_data.hpp>
 #include <userver/ugrpc/client/impl/perform_unary_call.hpp>
 #include <userver/utils/algo.hpp>
 
@@ -21,12 +22,18 @@ struct GenericService final {
 }  // namespace
 
 GenericClient::GenericClient(impl::ClientInternals&& internals)
-    : impl_(std::move(internals), impl::GenericClientTag{}, std::in_place_type<GenericService>) {
+    : client_data_(std::move(internals), impl::GenericClientTag{}, std::in_place_type<GenericService>) {
     // There is no technical reason why QOS configs should be unsupported here.
     // However, it would be difficult to detect non-existent RPC names in QOS.
-    UINVARIANT(!impl_.GetClientQos(), "Client QOS configs are unsupported for generic services");
+    UINVARIANT(!client_data_->GetClientQos(), "Client QOS configs are unsupported for generic services");
 }
 
+GenericClient::GenericClient(GenericClient&&) noexcept = default;
+
+GenericClient& GenericClient::operator=(GenericClient&&) noexcept = default;
+
+GenericClient::~GenericClient() = default;
+
 ResponseFuture<grpc::ByteBuffer> GenericClient::AsyncUnaryCall(
     std::string_view call_name,
     const grpc::ByteBuffer& request,
@@ -35,7 +42,7 @@ ResponseFuture<grpc::ByteBuffer> GenericClient::AsyncUnaryCall(
 ) const {
     auto method_name = utils::StrCat<grpc::string>("/", call_name);
     return {
-        impl::CreateGenericCallParams(impl_, call_name, std::move(call_options), std::move(generic_options)),
+        impl::CreateGenericCallParams(*client_data_, call_name, std::move(call_options), std::move(generic_options)),
         impl::PrepareUnaryCallProxy(&grpc::GenericStub::PrepareUnaryCall, std::move(method_name)),
         request,
     };
@@ -49,7 +56,7 @@ grpc::ByteBuffer GenericClient::UnaryCall(
 ) const {
     auto method_name = utils::StrCat<grpc::string>("/", call_name);
     return impl::PerformUnaryCall(
-        impl::CreateGenericCallParams(impl_, call_name, std::move(call_options), std::move(generic_options)),
+        impl::CreateGenericCallParams(*client_data_, call_name, std::move(call_options), std::move(generic_options)),
         impl::PrepareUnaryCallProxy(&grpc::GenericStub::PrepareUnaryCall, std::move(method_name)),
         request
     );
diff --git a/grpc/src/ugrpc/client/impl/async_methods.cpp b/grpc/src/ugrpc/client/impl/async_methods.cpp
deleted file mode 100644
index d4fc019c47bf..000000000000
--- a/grpc/src/ugrpc/client/impl/async_methods.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include <userver/ugrpc/client/impl/async_methods.hpp>
-
-#include <fmt/format.h>
-
-#include <userver/ugrpc/client/exceptions.hpp>
-#include <userver/ugrpc/client/impl/middleware_pipeline.hpp>
-#include <userver/ugrpc/client/impl/tracing.hpp>
-
-USERVER_NAMESPACE_BEGIN
-
-namespace ugrpc::client::impl {
-
-namespace {
-
-void SetStatusAndResetSpan(CallState& state, const grpc::Status& status) noexcept {
-    SetStatusForSpan(state.GetSpan(), status);
-    state.ResetSpan();
-}
-
-void SetErrorAndResetSpan(CallState& state, std::string_view error_message) noexcept {
-    SetErrorForSpan(state.GetSpan(), error_message);
-    state.ResetSpan();
-}
-
-}  // namespace
-
-ugrpc::impl::AsyncMethodInvocation::WaitStatus WaitAndTryCancelIfNeeded(
-    ugrpc::impl::AsyncMethodInvocation& invocation,
-    engine::Deadline deadline,
-    grpc::ClientContext& context
-) noexcept {
-    const auto wait_status = invocation.WaitUntil(deadline);
-    if (ugrpc::impl::AsyncMethodInvocation::WaitStatus::kCancelled == wait_status) {
-        context.TryCancel();
-    }
-    return wait_status;
-}
-
-ugrpc::impl::AsyncMethodInvocation::WaitStatus
-WaitAndTryCancelIfNeeded(ugrpc::impl::AsyncMethodInvocation& invocation, grpc::ClientContext& context) noexcept {
-    return WaitAndTryCancelIfNeeded(invocation, engine::Deadline{}, context);
-}
-
-void ProcessFinish(CallState& state, const google::protobuf::Message* final_response) {
-    const auto& status = state.GetStatus();
-
-    HandleCallStatistics(state, status);
-
-    RunMiddlewarePipeline(state, FinishHooks(status, final_response));
-
-    SetStatusAndResetSpan(state, status);
-}
-
-void ProcessFinishAbandoned(CallState& state) noexcept { SetStatusAndResetSpan(state, state.GetStatus()); }
-
-void ProcessCancelled(CallState& state, std::string_view stage) noexcept {
-    state.GetStatsScope().OnCancelled();
-    state.GetStatsScope().Flush();
-    SetErrorAndResetSpan(state, fmt::format("Task cancellation at '{}'", stage));
-}
-
-void ProcessNetworkError(CallState& state, std::string_view stage) noexcept {
-    state.GetStatsScope().OnNetworkError();
-    state.GetStatsScope().Flush();
-    SetErrorAndResetSpan(state, fmt::format("Network error at '{}'", stage));
-}
-
-void CheckFinishStatus(CallState& state) {
-    auto& status = state.GetStatus();
-    if (!status.ok()) {
-        ThrowErrorWithStatus(state.GetCallName(), std::move(status));
-    }
-}
-
-}  // namespace ugrpc::client::impl
-
-USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/async_stream_methods.cpp b/grpc/src/ugrpc/client/impl/async_stream_methods.cpp
index 0ad61c05f600..4e4be99f7247 100644
--- a/grpc/src/ugrpc/client/impl/async_stream_methods.cpp
+++ b/grpc/src/ugrpc/client/impl/async_stream_methods.cpp
@@ -1,9 +1,38 @@
 #include <userver/ugrpc/client/impl/async_stream_methods.hpp>
 
+#include <fmt/format.h>
+
+#include <userver/ugrpc/client/exceptions.hpp>
+#include <userver/ugrpc/client/impl/middleware_pipeline.hpp>
+#include <userver/ugrpc/client/impl/tracing.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client::impl {
 
+namespace {
+
+void SetStatusAndResetSpan(CallState& state, const grpc::Status& status) noexcept {
+    SetStatusForSpan(state.GetSpan(), status);
+    state.ResetSpan();
+}
+
+void SetErrorAndResetSpan(CallState& state, std::string_view error_message) noexcept {
+    SetErrorForSpan(state.GetSpan(), error_message);
+    state.ResetSpan();
+}
+
+}  // namespace
+
+ugrpc::impl::AsyncMethodInvocation::WaitStatus
+WaitAndTryCancelIfNeeded(ugrpc::impl::AsyncMethodInvocation& invocation, grpc::ClientContext& context) noexcept {
+    const auto wait_status = invocation.Wait();
+    if (ugrpc::impl::AsyncMethodInvocation::WaitStatus::kCancelled == wait_status) {
+        context.TryCancel();
+    }
+    return wait_status;
+}
+
 void CheckOk(StreamingCallState& state, ugrpc::impl::AsyncMethodInvocation::WaitStatus status, std::string_view stage) {
     if (status == ugrpc::impl::AsyncMethodInvocation::WaitStatus::kError) {
         state.SetFinished();
@@ -16,6 +45,37 @@ void CheckOk(StreamingCallState& state, ugrpc::impl::AsyncMethodInvocation::Wait
     }
 }
 
+void CheckFinishStatus(CallState& state) {
+    auto& status = state.GetStatus();
+    if (!status.ok()) {
+        ThrowErrorWithStatus(state.GetCallName(), std::move(status));
+    }
+}
+
+void ProcessFinish(CallState& state, const google::protobuf::Message* final_response) {
+    const auto& status = state.GetStatus();
+
+    HandleCallStatistics(state, status);
+
+    RunMiddlewarePipeline(state, FinishHooks(status, final_response));
+
+    SetStatusAndResetSpan(state, status);
+}
+
+void ProcessFinishAbandoned(CallState& state) noexcept { SetStatusAndResetSpan(state, state.GetStatus()); }
+
+void ProcessCancelled(CallState& state, std::string_view stage) noexcept {
+    state.GetStatsScope().OnCancelled();
+    state.GetStatsScope().Flush();
+    SetErrorAndResetSpan(state, fmt::format("Task cancellation at '{}'", stage));
+}
+
+void ProcessNetworkError(CallState& state, std::string_view stage) noexcept {
+    state.GetStatsScope().OnNetworkError();
+    state.GetStatsScope().Flush();
+    SetErrorAndResetSpan(state, fmt::format("Network error at '{}'", stage));
+}
+
 }  // namespace ugrpc::client::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/call_options_accessor.cpp b/grpc/src/ugrpc/client/impl/call_options_accessor.cpp
index 2331d50b1f6d..89fb2621f44b 100644
--- a/grpc/src/ugrpc/client/impl/call_options_accessor.cpp
+++ b/grpc/src/ugrpc/client/impl/call_options_accessor.cpp
@@ -10,15 +10,15 @@ std::unique_ptr<grpc::ClientContext> CallOptionsAccessor::CreateClientContext(co
     auto client_context = call_options.client_context_factory_ ? call_options.client_context_factory_()
                                                                : std::make_unique<grpc::ClientContext>();
 
-    for (const auto& [meta_key, meta_value] : call_options.metadata_) {
-        client_context->AddMetadata(meta_key, meta_value);
-    }
-
     const auto timeout = call_options.GetTimeout();
     if (std::chrono::milliseconds::max() != timeout) {
         client_context->set_deadline(ugrpc::DurationToTimespec(timeout));
     }
 
+    for (const auto& [meta_key, meta_value] : call_options.metadata_) {
+        client_context->AddMetadata(meta_key, meta_value);
+    }
+
     return client_context;
 }
 
diff --git a/grpc/src/ugrpc/client/impl/call_params.cpp b/grpc/src/ugrpc/client/impl/call_params.cpp
index 35552bd6f890..e7f7fecef372 100644
--- a/grpc/src/ugrpc/client/impl/call_params.cpp
+++ b/grpc/src/ugrpc/client/impl/call_params.cpp
@@ -5,9 +5,12 @@
 #include <userver/ugrpc/client/client_qos.hpp>
 #include <userver/ugrpc/client/exceptions.hpp>
 #include <userver/utils/algo.hpp>
+#include <userver/utils/assert.hpp>
+#include <userver/utils/numeric_cast.hpp>
 
 #include <userver/ugrpc/client/impl/client_data.hpp>
 
+#include <ugrpc/client/impl/compat/retry_policy.hpp>
 #include <ugrpc/impl/rpc_metadata.hpp>
 
 USERVER_NAMESPACE_BEGIN
@@ -25,16 +28,58 @@ void CheckValidCallName(std::string_view call_name) {
     );
 }
 
-void ApplyDynamicConfig(CallOptions& call_options, const Qos& qos, const testsuite::GrpcControl& testsuite_grpc) {
-    // dynamic config has lowest priority,
-    // so set timeout from dynamic config only if NOT set
+void SetAttempts(CallOptions& call_options, const Qos& qos, const RetryConfig& retry_config) {
+    if (0 == call_options.GetAttempts()) {
+        call_options.SetAttempts(qos.attempts.value_or(retry_config.attempts));
+    }
+}
+
+void SetTimeout(CallOptions& call_options, const Qos& qos, const testsuite::GrpcControl& testsuite_grpc) {
     if (std::chrono::milliseconds::max() == call_options.GetTimeout() && qos.timeout.has_value()) {
-        const auto total_timeout = GetTotalTimeout(qos);
-        UASSERT(total_timeout.has_value());
-        call_options.SetTimeout(testsuite_grpc.MakeTimeout(*total_timeout));
+        call_options.SetTimeout(testsuite_grpc.MakeTimeout(*qos.timeout));
+    }
+}
+
+void SetTimeoutStreaming(
+    CallOptions& call_options,
+    const Qos& qos,
+    const RetryConfig& retry_config,
+    const testsuite::GrpcControl& testsuite_grpc
+) {
+    SetTimeout(call_options, qos, testsuite_grpc);
+
+    // if timeout is set, reset it to TotalTimeout, because of grpc-core retries
+    const auto timeout = call_options.GetTimeout();
+    if (std::chrono::milliseconds::max() != timeout) {
+        const auto attempts = qos.attempts.value_or(retry_config.attempts);
+        UINVARIANT(0 < attempts, "Qos/RetryConfig attempts value must be greater than 0");
+        const auto total_timeout = compat::CalculateTotalTimeout(timeout, utils::numeric_cast<std::uint32_t>(attempts));
+        call_options.SetTimeout(total_timeout);
     }
 }
 
+void ApplyRetryConfiguration(
+    CallOptions& call_options,
+    const Qos& qos,
+    const RetryConfig& retry_config,
+    const testsuite::GrpcControl& testsuite_grpc
+) {
+    SetAttempts(call_options, qos, retry_config);
+    SetTimeout(call_options, qos, testsuite_grpc);
+}
+
+void ApplyRetryConfigurationStreaming(
+    CallOptions& call_options,
+    const Qos& qos,
+    const RetryConfig& retry_config,
+    const testsuite::GrpcControl& testsuite_grpc
+) {
+    // we use grpc-core retries for streaming-methods,
+    // so CallOption attempts do not work, no need to set them
+
+    SetTimeoutStreaming(call_options, qos, retry_config, testsuite_grpc);
+}
+
 }  // namespace
 
 CallParams CreateCallParams(const ClientData& client_data, std::size_t method_id, CallOptions&& call_options) {
@@ -48,7 +93,14 @@ CallParams CreateCallParams(const ClientData& client_data, std::size_t method_id
     auto stub = client_data.NextStubFromMethodId(method_id);
 
     const auto qos = stub.GetClientQos().methods.GetOptional(call_name).value_or(Qos{});
-    ApplyDynamicConfig(call_options, qos, client_data.GetTestsuiteControl());
+    ApplyRetryConfiguration(call_options, qos, client_data.GetRetryConfig(), client_data.GetTestsuiteControl());
+    if (ugrpc::impl::RpcType::kUnary == GetMethodType(metadata, method_id)) {
+        ApplyRetryConfiguration(call_options, qos, client_data.GetRetryConfig(), client_data.GetTestsuiteControl());
+    } else {
+        ApplyRetryConfigurationStreaming(
+            call_options, qos, client_data.GetRetryConfig(), client_data.GetTestsuiteControl()
+        );
+    }
 
     return CallParams{
         client_data.GetClientName(),
@@ -59,6 +111,7 @@ CallParams CreateCallParams(const ClientData& client_data, std::size_t method_id
         std::move(stub),
         client_data.GetMiddlewares(),
         client_data.GetStatistics(method_id),
+        client_data.GetTestsuiteControl(),
     };
 }
 
@@ -88,6 +141,7 @@ CallParams CreateGenericCallParams(
         client_data.NextStub(),
         client_data.GetMiddlewares(),
         client_data.GetGenericStatistics(generic_options.metrics_call_name.value_or(call_name)),
+        client_data.GetTestsuiteControl(),
     };
 }
 
diff --git a/grpc/src/ugrpc/client/impl/call_state.cpp b/grpc/src/ugrpc/client/impl/call_state.cpp
index ae33153e5fe4..4b184800e300 100644
--- a/grpc/src/ugrpc/client/impl/call_state.cpp
+++ b/grpc/src/ugrpc/client/impl/call_state.cpp
@@ -59,20 +59,28 @@ CallState::CallState(CallParams&& params, CallKind call_kind)
       queue_(params.queue),
       config_values_(params.config),
       middleware_pipeline_(params.middlewares),
+      testsuite_grpc_(params.testsuite_grpc),
       call_kind_(call_kind) {
     UINVARIANT(!client_name_.empty(), "client name should not be empty");
 
     SetupSpan(span_, call_name_.Get());
-
-    client_context_ = CallOptionsAccessor::CreateClientContext(params.call_options);
-    AddTracingMetadata(*client_context_, GetSpan());
 }
 
 StubHandle& CallState::GetStub() noexcept { return stub_; }
 
-const grpc::ClientContext& CallState::GetClientContext() const noexcept { return *client_context_; }
+void CallState::SetClientContext(std::unique_ptr<grpc::ClientContext> client_context) noexcept {
+    client_context_ = std::move(client_context);
+}
 
-grpc::ClientContext& CallState::GetClientContext() noexcept { return *client_context_; }
+const grpc::ClientContext& CallState::GetClientContext() const noexcept {
+    UASSERT(client_context_);
+    return *client_context_;
+}
+
+grpc::ClientContext& CallState::GetClientContext() noexcept {
+    UASSERT(client_context_);
+    return *client_context_;
+}
 
 grpc::CompletionQueue& CallState::GetQueue() const noexcept { return queue_; }
 
@@ -80,6 +88,8 @@ const RpcConfigValues& CallState::GetConfigValues() const noexcept { return conf
 
 const MiddlewarePipeline& CallState::GetMiddlewarePipeline() const noexcept { return middleware_pipeline_; }
 
+const testsuite::GrpcControl& CallState::GetTestsuiteControl() const noexcept { return testsuite_grpc_; }
+
 std::string_view CallState::GetCallName() const noexcept { return call_name_.Get(); }
 
 std::string_view CallState::GetClientName() const noexcept { return client_name_; }
@@ -107,30 +117,18 @@ bool CallState::IsDeadlinePropagated() const noexcept { return is_deadline_propa
 
 grpc::Status& CallState::GetStatus() noexcept { return status_; }
 
-UnaryCallState::~UnaryCallState() noexcept { invocation_.reset(); }
-
-bool UnaryCallState::IsFinishProcessed() const noexcept { return finish_processed_; }
+void CallState::Commit() noexcept { committed_.store(true, std::memory_order_release); }
 
-void UnaryCallState::SetFinishProcessed() noexcept {
-    UASSERT(!finish_processed_);
-    finish_processed_ = true;
+grpc::ClientContext& CallState::GetClientContextCommitted() {
+    UINVARIANT(committed_, "Call state should be committed");
+    UINVARIANT(client_context_, "GetClientContext should not be called on cancelled RPC");
+    return *client_context_;
 }
 
-bool UnaryCallState::IsStatusExtracted() const noexcept { return status_extracted_; }
-
-void UnaryCallState::SetStatusExtracted() noexcept {
-    UASSERT(!status_extracted_);
-    status_extracted_ = true;
-}
-
-void UnaryCallState::EmplaceFinishAsyncMethodInvocation() {
-    UASSERT(!invocation_.has_value());
-    invocation_.emplace();
-}
-
-FinishAsyncMethodInvocation& UnaryCallState::GetFinishAsyncMethodInvocation() noexcept {
-    UASSERT(invocation_.has_value());
-    return *invocation_;
+StreamingCallState::StreamingCallState(CallParams&& params, CallKind call_kind)
+    : CallState(std::move(params), call_kind) {
+    SetupClientContext(*this, params.call_options);
+    Commit();
 }
 
 StreamingCallState::~StreamingCallState() noexcept {
@@ -196,6 +194,12 @@ bool IsWriteAndCheckAvailable(const StreamingCallState& state) noexcept {
     return !state.AreWritesFinished() && !state.IsFinished();
 }
 
+void SetupClientContext(CallState& state, const CallOptions& call_options) {
+    auto client_context = CallOptionsAccessor::CreateClientContext(call_options);
+    AddTracingMetadata(*client_context, state.GetSpan());
+    state.SetClientContext(std::move(client_context));
+}
+
 void HandleCallStatistics(CallState& state, const grpc::Status& status) noexcept {
     auto& stats = state.GetStatsScope();
     stats.OnExplicitFinish(status.error_code());
diff --git a/grpc/src/ugrpc/client/impl/channel_argument_utils.cpp b/grpc/src/ugrpc/client/impl/channel_argument_utils.cpp
new file mode 100644
index 000000000000..1b18b05575d0
--- /dev/null
+++ b/grpc/src/ugrpc/client/impl/channel_argument_utils.cpp
@@ -0,0 +1,25 @@
+#include <userver/ugrpc/client/impl/channel_argument_utils.hpp>
+
+#include <userver/logging/log.hpp>
+
+#include <userver/ugrpc/impl/to_string.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+grpc::ChannelArguments
+BuildChannelArguments(const grpc::ChannelArguments& channel_args, const std::optional<std::string>& service_config) {
+    if (!service_config.has_value()) {
+        return channel_args;
+    }
+
+    LOG_INFO() << "Building ChannelArguments, ServiceConfig: " << *service_config;
+    auto effective_channel_args{channel_args};
+    effective_channel_args.SetServiceConfigJSON(ugrpc::impl::ToGrpcString(*service_config));
+    return effective_channel_args;
+}
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/channel_arguments_builder.cpp b/grpc/src/ugrpc/client/impl/channel_arguments_builder.cpp
deleted file mode 100644
index 0738f748b8ce..000000000000
--- a/grpc/src/ugrpc/client/impl/channel_arguments_builder.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-#include <userver/ugrpc/client/impl/channel_arguments_builder.hpp>
-
-#include <fmt/format.h>
-
-#include <google/protobuf/util/json_util.h>
-#include <google/protobuf/util/time_util.h>
-
-#include <userver/formats/json/inline.hpp>
-#include <userver/formats/json/serialize.hpp>
-#include <userver/formats/json/value_builder.hpp>
-#include <userver/logging/log.hpp>
-#include <userver/utils/algo.hpp>
-#include <userver/utils/assert.hpp>
-
-#include <userver/ugrpc/client/client_qos.hpp>
-#include <userver/ugrpc/impl/to_string.hpp>
-
-#include <ugrpc/client/impl/retry_policy.hpp>
-
-USERVER_NAMESPACE_BEGIN
-
-namespace ugrpc::client::impl {
-
-namespace {
-
-constexpr bool HasValue(const Qos& qos) noexcept { return qos.attempts.has_value(); }
-
-void SetName(formats::json::ValueBuilder& method_config, formats::json::Value name) {
-    method_config["name"] = formats::json::MakeArray(std::move(name));
-}
-
-void ApplyQosConfig(formats::json::ValueBuilder& method_config, const Qos& qos) {
-    const auto attempts = GetAttempts(qos);
-    if (attempts.has_value()) {
-        method_config.Remove("hedgingPolicy");
-
-        if (1 == *attempts) {
-            method_config.Remove("retryPolicy");
-            return;
-        }
-
-        if (!method_config.HasMember("retryPolicy")) {
-            method_config["retryPolicy"] = ConstructDefaultRetryPolicy();
-        }
-        method_config["retryPolicy"]["maxAttempts"] = *attempts;
-        if (qos.timeout.has_value()) {
-            method_config["retryPolicy"]["perAttemptRecvTimeout"] =
-                ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(
-                    google::protobuf::util::TimeUtil::MillisecondsToDuration(qos.timeout->count())
-                ));
-        }
-    }
-}
-
-formats::json::Value ApplyQosConfig(formats::json::Value method_config, const Qos& qos) {
-    formats::json::ValueBuilder method_config_builder{std::move(method_config)};
-    ApplyQosConfig(method_config_builder, qos);
-    return method_config_builder.ExtractValue();
-}
-
-formats::json::Value Normalize(const formats::json::Value& method_config, formats::json::Value name) {
-    formats::json::ValueBuilder method_config_builder{method_config};
-    SetName(method_config_builder, std::move(name));
-    return method_config_builder.ExtractValue();
-}
-
-formats::json::Value NormalizeDefault(const formats::json::Value& method_config) {
-    formats::json::ValueBuilder method_config_builder{method_config};
-    SetName(method_config_builder, formats::json::MakeObject());
-    return method_config_builder.ExtractValue();
-}
-
-ServiceConfigBuilder::PreparedMethodConfigs PrepareMethodConfigs(
-    const formats::json::Value& static_service_config,
-    const ugrpc::impl::StaticServiceMetadata& metadata
-) {
-    std::unordered_map<std::size_t, formats::json::Value> method_configs;
-    std::optional<formats::json::Value> default_method_config;
-
-    if (static_service_config.HasMember("methodConfig")) {
-        for (const auto& method_config : static_service_config["methodConfig"]) {
-            if (method_config.HasMember("name")) {
-                for (const auto& name : method_config["name"]) {
-                    const auto service_name = name["service"].As<std::string>("");
-                    const auto method_name = name["method"].As<std::string>("");
-
-                    // - If the 'service' field is empty, the 'method' field must be empty, and
-                    //   this MethodConfig specifies the default for all methods (it's the default
-                    //   config).
-                    if (service_name.empty()) {
-                        UINVARIANT(
-                            method_name.empty(), "If the 'service' field is empty, the 'method' field must be empty"
-                        );
-                        if (!default_method_config.has_value()) {
-                            default_method_config = NormalizeDefault(method_config);
-                        }
-                        continue;
-                    }
-
-                    if (metadata.service_full_name != service_name) {
-                        throw std::runtime_error{
-                            fmt::format("Invalid MethodConfig: unknown service name {}", service_name)};
-                    }
-
-                    // - If the 'method' field is empty, this MethodConfig specifies the defaults
-                    //   for all methods for the specified service.
-                    if (method_name.empty()) {
-                        default_method_config = NormalizeDefault(method_config);
-                        continue;
-                    }
-
-                    const auto method_id = FindMethod(metadata, service_name, method_name);
-                    if (!method_id.has_value()) {
-                        throw std::runtime_error{
-                            fmt::format("Invalid MethodConfig: unknown method name {}", method_name)};
-                    }
-
-                    const auto [_, inserted] = method_configs.try_emplace(*method_id, Normalize(method_config, name));
-                    UINVARIANT(inserted, "Each name entry must be unique across the entire ServiceConfig");
-                }
-            }
-        }
-    }
-
-    return {std::move(method_configs), std::move(default_method_config)};
-}
-
-formats::json::Value
-BuildMethodConfig(formats::json::Value name, const Qos& qos, std::optional<formats::json::Value> static_method_config) {
-    formats::json::ValueBuilder method_config{std::move(static_method_config).value_or(formats::json::MakeObject())};
-
-    SetName(method_config, std::move(name));
-
-    ApplyQosConfig(method_config, qos);
-
-    return method_config.ExtractValue();
-}
-
-formats::json::Value BuildMethodConfig(
-    std::string_view service_name,
-    std::string_view method_name,
-    const Qos& qos,
-    std::optional<formats::json::Value> static_method_config
-) {
-    UINVARIANT(
-        !service_name.empty() || method_name.empty(),
-        "If the 'service' field is empty, the 'method' field must be empty"
-    );
-
-    auto name = formats::json::MakeObject("service", service_name, "method", method_name);
-
-    return BuildMethodConfig(std::move(name), qos, std::move(static_method_config));
-}
-
-formats::json::Value
-BuildDefaultMethodConfig(const Qos& qos, std::optional<formats::json::Value> static_method_config) {
-    return BuildMethodConfig(formats::json::MakeObject(), qos, std::move(static_method_config));
-}
-
-}  // namespace
-
-ServiceConfigBuilder::ServiceConfigBuilder(
-    const ugrpc::impl::StaticServiceMetadata& metadata,
-    const std::optional<std::string>& static_service_config
-)
-    : metadata_{metadata} {
-    if (static_service_config.has_value()) {
-        static_service_config_ = formats::json::FromString(*static_service_config);
-        prepared_method_configs_ = PrepareMethodConfigs(static_service_config_, metadata_);
-    }
-}
-
-formats::json::Value ServiceConfigBuilder::Build(const ClientQos& client_qos) const {
-    formats::json::ValueBuilder service_config_builder{static_service_config_};
-
-    if (auto method_config_array = BuildMethodConfigArray(client_qos); !method_config_array.IsEmpty()) {
-        service_config_builder["methodConfig"] = std::move(method_config_array);
-    }
-
-    return service_config_builder.ExtractValue();
-}
-
-formats::json::Value ServiceConfigBuilder::BuildMethodConfigArray(const ClientQos& client_qos) const {
-    formats::json::ValueBuilder method_config_array;
-
-    const auto qos_default =
-        client_qos.methods.HasDefaultValue() ? client_qos.methods.GetDefaultValue() : std::optional<Qos>{};
-
-    auto default_method_config = prepared_method_configs_.default_method_config;
-    if (default_method_config.has_value() && qos_default.has_value()) {
-        default_method_config = ApplyQosConfig(std::move(*default_method_config), *qos_default);
-    }
-
-    for (std::size_t method_id = 0; method_id < GetMethodsCount(metadata_); ++method_id) {
-        const auto method_name = GetMethodName(metadata_, method_id);
-        const auto method_full_name = GetMethodFullName(metadata_, method_id);
-
-        const auto qos = client_qos.methods.GetOptional(method_full_name);
-
-        auto method_config = utils::FindOptional(prepared_method_configs_.method_configs, method_id);
-        if (method_config.has_value() && qos_default.has_value()) {
-            method_config = ApplyQosConfig(std::move(*method_config), *qos_default);
-        }
-
-        // add MethodConfig
-        // if method Qos with non empty value exists,
-        // or `static-service-config` has corresponding MethodConfig entry
-        if (client_qos.methods.HasValue(method_full_name) && HasValue(*qos)) {
-            method_config_array.PushBack(BuildMethodConfig(
-                metadata_.service_full_name,
-                method_name,
-                *qos,
-                method_config.has_value() ? std::move(method_config) : default_method_config
-            ));
-        } else if (method_config.has_value()) {
-            method_config_array.PushBack(std::move(*method_config));
-        }
-    }
-
-    // add default MethodConfig if default Qos with non empty value exists
-    // or `static-service-config` has default MethodConfig
-    if (qos_default.has_value() && HasValue(*qos_default)) {
-        method_config_array.PushBack(BuildDefaultMethodConfig(*qos_default, std::move(default_method_config)));
-    } else if (default_method_config.has_value()) {
-        method_config_array.PushBack(std::move(*default_method_config));
-    }
-
-    return method_config_array.ExtractValue();
-}
-
-ChannelArgumentsBuilder::ChannelArgumentsBuilder(
-    const grpc::ChannelArguments& channel_args,
-    const std::optional<std::string>& static_service_config,
-    const ugrpc::impl::StaticServiceMetadata& metadata
-)
-    : channel_args_{channel_args}, service_config_builder_{metadata, static_service_config} {}
-
-grpc::ChannelArguments ChannelArgumentsBuilder::Build(const ClientQos& client_qos) const {
-    const auto service_config = service_config_builder_.Build(client_qos);
-    if (service_config.IsNull()) {
-        return channel_args_;
-    }
-    return BuildChannelArguments(channel_args_, formats::json::ToString(service_config));
-}
-
-grpc::ChannelArguments
-BuildChannelArguments(const grpc::ChannelArguments& channel_args, const std::optional<std::string>& service_config) {
-    if (!service_config.has_value()) {
-        return channel_args;
-    }
-
-    LOG_INFO() << "Building ChannelArguments, ServiceConfig: " << *service_config;
-    auto effective_channel_args{channel_args};
-    effective_channel_args.SetServiceConfigJSON(ugrpc::impl::ToGrpcString(*service_config));
-#ifdef GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-    effective_channel_args.SetInt(GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING, 1);
-#endif  // GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-    return effective_channel_args;
-}
-
-}  // namespace ugrpc::client::impl
-
-USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/client_factory_config.cpp b/grpc/src/ugrpc/client/impl/client_factory_config.cpp
index 211d30fdc996..4a8930030174 100644
--- a/grpc/src/ugrpc/client/impl/client_factory_config.cpp
+++ b/grpc/src/ugrpc/client/impl/client_factory_config.cpp
@@ -1,14 +1,10 @@
 #include <ugrpc/client/impl/client_factory_config.hpp>
 
 #include <userver/formats/yaml/serialize.hpp>
-#include <userver/logging/level_serialization.hpp>
+#include <userver/fs/blocking/read.hpp>
 #include <userver/logging/log.hpp>
 #include <userver/utils/trivial_map.hpp>
-#include <userver/yaml_config/yaml_config.hpp>
 
-#include <ugrpc/client/secdist.hpp>
-#include <userver/fs/blocking/read.hpp>
-#include <userver/logging/log.hpp>
 #include <userver/ugrpc/impl/to_string.hpp>
 
 USERVER_NAMESPACE_BEGIN
@@ -17,16 +13,6 @@ namespace ugrpc::client::impl {
 
 namespace {
 
-std::shared_ptr<grpc::ChannelCredentials> MakeCredentials(const ClientFactoryConfig& config) {
-    if (config.auth_type == AuthType::kSsl) {
-        LOG_INFO() << "GRPC client (SSL) initialized...";
-        return grpc::SslCredentials(config.ssl_credentials_options);
-    } else {
-        LOG_INFO() << "GRPC client (non SSL) initialized...";
-        return grpc::InsecureChannelCredentials();
-    }
-}
-
 grpc::SslCredentialsOptions MakeCredentialsOptions(const yaml_config::YamlConfig& config) {
     grpc::SslCredentialsOptions result;
     if (config.IsMissing()) {
@@ -78,36 +64,14 @@ ClientFactoryConfig Parse(const yaml_config::YamlConfig& value, formats::parse::
     if (config.auth_type == AuthType::kSsl) {
         config.ssl_credentials_options = MakeCredentialsOptions(value["ssl-credentials-options"]);
     }
+    config.retry_config = value["retry-config"].As<RetryConfig>();
+    LOG_INFO() << "RetryConfig: attempts=" << config.retry_config.attempts;
     config.channel_args = MakeChannelArgs(value["channel-args"]);
     config.default_service_config = value["default-service-config"].As<std::optional<std::string>>();
     config.channel_count = value["channel-count"].As<std::size_t>(config.channel_count);
     return config;
 }
 
-ClientFactorySettings
-MakeFactorySettings(ClientFactoryConfig&& config, const storages::secdist::SecdistConfig* secdist) {
-    std::shared_ptr<grpc::ChannelCredentials> credentials = MakeCredentials(config);
-    std::unordered_map<std::string, std::shared_ptr<grpc::ChannelCredentials>> client_credentials;
-
-    if (secdist) {
-        const auto& tokens = secdist->Get<Secdist>();
-
-        for (const auto& [client_name, token] : tokens.tokens) {
-            client_credentials[client_name] = grpc::CompositeChannelCredentials(
-                credentials, grpc::AccessTokenCredentials(ugrpc::impl::ToGrpcString(token))
-            );
-        }
-    }
-
-    return ClientFactorySettings{
-        std::move(credentials),
-        std::move(client_credentials),
-        std::move(config.channel_args),
-        std::move(config.default_service_config),
-        config.channel_count,
-    };
-}
-
 }  // namespace ugrpc::client::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/client_factory_config.hpp b/grpc/src/ugrpc/client/impl/client_factory_config.hpp
index 4537de1734b3..8a62a129f8ad 100644
--- a/grpc/src/ugrpc/client/impl/client_factory_config.hpp
+++ b/grpc/src/ugrpc/client/impl/client_factory_config.hpp
@@ -1,9 +1,11 @@
 #pragma once
 
-#include <userver/storages/secdist/secdist.hpp>
+#include <grpcpp/security/credentials.h>
+#include <grpcpp/support/channel_arguments.h>
+
 #include <userver/yaml_config/yaml_config.hpp>
 
-#include <userver/ugrpc/client/client_factory_settings.hpp>
+#include <userver/ugrpc/client/retry_config.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -20,6 +22,9 @@ struct ClientFactoryConfig final {
 
     grpc::SslCredentialsOptions ssl_credentials_options{};
 
+    /// Retry configuration for outgoing RPCs
+    RetryConfig retry_config;
+
     /// Optional grpc-core channel args
     /// @see https://grpc.github.io/grpc/core/group__grpc__arg__keys.html
     grpc::ChannelArguments channel_args{};
@@ -35,9 +40,6 @@ struct ClientFactoryConfig final {
 
 ClientFactoryConfig Parse(const yaml_config::YamlConfig& value, formats::parse::To<ClientFactoryConfig>);
 
-ClientFactorySettings
-MakeFactorySettings(impl::ClientFactoryConfig&& config, const storages::secdist::SecdistConfig* secdist);
-
 }  // namespace ugrpc::client::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/compat/channel_arguments_builder.cpp b/grpc/src/ugrpc/client/impl/compat/channel_arguments_builder.cpp
new file mode 100644
index 000000000000..93866aa9824d
--- /dev/null
+++ b/grpc/src/ugrpc/client/impl/compat/channel_arguments_builder.cpp
@@ -0,0 +1,343 @@
+#include <userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp>
+
+#include <fmt/format.h>
+
+#include <google/protobuf/util/json_util.h>
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/formats/json/inline.hpp>
+#include <userver/formats/json/serialize.hpp>
+#include <userver/formats/json/value_builder.hpp>
+#include <userver/logging/log.hpp>
+#include <userver/utils/algo.hpp>
+#include <userver/utils/assert.hpp>
+#include <userver/utils/numeric_cast.hpp>
+
+#include <userver/ugrpc/client/client_qos.hpp>
+#include <userver/ugrpc/client/impl/channel_argument_utils.hpp>
+#include <userver/ugrpc/impl/to_string.hpp>
+
+#include <ugrpc/client/impl/compat/retry_policy.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl::compat {
+
+namespace {
+
+void SetName(formats::json::ValueBuilder& method_config, formats::json::Value name) {
+    method_config["name"] = std::move(name);
+}
+
+formats::json::Value Normalize(const formats::json::Value& name, const formats::json::Value& method_config) {
+    formats::json::ValueBuilder method_config_builder{method_config};
+    SetName(method_config_builder, formats::json::MakeArray(name));
+    return method_config_builder.ExtractValue();
+}
+
+ServiceConfigBuilder::PreparedMethodConfigs PrepareMethodConfigs(
+    const formats::json::Value& static_service_config,
+    const ugrpc::impl::StaticServiceMetadata& metadata
+) {
+    std::unordered_map<std::size_t, formats::json::Value> method_configs;
+    std::optional<formats::json::Value> default_method_config;
+
+    if (static_service_config.HasMember("methodConfig")) {
+        for (const auto& method_config : static_service_config["methodConfig"]) {
+            if (method_config.HasMember("name")) {
+                for (const auto& name : method_config["name"]) {
+                    const auto service_name = name["service"].As<std::string>("");
+                    const auto method_name = name["method"].As<std::string>("");
+
+                    // - If the 'service' field is empty, the 'method' field must be empty, and
+                    //   this MethodConfig specifies the default for all methods (it's the default
+                    //   config).
+                    if (service_name.empty()) {
+                        UINVARIANT(
+                            method_name.empty(), "If the 'service' field is empty, the 'method' field must be empty"
+                        );
+                        if (!default_method_config.has_value()) {
+                            default_method_config = Normalize(name, method_config);
+                        }
+                        continue;
+                    }
+
+                    if (metadata.service_full_name != service_name) {
+                        throw std::runtime_error{
+                            fmt::format("Invalid MethodConfig: unknown service name {}", service_name)};
+                    }
+
+                    // - If the 'method' field is empty, this MethodConfig specifies the defaults
+                    //   for all methods for the specified service.
+                    if (method_name.empty()) {
+                        default_method_config = Normalize(name, method_config);
+                        continue;
+                    }
+
+                    const auto method_id = FindMethod(metadata, service_name, method_name);
+                    if (!method_id.has_value()) {
+                        throw std::runtime_error{
+                            fmt::format("Invalid MethodConfig: unknown method name {}", method_name)};
+                    }
+
+                    const auto [_, inserted] = method_configs.try_emplace(*method_id, Normalize(name, method_config));
+                    UINVARIANT(inserted, "Each name entry must be unique across the entire ServiceConfig");
+                }
+            }
+        }
+    }
+
+    return {std::move(method_configs), std::move(default_method_config)};
+}
+
+class RetryConfiguration final {
+public:
+    RetryConfiguration(
+        const ugrpc::impl::StaticServiceMetadata& metadata,
+        const RetryConfig& retry_config,
+        const ServiceConfigBuilder::PreparedMethodConfigs& prepared_method_configs,
+        const ClientQos& client_qos
+    )
+        : metadata_{metadata},
+          retry_config_{retry_config},
+          prepared_method_configs_{prepared_method_configs},
+          client_qos_{client_qos} {}
+
+    bool HasMethodConfiguration(size_t method_id) {
+        // method Qos exists and has non empty 'attempts' value
+        const auto method_full_name = GetMethodFullName(metadata_, method_id);
+        if (client_qos_.methods.HasValue(method_full_name)) {
+            const auto& qos = client_qos_.methods.Get(method_full_name);
+            if (qos.attempts.has_value()) {
+                return true;
+            }
+        }
+
+        // or `static-service-config` has corresponding MethodConfig entry
+        return prepared_method_configs_.method_configs.count(method_id);
+    }
+
+    bool HasDefaultConfiguration() { return GetDefaultAttempts().has_value(); }
+
+    std::optional<int> GetAttempts(size_t method_id) {
+        const auto method_full_name = GetMethodFullName(metadata_, method_id);
+        const auto qos = client_qos_.methods.GetOptional(method_full_name);
+        if (qos.has_value() && qos->attempts.has_value()) {
+            return qos->attempts;
+        }
+
+        return GetDefaultAttempts();
+    }
+
+    std::optional<int> GetDefaultAttempts() {
+        if (client_qos_.methods.HasDefaultValue()) {
+            const auto qos_default = client_qos_.methods.GetDefaultValue();
+            if (qos_default.attempts.has_value()) {
+                return qos_default.attempts;
+            }
+        }
+
+        return GetStaticConfigAttempts();
+    }
+
+    std::optional<formats::json::Value> GetMethodConfig(size_t method_id) {
+        auto method_config = utils::FindOptional(prepared_method_configs_.method_configs, method_id);
+        return method_config.has_value() ? method_config : GetDefaultMethodConfig();
+    }
+
+    std::optional<formats::json::Value> GetDefaultMethodConfig() {
+        return prepared_method_configs_.default_method_config;
+    }
+
+private:
+    std::optional<int> GetStaticConfigAttempts() const {
+        // for RetryConfig 'attempts == 1' means stay ServiceConfig AS IS
+        if (1 == retry_config_.attempts) {
+            return std::nullopt;
+        }
+
+        return retry_config_.attempts;
+    }
+
+    const ugrpc::impl::StaticServiceMetadata& metadata_;
+    const RetryConfig& retry_config_;
+    const ServiceConfigBuilder::PreparedMethodConfigs& prepared_method_configs_;
+    const ClientQos& client_qos_;
+};
+
+void ClearRetryPolicy(formats::json::ValueBuilder& method_config) {
+    method_config.Remove("retryPolicy");
+    method_config.Remove("hedgingPolicy");
+}
+
+struct RetryPolicy {
+    std::uint32_t max_attempts{};
+    std::optional<std::chrono::milliseconds> per_attempt_recv_timeout;
+};
+void SetRetryPolicy(formats::json::ValueBuilder& method_config, const RetryPolicy& retry_policy) {
+    UINVARIANT(1 < retry_policy.max_attempts, "RetryPolicy MaxAttempts must be greater than 1");
+
+    // Only one of "retryPolicy" or "hedgingPolicy" may be set
+    if (method_config.HasMember("hedgingPolicy")) {
+        method_config.Remove("hedgingPolicy");
+    }
+
+    if (!method_config.HasMember("retryPolicy")) {
+        method_config["retryPolicy"] = ConstructDefaultRetryPolicy();
+    }
+    method_config["retryPolicy"]["maxAttempts"] = retry_policy.max_attempts;
+
+    // do not set "perAttemptRecvTimeout" for now
+    // https://github.com/grpc/grpc/issues/39935
+    // "Client request may hangs forever when set 'perAttemptRecvTimeout'"
+    //
+    // if (retry_policy.per_attempt_recv_timeout.has_value()) {
+    //     method_config["retryPolicy"]["perAttemptRecvTimeout"] =
+    //         ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(
+    //             google::protobuf::util::TimeUtil::MillisecondsToDuration(retry_policy.per_attempt_recv_timeout->count())
+    //         ));
+    // }
+}
+
+void ApplyAttempts(formats::json::ValueBuilder& method_config, int attempts) {
+    UINVARIANT(0 < attempts, "'attempts' value must be greater than 0");
+    if (1 == attempts) {
+        ClearRetryPolicy(method_config);
+    } else {
+        SetRetryPolicy(method_config, RetryPolicy{utils::numeric_cast<std::uint32_t>(attempts), std::nullopt});
+    }
+}
+
+class MethodConfigBuilder final {
+public:
+    void SetMethodConfig(std::optional<formats::json::Value> method_config) {
+        method_config_ = std::move(method_config);
+    }
+
+    void SetName(std::string_view service, std::string_view method) { SetName(service, std::vector{method}); }
+
+    void SetName(std::string_view service, const std::vector<std::string_view>& methods) {
+        formats::json::ValueBuilder name{};
+        for (const auto& method : methods) {
+            UINVARIANT(
+                !service.empty() || method.empty(), "If the 'service' field is empty, the 'method' field must be empty"
+            );
+            name.PushBack(formats::json::MakeObject("service", service, "method", method));
+        }
+        name_ = name.ExtractValue();
+    }
+
+    void SetAttempts(std::optional<int> attempts) { attempts_ = attempts; }
+
+    formats::json::Value Build() && {
+        formats::json::ValueBuilder method_config_builder{
+            std::move(method_config_).value_or(formats::json::MakeObject())};
+
+        if (name_.has_value()) {
+            impl::compat::SetName(method_config_builder, std::move(*name_));
+        }
+
+        if (attempts_.has_value()) {
+            ApplyAttempts(method_config_builder, *attempts_);
+        }
+
+        return method_config_builder.ExtractValue();
+    }
+
+private:
+    std::optional<formats::json::Value> method_config_;
+    std::optional<formats::json::Value> name_;
+    std::optional<int> attempts_;
+};
+
+}  // namespace
+
+ServiceConfigBuilder::ServiceConfigBuilder(
+    const ugrpc::impl::StaticServiceMetadata& metadata,
+    const RetryConfig& retry_config,
+    const std::optional<std::string>& static_service_config
+)
+    : metadata_{metadata}, retry_config_{retry_config} {
+    if (static_service_config.has_value()) {
+        static_service_config_ = formats::json::FromString(*static_service_config);
+        prepared_method_configs_ = PrepareMethodConfigs(static_service_config_, metadata_);
+    }
+}
+
+formats::json::Value ServiceConfigBuilder::Build(const ClientQos& client_qos) const {
+    formats::json::ValueBuilder service_config_builder{static_service_config_};
+
+    if (auto method_config_array = BuildMethodConfigArray(client_qos); !method_config_array.IsEmpty()) {
+        service_config_builder["methodConfig"] = std::move(method_config_array);
+    }
+
+    return service_config_builder.ExtractValue();
+}
+
+formats::json::Value ServiceConfigBuilder::BuildMethodConfigArray(const ClientQos& client_qos) const {
+    formats::json::ValueBuilder method_config_array;
+
+    // push unary method configs AS IS
+    for (const auto& [method_id, method_config] : prepared_method_configs_.method_configs) {
+        if (ugrpc::impl::RpcType::kUnary == GetMethodType(metadata_, method_id)) {
+            method_config_array.PushBack(method_config);
+        }
+    }
+
+    RetryConfiguration retry_configuration{metadata_, retry_config_, prepared_method_configs_, client_qos};
+
+    std::vector<std::string_view> default_stream_methods;
+
+    for (std::size_t method_id = 0; method_id < GetMethodsCount(metadata_); ++method_id) {
+        if (ugrpc::impl::RpcType::kUnary == GetMethodType(metadata_, method_id)) {
+            continue;
+        }
+
+        if (retry_configuration.HasMethodConfiguration(method_id)) {
+            MethodConfigBuilder builder;
+            builder.SetMethodConfig(retry_configuration.GetMethodConfig(method_id));
+            builder.SetName(metadata_.service_full_name, GetMethodName(metadata_, method_id));
+            builder.SetAttempts(retry_configuration.GetAttempts(method_id));
+            method_config_array.PushBack(std::move(builder).Build());
+            continue;
+        }
+
+        default_stream_methods.push_back(GetMethodName(metadata_, method_id));
+    }
+
+    // add default MethodConfig for streaming methods
+    if (!default_stream_methods.empty() && retry_configuration.HasDefaultConfiguration()) {
+        MethodConfigBuilder builder;
+        builder.SetMethodConfig(retry_configuration.GetDefaultMethodConfig());
+        builder.SetName(metadata_.service_full_name, default_stream_methods);
+        builder.SetAttempts(retry_configuration.GetDefaultAttempts());
+        method_config_array.PushBack(std::move(builder).Build());
+    }
+
+    // push default MethodConfig AS IS
+    if (prepared_method_configs_.default_method_config.has_value()) {
+        method_config_array.PushBack(prepared_method_configs_.default_method_config);
+    }
+
+    return method_config_array.ExtractValue();
+}
+
+ChannelArgumentsBuilder::ChannelArgumentsBuilder(
+    const grpc::ChannelArguments& channel_args,
+    const std::optional<std::string>& static_service_config,
+    const RetryConfig& retry_config,
+    const ugrpc::impl::StaticServiceMetadata& metadata
+)
+    : channel_args_{channel_args}, service_config_builder_{metadata, retry_config, static_service_config} {}
+
+grpc::ChannelArguments ChannelArgumentsBuilder::Build(const ClientQos& client_qos) const {
+    const auto service_config = service_config_builder_.Build(client_qos);
+    if (service_config.IsNull()) {
+        return channel_args_;
+    }
+    return BuildChannelArguments(channel_args_, formats::json::ToString(service_config));
+}
+
+}  // namespace ugrpc::client::impl::compat
+
+USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/compat/retry_policy.cpp b/grpc/src/ugrpc/client/impl/compat/retry_policy.cpp
new file mode 100644
index 000000000000..f53afc814c96
--- /dev/null
+++ b/grpc/src/ugrpc/client/impl/compat/retry_policy.cpp
@@ -0,0 +1,72 @@
+#include <ugrpc/client/impl/compat/retry_policy.hpp>
+
+#include <algorithm>
+#include <cmath>
+
+#include <google/protobuf/util/time_util.h>
+
+#include <grpc/grpc.h>  // for GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
+
+#include <userver/formats/json/inline.hpp>
+#include <userver/formats/json/value_builder.hpp>
+
+#include <userver/ugrpc/impl/to_string.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl::compat {
+
+namespace {
+
+constexpr std::uint32_t kMaxAttempts = 5;
+
+constexpr std::int64_t kInitialBackoffMs = 10;
+constexpr std::int64_t kMaxBackoffMs = 300;
+
+constexpr float kBackoffMultiplier = 2.0;
+
+}  // namespace
+
+formats::json::Value ConstructDefaultRetryPolicy() {
+    formats::json::ValueBuilder retry_policy;
+    retry_policy["maxAttempts"] = kMaxAttempts;
+    retry_policy["initialBackoff"] = ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(
+        google::protobuf::util::TimeUtil::MillisecondsToDuration(kInitialBackoffMs)
+    ));
+    retry_policy["maxBackoff"] = ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(
+        google::protobuf::util::TimeUtil::MillisecondsToDuration(kMaxBackoffMs)
+    ));
+    retry_policy["backoffMultiplier"] = kBackoffMultiplier;
+    retry_policy["retryableStatusCodes"] =
+        formats::json::MakeArray("CANCELLED", "UNKNOWN", "DEADLINE_EXCEEDED", "ABORTED", "INTERNAL", "UNAVAILABLE");
+    return retry_policy.ExtractValue();
+}
+
+std::chrono::milliseconds CalculateTotalTimeout(std::chrono::milliseconds timeout, std::uint32_t attempts) {
+    // Values greater than 5 are treated as 5 without being considered a validation error.
+    attempts = std::min(attempts, kMaxAttempts);
+
+    const std::int64_t timeout_ms = timeout.count();
+
+    std::int64_t total_timeout_ms = timeout_ms;
+#ifdef GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
+    for (std::uint32_t n = 1; n < attempts; ++n) {
+        // https://github.com/grpc/proposal/blob/master/A6-client-retries.md
+        // The initial retry attempt will occur after initialBackoff * random(0.8, 1.2).
+        // After that, the n-th attempt will occur after min(initialBackoff*backoffMultiplier**(n-1), maxBackoff) *
+        // random(0.8, 1.2)).
+        const double backoff = std::min(
+            kInitialBackoffMs * std::pow(static_cast<double>(kBackoffMultiplier), n - 1),
+            static_cast<double>(kMaxBackoffMs)
+        );
+        // Jitter of plus or minus 0.2 is applied to the backoff delay
+        constexpr double kBackoffJitter = 0.2;
+        total_timeout_ms += timeout_ms + static_cast<std::int64_t>(std::ceil(backoff * (1 + kBackoffJitter)));
+    }
+#endif  // GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
+    return std::chrono::milliseconds{total_timeout_ms};
+}
+
+}  // namespace ugrpc::client::impl::compat
+
+USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/retry_policy.hpp b/grpc/src/ugrpc/client/impl/compat/retry_policy.hpp
similarity index 77%
rename from grpc/src/ugrpc/client/impl/retry_policy.hpp
rename to grpc/src/ugrpc/client/impl/compat/retry_policy.hpp
index 2a9bd496ca88..4b3f12e117e0 100644
--- a/grpc/src/ugrpc/client/impl/retry_policy.hpp
+++ b/grpc/src/ugrpc/client/impl/compat/retry_policy.hpp
@@ -6,12 +6,12 @@
 
 USERVER_NAMESPACE_BEGIN
 
-namespace ugrpc::client::impl {
+namespace ugrpc::client::impl::compat {
 
 formats::json::Value ConstructDefaultRetryPolicy();
 
 std::chrono::milliseconds CalculateTotalTimeout(std::chrono::milliseconds timeout, std::uint32_t attempts);
 
-}  // namespace ugrpc::client::impl
+}  // namespace ugrpc::client::impl::compat
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/retry_backoff.cpp b/grpc/src/ugrpc/client/impl/retry_backoff.cpp
new file mode 100644
index 000000000000..41339108e328
--- /dev/null
+++ b/grpc/src/ugrpc/client/impl/retry_backoff.cpp
@@ -0,0 +1,42 @@
+#include <userver/ugrpc/client/impl/retry_backoff.hpp>
+
+#include <algorithm>
+
+#include <userver/utils/rand.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client::impl {
+
+namespace {
+
+constexpr std::int64_t kInitialBackoffMs = 10;
+constexpr std::int64_t kMaxBackoffMs = 300;
+
+constexpr float kBackoffMultiplier = 2.0;
+
+constexpr double kJitter = 0.2;
+
+}  // namespace
+
+RetryBackoff::RetryBackoff() { Reset(); }
+
+std::chrono::milliseconds RetryBackoff::NextAttemptDelay() {
+    if (initial_) {
+        initial_ = false;
+    } else {
+        current_backoff_ms_ *= kBackoffMultiplier;
+    }
+    current_backoff_ms_ = std::min(current_backoff_ms_, kMaxBackoffMs);
+    const double jitter = utils::RandRange(1 - kJitter, 1 + kJitter);
+    return std::chrono::milliseconds{std::llround(current_backoff_ms_ * jitter)};
+}
+
+void RetryBackoff::Reset() {
+    current_backoff_ms_ = kInitialBackoffMs;
+    initial_ = true;
+}
+
+}  // namespace ugrpc::client::impl
+
+USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/impl/retry_policy.cpp b/grpc/src/ugrpc/client/impl/retry_policy.cpp
index b424dc48b542..08aec9f14813 100644
--- a/grpc/src/ugrpc/client/impl/retry_policy.cpp
+++ b/grpc/src/ugrpc/client/impl/retry_policy.cpp
@@ -1,70 +1,25 @@
-#include <ugrpc/client/impl/retry_policy.hpp>
-
-#include <algorithm>
-#include <cmath>
-
-#include <google/protobuf/util/time_util.h>
-
-#include <grpc/grpc.h>  // for GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-
-#include <userver/formats/json/inline.hpp>
-#include <userver/formats/json/value_builder.hpp>
-
-#include <userver/ugrpc/impl/to_string.hpp>
+#include <userver/ugrpc/client/impl/retry_policy.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client::impl {
 
-namespace {
-
-constexpr std::uint32_t kMaxAttempts = 5;
-
-constexpr std::int64_t kInitialBackoffMs = 10;
-constexpr std::int64_t kMaxBackoffMs = 300;
-
-constexpr float kBackoffMultiplier = 2.0;
-
-}  // namespace
-
-formats::json::Value ConstructDefaultRetryPolicy() {
-    formats::json::ValueBuilder retry_policy;
-    retry_policy["maxAttempts"] = kMaxAttempts;
-    retry_policy["initialBackoff"] = ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(
-        google::protobuf::util::TimeUtil::MillisecondsToDuration(kInitialBackoffMs)
-    ));
-    retry_policy["maxBackoff"] = ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(
-        google::protobuf::util::TimeUtil::MillisecondsToDuration(kMaxBackoffMs)
-    ));
-    retry_policy["backoffMultiplier"] = kBackoffMultiplier;
-    retry_policy["retryableStatusCodes"] = formats::json::MakeArray("UNAVAILABLE");
-    return retry_policy.ExtractValue();
-}
-
-std::chrono::milliseconds CalculateTotalTimeout(std::chrono::milliseconds timeout, std::uint32_t attempts) {
-    // Values greater than 5 are treated as 5 without being considered a validation error.
-    attempts = std::min(attempts, kMaxAttempts);
-
-    const std::int64_t timeout_ms = timeout.count();
-
-    std::int64_t total_timeout_ms = timeout_ms;
-#ifdef GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-    for (std::uint32_t n = 1; n < attempts; ++n) {
-        // https://github.com/grpc/proposal/blob/master/A6-client-retries.md
-        // The initial retry attempt will occur after initialBackoff * random(0.8, 1.2).
-        // After that, the n-th attempt will occur after min(initialBackoff*backoffMultiplier**(n-1), maxBackoff) *
-        // random(0.8, 1.2)).
-        const double backoff = std::min(
-            kInitialBackoffMs * std::pow(static_cast<double>(kBackoffMultiplier), n - 1),
-            static_cast<double>(kMaxBackoffMs)
-        );
-        // Jitter of plus or minus 0.2 is applied to the backoff delay
-        constexpr double kBackoffJitter = 0.2;
-        total_timeout_ms += timeout_ms + static_cast<std::int64_t>(std::ceil(backoff * (1 + kBackoffJitter)));
+/// [retryable]
+bool IsRetryable(grpc::StatusCode status_code) noexcept {
+    switch (status_code) {
+        case grpc::StatusCode::CANCELLED:
+        case grpc::StatusCode::UNKNOWN:
+        case grpc::StatusCode::DEADLINE_EXCEEDED:
+        case grpc::StatusCode::ABORTED:
+        case grpc::StatusCode::INTERNAL:
+        case grpc::StatusCode::UNAVAILABLE:
+            return true;
+
+        default:
+            return false;
     }
-#endif  // GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-    return std::chrono::milliseconds{total_timeout_ms};
 }
+/// [retryable]
 
 }  // namespace ugrpc::client::impl
 
diff --git a/grpc/src/ugrpc/client/impl/rpc.cpp b/grpc/src/ugrpc/client/impl/rpc.cpp
deleted file mode 100644
index adc895149c1d..000000000000
--- a/grpc/src/ugrpc/client/impl/rpc.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include <userver/ugrpc/client/impl/rpc.hpp>
-
-#include <userver/engine/task/cancel.hpp>
-
-#include <userver/ugrpc/client/exceptions.hpp>
-
-USERVER_NAMESPACE_BEGIN
-
-namespace ugrpc::client::impl {
-
-UnaryFinishFuture::UnaryFinishFuture(UnaryCallState& state, const google::protobuf::Message* response) noexcept
-    : state_{state}, response_{response} {}
-
-UnaryFinishFuture::~UnaryFinishFuture() { Destroy(); }
-
-void UnaryFinishFuture::Destroy() noexcept try {
-    if (state_.IsFinishProcessed()) {
-        return;
-    }
-    state_.SetFinishProcessed();
-    state_.GetClientContext().TryCancel();
-    auto& finish = state_.GetFinishAsyncMethodInvocation();
-
-    const engine::TaskCancellationBlocker cancel_blocker;
-    const auto wait_status = finish.Wait();
-
-    state_.GetStatsScope().SetFinishTime(finish.GetFinishTime());
-
-    switch (wait_status) {
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kOk:
-            ProcessFinishAbandoned(state_);
-            break;
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kError:
-            ProcessNetworkError(state_, "Finish");
-            break;
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kCancelled:
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kDeadline:
-            utils::AbortWithStacktrace("unreachable");
-    }
-} catch (const std::exception& ex) {
-    LOG_WARNING() << "There is a caught exception in 'UnaryFinishFuture::Destroy': " << ex;
-}
-
-bool UnaryFinishFuture::IsReady() const noexcept {
-    auto& finish = state_.GetFinishAsyncMethodInvocation();
-    return finish.IsReady();
-}
-
-engine::FutureStatus UnaryFinishFuture::WaitUntil(engine::Deadline deadline) const noexcept {
-    if (state_.IsFinishProcessed()) return engine::FutureStatus::kReady;
-
-    auto& finish = state_.GetFinishAsyncMethodInvocation();
-    const auto wait_status = impl::WaitAndTryCancelIfNeeded(finish, deadline, state_.GetClientContext());
-    switch (wait_status) {
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kOk:
-            state_.SetFinishProcessed();
-            state_.GetStatsScope().SetFinishTime(finish.GetFinishTime());
-            try {
-                ProcessFinish(state_, response_);
-            } catch (...) {
-                exception_ = std::current_exception();
-            }
-            return engine::FutureStatus::kReady;
-
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kError:
-            state_.SetFinishProcessed();
-            state_.GetStatsScope().SetFinishTime(finish.GetFinishTime());
-            ProcessNetworkError(state_, "Finish");
-            exception_ = std::make_exception_ptr(RpcInterruptedError(state_.GetCallName(), "Finish"));
-            return engine::FutureStatus::kReady;
-
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kCancelled:
-            state_.GetStatsScope().OnCancelled();
-            return engine::FutureStatus::kCancelled;
-
-        case ugrpc::impl::AsyncMethodInvocation::WaitStatus::kDeadline:
-            return engine::FutureStatus::kTimeout;
-    }
-
-    utils::AbortWithStacktrace("should be unreachable");
-}
-
-void UnaryFinishFuture::Get() {
-    UINVARIANT(!state_.IsStatusExtracted(), "'Get' called multiple times on the same future");
-    state_.SetStatusExtracted();
-
-    const auto future_status = WaitUntil(engine::Deadline{});
-
-    if (future_status == engine::FutureStatus::kCancelled) {
-        throw RpcCancelledError(state_.GetCallName(), "UnaryFuture::Get");
-    }
-    UASSERT(state_.IsFinishProcessed());
-
-    if (exception_) {
-        std::rethrow_exception(std::exchange(exception_, {}));
-    }
-
-    CheckFinishStatus(state_);
-}
-
-engine::impl::ContextAccessor* UnaryFinishFuture::TryGetContextAccessor() noexcept {
-    // Unfortunately, we can't require that TryGetContextAccessor is not called
-    // after future is finished - it doesn't match pattern usage of WaitAny
-    // Instead we should return nullptr
-    if (state_.IsStatusExtracted()) {
-        return nullptr;
-    }
-
-    // if state exists, then FinishAsyncMethodInvocation also exists
-    auto& finish = state_.GetFinishAsyncMethodInvocation();
-    return finish.TryGetContextAccessor();
-}
-
-}  // namespace ugrpc::client::impl
-
-USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/middlewares/deadline_propagation/middleware.cpp b/grpc/src/ugrpc/client/middlewares/deadline_propagation/middleware.cpp
index c0715e1b0324..b364553d73b6 100644
--- a/grpc/src/ugrpc/client/middlewares/deadline_propagation/middleware.cpp
+++ b/grpc/src/ugrpc/client/middlewares/deadline_propagation/middleware.cpp
@@ -19,15 +19,17 @@ void AddTimeoutMsToSpan(tracing::Span& span, Duration d) {
     span.AddTag(tracing::kTimeoutMs, ms.count());
 }
 
-void UpdateDeadline(impl::CallState& state) {
+void UpdateDeadline(MiddlewareCallContext& context) {
+    auto& state = context.GetState(utils::impl::InternalTag{});
+
     // Disable by config
     if (!state.GetConfigValues().enforce_task_deadline) {
         return;
     }
 
-    auto& context = state.GetClientContext();
+    auto& client_context = context.GetClientContext();
 
-    const auto context_time_left = ugrpc::TimespecToDuration(context.raw_deadline());
+    const auto context_time_left = ugrpc::TimespecToDuration(client_context.raw_deadline());
     const engine::Deadline task_deadline = USERVER_NAMESPACE::server::request::GetTaskInheritedDeadline();
 
     const auto client_deadline_reachable = (context_time_left != engine::Deadline::Duration::max());
@@ -36,7 +38,7 @@ void UpdateDeadline(impl::CallState& state) {
         return;
     }
 
-    auto& span = state.GetSpan();
+    auto& span = context.GetSpan();
     if (!task_deadline.IsReachable() && client_deadline_reachable) {
         AddTimeoutMsToSpan(span, context_time_left);
         return;
@@ -49,7 +51,7 @@ void UpdateDeadline(impl::CallState& state) {
         span.AddTag("deadline_updated", true);
         state.SetDeadlinePropagated();
 
-        context.set_deadline(ugrpc::DurationToTimespec(task_time_left));
+        client_context.set_deadline(ugrpc::DurationToTimespec(task_time_left));
 
         AddTimeoutMsToSpan(span, task_time_left);
     } else {
@@ -59,9 +61,7 @@ void UpdateDeadline(impl::CallState& state) {
 
 }  // namespace
 
-void Middleware::PreStartCall(MiddlewareCallContext& context) const {
-    UpdateDeadline(context.GetState(utils::impl::InternalTag{}));
-}
+void Middleware::PreStartCall(MiddlewareCallContext& context) const { UpdateDeadline(context); }
 
 }  // namespace ugrpc::client::middlewares::deadline_propagation
 
diff --git a/grpc/src/ugrpc/client/middlewares/log/middleware.cpp b/grpc/src/ugrpc/client/middlewares/log/middleware.cpp
index c804b7b51f30..3ae3de5c7a88 100644
--- a/grpc/src/ugrpc/client/middlewares/log/middleware.cpp
+++ b/grpc/src/ugrpc/client/middlewares/log/middleware.cpp
@@ -3,6 +3,7 @@
 #include <userver/logging/level.hpp>
 #include <userver/logging/log_extra.hpp>
 #include <userver/tracing/tags.hpp>
+#include <userver/ugrpc/protobuf_logging.hpp>
 #include <userver/ugrpc/status_codes.hpp>
 
 #include <ugrpc/impl/logging.hpp>
@@ -17,7 +18,7 @@ std::string GetMessageForLogging(const google::protobuf::Message& message, const
     if (!logging::ShouldLog(settings.msg_log_level)) {
         return "";
     }
-    return ugrpc::impl::GetMessageForLogging(message, settings.max_msg_size);
+    return ugrpc::ToLimitedDebugString(message, settings.max_msg_size);
 }
 
 class SpanLogger {
@@ -91,7 +92,7 @@ void Middleware::PostFinish(MiddlewareCallContext& context, const grpc::Status&
             logger.Log(settings_.msg_log_level, "gRPC response stream finished", logging::LogExtra{});
         }
     } else {
-        auto error_details = ugrpc::impl::GetErrorDetailsForLogging(status);
+        auto error_details = ugrpc::ToUnlimitedDebugString(status);
         logging::LogExtra extra{
             {ugrpc::impl::kTypeTag, "error_status"},
             {ugrpc::impl::kCodeTag, ugrpc::ToString(status.error_code())},
diff --git a/grpc/src/ugrpc/client/qos.cpp b/grpc/src/ugrpc/client/qos.cpp
index f8b05b28156f..245a4364b773 100644
--- a/grpc/src/ugrpc/client/qos.cpp
+++ b/grpc/src/ugrpc/client/qos.cpp
@@ -10,10 +10,6 @@
 #include <userver/formats/json/value_builder.hpp>
 #include <userver/formats/parse/common_containers.hpp>
 #include <userver/formats/serialize/common_containers.hpp>
-#include <userver/utils/assert.hpp>
-#include <userver/utils/numeric_cast.hpp>
-
-#include <ugrpc/client/impl/retry_policy.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -52,25 +48,6 @@ formats::json::Value Serialize(const Qos& qos, formats::serialize::To<formats::j
     return result.ExtractValue();
 }
 
-std::optional<std::uint32_t> GetAttempts(const Qos& qos) {
-    if (qos.attempts.has_value()) {
-        UINVARIANT(0 < *qos.attempts, "Qos attempts value must be greater than 0");
-        return utils::numeric_cast<std::uint32_t>(*qos.attempts);
-    }
-    return std::nullopt;
-}
-
-std::optional<std::chrono::milliseconds> GetTotalTimeout(const Qos& qos) {
-    if (qos.timeout.has_value()) {
-        const auto attempts = GetAttempts(qos);
-        if (attempts.has_value()) {
-            return impl::CalculateTotalTimeout(*qos.timeout, *attempts);
-        }
-        return *qos.timeout;
-    }
-    return std::nullopt;
-}
-
 }  // namespace ugrpc::client
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/retry_config.cpp b/grpc/src/ugrpc/client/retry_config.cpp
new file mode 100644
index 000000000000..86fbf03ced36
--- /dev/null
+++ b/grpc/src/ugrpc/client/retry_config.cpp
@@ -0,0 +1,17 @@
+#include <userver/ugrpc/client/retry_config.hpp>
+
+#include <userver/yaml_config/yaml_config.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::client {
+
+RetryConfig Parse(const yaml_config::YamlConfig& value, formats::parse::To<RetryConfig>) {
+    RetryConfig retry_config;
+    retry_config.attempts = value["attempts"].As<int>(retry_config.attempts);
+    return retry_config;
+}
+
+}  // namespace ugrpc::client
+
+USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/client/secdist.hpp b/grpc/src/ugrpc/client/secdist.hpp
index 1dd3db3e7a1c..b9b5e02330ab 100644
--- a/grpc/src/ugrpc/client/secdist.hpp
+++ b/grpc/src/ugrpc/client/secdist.hpp
@@ -1,5 +1,10 @@
 #pragma once
 
+#include <string>
+#include <unordered_map>
+
+#include <userver/formats/json/value.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::client {
diff --git a/grpc/src/ugrpc/impl/logging.cpp b/grpc/src/ugrpc/impl/logging.cpp
index 60ea723616f5..1ea755627ae9 100644
--- a/grpc/src/ugrpc/impl/logging.cpp
+++ b/grpc/src/ugrpc/impl/logging.cpp
@@ -1,14 +1,5 @@
 #include <ugrpc/impl/logging.hpp>
 
-#include <fmt/format.h>
-
-#include <userver/logging/log.hpp>
-
-#include <userver/ugrpc/status_codes.hpp>
-#include <userver/ugrpc/status_utils.hpp>
-
-#include <ugrpc/impl/protobuf_utils.hpp>
-
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::impl {
@@ -19,28 +10,6 @@ const std::string kComponentTag{"grpc_component"};
 const std::string kMessageMarshalledLenTag{"grpc_message_marshalled_len"};
 const std::string kTypeTag{"grpc_type"};
 
-std::string GetMessageForLogging(const google::protobuf::Message& message, std::size_t max_size) {
-    return ugrpc::impl::ToLimitedDebugString(message, max_size);
-}
-
-std::string GetErrorDetailsForLogging(const grpc::Status& status) {
-    if (status.ok()) {
-        return "";
-    }
-
-    const auto gstatus = ugrpc::ToGoogleRpcStatus(status);
-    return gstatus.has_value()
-               ? fmt::format(
-                     "code: {}, error message: {}\nerror details:\n{}",
-                     ugrpc::ToString(status.error_code()),
-                     status.error_message(),
-                     ugrpc::GetGStatusLimitedMessage(*gstatus)
-                 )
-               : fmt::format(
-                     "code: {}, error message: {}", ugrpc::ToString(status.error_code()), status.error_message()
-                 );
-}
-
 }  // namespace ugrpc::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/impl/logging.hpp b/grpc/src/ugrpc/impl/logging.hpp
index 7803afea4f54..1e7ab449d530 100644
--- a/grpc/src/ugrpc/impl/logging.hpp
+++ b/grpc/src/ugrpc/impl/logging.hpp
@@ -1,10 +1,6 @@
 #pragma once
-
 #include <string>
 
-#include <google/protobuf/message.h>
-#include <grpcpp/support/status.h>
-
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::impl {
@@ -15,10 +11,6 @@ extern const std::string kComponentTag;
 extern const std::string kMessageMarshalledLenTag;
 extern const std::string kTypeTag;
 
-std::string GetMessageForLogging(const google::protobuf::Message& message, std::size_t max_size);
-
-std::string GetErrorDetailsForLogging(const grpc::Status& status);
-
 }  // namespace ugrpc::impl
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/impl/protobuf_utils.hpp b/grpc/src/ugrpc/impl/protobuf_utils.hpp
deleted file mode 100644
index 233e73644db5..000000000000
--- a/grpc/src/ugrpc/impl/protobuf_utils.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <google/protobuf/message.h>
-
-USERVER_NAMESPACE_BEGIN
-
-namespace ugrpc::impl {
-
-std::string ToLimitedDebugString(const google::protobuf::Message& message, std::size_t limit);
-
-}  // namespace ugrpc::impl
-
-USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/impl/statistics.cpp b/grpc/src/ugrpc/impl/statistics.cpp
index 6aca768c1c49..a9f1d719fe99 100644
--- a/grpc/src/ugrpc/impl/statistics.cpp
+++ b/grpc/src/ugrpc/impl/statistics.cpp
@@ -209,10 +209,12 @@ void ServiceStatistics::DumpAndCountTotal(
     std::optional<std::string_view> client_name,
     MethodStatisticsSnapshot& total
 ) const {
-    for (const auto& [i, method_full_name] : utils::enumerate(metadata_.method_full_names)) {
+    for (const auto& [i, method_descriptor] : utils::enumerate(metadata_.methods)) {
         const MethodStatisticsSnapshot snapshot{method_statistics_[i]};
         total.Add(snapshot);
-        DumpMetricWithLabels(writer, snapshot, client_name, method_full_name, metadata_.service_full_name);
+        DumpMetricWithLabels(
+            writer, snapshot, client_name, method_descriptor.method_full_name, metadata_.service_full_name
+        );
     }
 }
 
diff --git a/grpc/src/ugrpc/proto_json.cpp b/grpc/src/ugrpc/proto_json.cpp
index 583d42da9015..6da37724fe40 100644
--- a/grpc/src/ugrpc/proto_json.cpp
+++ b/grpc/src/ugrpc/proto_json.cpp
@@ -82,74 +82,74 @@ class ResultStackFrame final {
         : ResultStackFrame(ParseType(iter), iter->GetSize(), GetName(iter, previous_type)) {}
 
     void SetStructField(std::string_view field_name, google::protobuf::Value&& field) {
-        UINVARIANT(type == Type::kStruct, "invalid type");
+        UINVARIANT(type_ == Type::kStruct, "invalid type");
 #if GOOGLE_PROTOBUF_VERSION >= 4022000
-        (*value.mutable_struct_value()->mutable_fields())[field_name] = std::move(field);
+        (*value_.mutable_struct_value()->mutable_fields())[field_name] = std::move(field);
 #else
         // No transparent comparisons till
         // https://github.com/protocolbuffers/protobuf/commit/38d6de1eef8163342084fe
-        (*value.mutable_struct_value()->mutable_fields())[std::string{field_name}] = std::move(field);
+        (*value_.mutable_struct_value()->mutable_fields())[std::string{field_name}] = std::move(field);
 #endif
 
-        --elements_await;
+        --elements_await_;
     }
 
     void AddListElement(google::protobuf::Value&& field) {
-        UINVARIANT(type == Type::kArray, "invalid type");
-        *(value.mutable_list_value()->mutable_values()->Add()) = std::move(field);
-        --elements_await;
+        UINVARIANT(type_ == Type::kArray, "invalid type");
+        *(value_.mutable_list_value()->mutable_values()->Add()) = std::move(field);
+        --elements_await_;
     }
 
-    bool IsStruct() const { return type == Type::kStruct; }
+    bool IsStruct() const { return type_ == Type::kStruct; }
 
-    bool IsArray() const { return type == Type::kArray; }
+    bool IsArray() const { return type_ == Type::kArray; }
 
-    Type GetType() const { return type; }
+    Type GetType() const { return type_; }
 
-    bool AwaitElements() const { return elements_await != 0; }
+    bool AwaitElements() const { return elements_await_ != 0; }
 
-    std::string_view GetOuterFieldName() const { return outer_field_name; }
+    std::string_view GetOuterFieldName() const { return outer_field_name_; }
 
-    google::protobuf::Value GetValue() { return google::protobuf::Value(std::move(value)); }
+    google::protobuf::Value GetValue() { return google::protobuf::Value(std::move(value_)); }
 
 private:
     ResultStackFrame(const Type type, std::size_t elements_await, std::string&& outer_field_name)
-        : type(type), elements_await(elements_await), outer_field_name(outer_field_name) {
+        : type_(type), elements_await_(elements_await), outer_field_name_(outer_field_name) {
         if (type == Type::kStruct) {
-            value.mutable_struct_value();
+            value_.mutable_struct_value();
         } else {
-            value.mutable_list_value();
+            value_.mutable_list_value();
         }
     }
 
 private:
-    Type type;
-    std::size_t elements_await;
-    std::string outer_field_name;
-    google::protobuf::Value value{};
+    Type type_;
+    std::size_t elements_await_;
+    std::string outer_field_name_;
+    google::protobuf::Value value_{};
 };
 
 class StackFrame {
 public:
     using Iterator = formats::json::Value::const_iterator;
 
-    StackFrame(Iterator begin, Iterator end) : cur(begin), end(end) {}
+    StackFrame(Iterator begin, Iterator end) : cur_(begin), end_(end) {}
 
-    bool IsTrivial() const { return !(cur->IsObject() || cur->IsArray()); }
+    bool IsTrivial() const { return !(cur_->IsObject() || cur_->IsArray()); }
 
-    std::size_t GetSize() const { return cur->GetSize(); }
+    std::size_t GetSize() const { return cur_->GetSize(); }
 
-    Iterator GetIter() const { return cur; }
+    Iterator GetIter() const { return cur_; }
 
-    std::string GetName() const { return cur.GetName(); }
+    std::string GetName() const { return cur_.GetName(); }
 
-    void Advance() { ++cur; }
+    void Advance() { ++cur_; }
 
-    bool IsValid() const { return cur != end; }
+    bool IsValid() const { return cur_ != end_; }
 
 private:
-    Iterator cur;
-    Iterator end;
+    Iterator cur_;
+    Iterator end_;
 };
 
 static constexpr std::size_t kInitialStackDepth = 32;
diff --git a/grpc/src/ugrpc/impl/protobuf_utils.cpp b/grpc/src/ugrpc/protobuf_logging.cpp
similarity index 74%
rename from grpc/src/ugrpc/impl/protobuf_utils.cpp
rename to grpc/src/ugrpc/protobuf_logging.cpp
index daf8679272bc..4c1430da1e2c 100644
--- a/grpc/src/ugrpc/impl/protobuf_utils.cpp
+++ b/grpc/src/ugrpc/protobuf_logging.cpp
@@ -1,16 +1,12 @@
-#include <ugrpc/impl/protobuf_utils.hpp>
-
-#include <exception>
-#include <memory>
-#include <unordered_set>
+#include <userver/ugrpc/protobuf_logging.hpp>
 
 #include <google/protobuf/descriptor.pb.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 #include <google/protobuf/text_format.h>
-#include <grpcpp/support/config.h>
 #include <boost/container/small_vector.hpp>
 
 #include <userver/compiler/thread_local.hpp>
+#include <userver/ugrpc/status_codes.hpp>
+#include <userver/ugrpc/status_utils.hpp>
 #include <userver/utils/assert.hpp>
 #include <userver/utils/numeric_cast.hpp>
 
@@ -97,11 +93,11 @@ class DebugRedactFieldValuePrinter final : public google::protobuf::TextFormat::
         const google::protobuf::Message& /*message*/,
         int /*fieldIndex*/,
         int /*fieldCount*/,
-        bool singleLineMode,
+        bool single_line_mode,
         BaseTextGenerator* generator
     ) const override {
         PrintRedacted(generator);
-        if (singleLineMode) {
+        if (single_line_mode) {
             generator->PrintLiteral(" ");
         } else {
             generator->PrintLiteral("\n");
@@ -189,31 +185,89 @@ compiler::ThreadLocal kDebugStringPrinter = [] { return DebugStringPrinter{}; };
 
 }  // namespace
 
+void Print(const google::protobuf::Message& message, google::protobuf::io::ZeroCopyOutputStream& output_stream) {
+    auto printer = kDebugStringPrinter.Use();
+    printer->RegisterDebugRedactPrinters(*message.GetDescriptor());
+    printer->Print(message, output_stream);
+}
+
+}  // namespace ugrpc::impl
+
+namespace ugrpc {
+
 std::string ToLimitedDebugString(const google::protobuf::Message& message, std::size_t limit) {
     boost::container::small_vector<char, 1024> output_buffer{limit, boost::container::default_init};
     google::protobuf::io::ArrayOutputStream output_stream{output_buffer.data(), utils::numeric_cast<int>(limit)};
 
-    auto printer = kDebugStringPrinter.Use();
+    auto printer = impl::kDebugStringPrinter.Use();
     printer->RegisterDebugRedactPrinters(*message.GetDescriptor());
 
 #if defined(ARCADIA_ROOT) || GOOGLE_PROTOBUF_VERSION >= 6031002
     // Throw `LimitReachedException` on limit reached to stop printing immediately, otherwise TextFormat will continue
     // to walk the whole message and apply noop printing.
-    LimitingOutputStream limiting_output_stream{output_stream};
+    impl::LimitingOutputStream limiting_output_stream{output_stream};
     try {
-        printer->Print(message, limiting_output_stream);
-    } catch (const LimitingOutputStream::LimitReachedException& /*ex*/) {
+        impl::Print(message, limiting_output_stream);
+    } catch (const impl::LimitingOutputStream::LimitReachedException& /*ex*/) {
         // Buffer limit has been reached.
     }
 #else
     // For old protobuf, we cannot apply hard limits when printing messages, because its TextFormat is not
     // exception-safe. https://github.com/protocolbuffers/protobuf/commit/be875d0aaf37dbe6948717ea621278e75e89c9c7
-    printer->Print(message, output_stream);
+    impl::Print(message, output_stream);
 #endif
+    std::string returned_str = std::string{output_buffer.data(), static_cast<std::size_t>(output_stream.ByteCount())};
+    if (returned_str.empty() && limit >= 7) return "<EMPTY>";
+    return returned_str;
+}
 
-    return std::string{output_buffer.data(), static_cast<std::size_t>(output_stream.ByteCount())};
+std::string ToUnlimitedDebugString(const google::protobuf::Message& message) {
+    grpc::string result;
+    google::protobuf::io::StringOutputStream output_stream(&result);
+    impl::Print(message, output_stream);
+    std::string returned_str = std::string(result);
+    if (returned_str.empty()) return "<EMPTY>";
+    return returned_str;
 }
 
-}  // namespace ugrpc::impl
+std::string ToLimitedDebugString(const grpc::Status& status, std::size_t max_size) {
+    if (status.ok()) {
+        return "OK";
+    }
+
+    const auto gstatus = ugrpc::ToGoogleRpcStatus(status);
+    if (gstatus.has_value()) {
+        const std::string details_string = ugrpc::ToLimitedDebugString(*gstatus, max_size);
+        return fmt::format(
+            "code: {}, error message: {}\nerror details:\n{}",
+            ugrpc::ToString(status.error_code()),
+            status.error_message(),
+            details_string
+        );
+    } else {
+        return fmt::format("code: {}, error message: {}", ugrpc::ToString(status.error_code()), status.error_message());
+    }
+}
+
+std::string ToUnlimitedDebugString(const grpc::Status& status) {
+    if (status.ok()) {
+        return "OK";
+    }
+
+    const auto gstatus = ugrpc::ToGoogleRpcStatus(status);
+    if (gstatus.has_value()) {
+        const std::string details_string = ugrpc::ToUnlimitedDebugString(*gstatus);
+        return fmt::format(
+            "code: {}, error message: {}\nerror details:\n{}",
+            ugrpc::ToString(status.error_code()),
+            status.error_message(),
+            details_string
+        );
+    } else {
+        return fmt::format("code: {}, error message: {}", ugrpc::ToString(status.error_code()), status.error_message());
+    }
+}
+
+}  // namespace ugrpc
 
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/protobuf_visit.cpp b/grpc/src/ugrpc/protobuf_visit.cpp
index 1bc10c8999db..daab1985cf58 100644
--- a/grpc/src/ugrpc/protobuf_visit.cpp
+++ b/grpc/src/ugrpc/protobuf_visit.cpp
@@ -7,9 +7,8 @@
 #include <userver/utils/assert.hpp>
 #include <userver/utils/impl/internal_tag.hpp>
 
-#include <ugrpc/impl/protobuf_utils.hpp>
 #include <userver/ugrpc/impl/protobuf_collector.hpp>
-#include <userver/ugrpc/protobuf_visit.hpp>
+#include <userver/ugrpc/protobuf_logging.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
diff --git a/grpc/src/ugrpc/server/impl/call_processor.cpp b/grpc/src/ugrpc/server/impl/call_processor.cpp
index e1a19a2cf860..1a7aab73c5d6 100644
--- a/grpc/src/ugrpc/server/impl/call_processor.cpp
+++ b/grpc/src/ugrpc/server/impl/call_processor.cpp
@@ -2,6 +2,8 @@
 
 #include <chrono>
 
+#include <boost/container/flat_map.hpp>
+
 #include <userver/logging/impl/logger_base.hpp>
 #include <userver/logging/log.hpp>
 #include <userver/tracing/opentelemetry.hpp>
@@ -20,20 +22,21 @@ namespace ugrpc::server::impl {
 
 namespace {
 
-void ReportFinishSuccess(
-    const grpc::Status& status,
-    tracing::Span& span,
-    ugrpc::impl::RpcStatisticsScope& statistics_scope
-) noexcept {
+void ReportFinishSuccess(const grpc::Status& status, CallState& state) noexcept {
     try {
         const auto status_code = status.error_code();
-        statistics_scope.OnExplicitFinish(status_code);
+        state.statistics_scope.OnExplicitFinish(status_code);
 
+        auto& span = state.GetSpan();
         span.AddNonInheritableTag("grpc_code", ugrpc::ToString(status_code));
         if (!status.ok()) {
             span.AddNonInheritableTag(tracing::kErrorFlag, true);
             span.AddNonInheritableTag(tracing::kErrorMessage, status.error_message());
-            span.SetLogLevel(IsServerError(status_code) ? logging::Level::kError : logging::Level::kWarning);
+            const auto default_error_log_level =
+                IsServerError(status.error_code()) ? logging::Level::kError : logging::Level::kWarning;
+            const auto error_log_level =
+                utils::FindOrDefault(state.status_codes_log_level, status.error_code(), default_error_log_level);
+            span.SetLogLevel(error_log_level);
         }
     } catch (const std::exception& ex) {
         LOG_ERROR() << "Error in ReportFinishSuccess: " << ex;
@@ -143,7 +146,7 @@ ReportCustomError(const USERVER_NAMESPACE::server::handlers::CustomHandlerExcept
 
 void CheckFinishStatus(bool finish_op_succeeded, const grpc::Status& status, CallState& state) noexcept {
     if (finish_op_succeeded) {
-        ReportFinishSuccess(status, state.GetSpan(), state.statistics_scope);
+        ReportFinishSuccess(status, state);
     } else {
         ReportRpcInterruptedError(state);
     }
diff --git a/grpc/src/ugrpc/server/impl/format_log_message.cpp b/grpc/src/ugrpc/server/impl/format_log_message.cpp
index 3d7aec140bfb..c0927aa730c2 100644
--- a/grpc/src/ugrpc/server/impl/format_log_message.cpp
+++ b/grpc/src/ugrpc/server/impl/format_log_message.cpp
@@ -5,9 +5,11 @@
 #include <fmt/format.h>
 
 #include <userver/compiler/thread_local.hpp>
+#include <userver/logging/impl/logger_base.hpp>
 #include <userver/ugrpc/impl/to_string.hpp>
 #include <userver/utils/datetime.hpp>
 #include <userver/utils/encoding/tskv.hpp>
+#include <userver/utils/impl/source_location.hpp>
 #include <userver/utils/text_light.hpp>
 
 USERVER_NAMESPACE_BEGIN
@@ -61,17 +63,26 @@ std::string_view GetCurrentTimeString(std::chrono::system_clock::time_point star
         );
         cache->cached_time = rounded_now;
     }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-stack-address"
+#endif
     return std::string_view{cache->cached_time_string, kTimeTemplate.size()};
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
 }
 
 }  // namespace
 
-std::string FormatLogMessage(
+logging::impl::LogExtraTskvFormatter FormatLogMessage(
     const std::multimap<grpc::string_ref, grpc::string_ref>& metadata,
     std::string_view peer,
     std::chrono::system_clock::time_point start_time,
     std::string_view call_name,
-    grpc::StatusCode code
+    grpc::StatusCode code,
+    const logging::LogExtra* log_extra
 ) {
     static const auto timezone = utils::datetime::LocalTimezoneTimestring(start_time, "%z");
 
@@ -88,9 +99,10 @@ std::string FormatLogMessage(
     const auto request_time_seconds = std::chrono::duration_cast<std::chrono::seconds>(request_time);
     const auto request_time_milliseconds = request_time - request_time_seconds;
 
-    // FMT_COMPILE makes it slower
-    return fmt::format(
-        "tskv"
+    logging::impl::LogExtraTskvFormatter formatter(logging::Format::kRaw);
+
+    fmt::format_to(
+        std::back_inserter(formatter.GetTextLogItem().log_line),
         "\ttimestamp={}"
         "\ttimezone={}"
         "\tuser_agent={}"
@@ -100,16 +112,13 @@ std::string FormatLogMessage(
         "\trequest_time={}.{:0>3}"
         "\tupstream_response_time={}.{:0>3}"
         "\tgrpc_status={}"
-        "\tgrpc_status_code={}\n",
+        "\tgrpc_status_code={}",
         GetCurrentTimeString(start_time),
         timezone,
         EscapeForAccessTskvLog(user_agent),
         ip,
         ip,
         EscapeForAccessTskvLog(call_name),
-        // request_time should represent the time from the first byte received to the last byte sent.
-        // We are currently being inexact here by not including the time for initial request deserialization
-        // and the time for the final response serialization.
         request_time_seconds.count(),
         request_time_milliseconds.count(),
         // TODO remove, this is for safe migration from old access log parsers.
@@ -118,6 +127,12 @@ std::string FormatLogMessage(
         static_cast<int>(code),
         ToString(code)
     );
+
+    if (log_extra) {
+        formatter.Append(*log_extra);
+    }
+
+    return formatter;
 }
 
 }  // namespace ugrpc::server::impl
diff --git a/grpc/src/ugrpc/server/impl/format_log_message.hpp b/grpc/src/ugrpc/server/impl/format_log_message.hpp
index 17dea33bf59d..015b92dde67e 100644
--- a/grpc/src/ugrpc/server/impl/format_log_message.hpp
+++ b/grpc/src/ugrpc/server/impl/format_log_message.hpp
@@ -4,18 +4,22 @@
 #include <grpcpp/support/string_ref.h>
 
 #include <userver/dynamic_config/snapshot.hpp>
+#include <userver/logging/impl/log_extra_tskv_formatter.hpp>
+#include <userver/logging/impl/logger_base.hpp>
+#include <userver/logging/log_extra.hpp>
 #include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace ugrpc::server::impl {
 
-std::string FormatLogMessage(
+logging::impl::LogExtraTskvFormatter FormatLogMessage(
     const std::multimap<grpc::string_ref, grpc::string_ref>& metadata,
     std::string_view peer,
     std::chrono::system_clock::time_point start_time,
     std::string_view call_name,
-    grpc::StatusCode code
+    grpc::StatusCode code,
+    const logging::LogExtra* log_extra
 );
 
 }  // namespace ugrpc::server::impl
diff --git a/grpc/src/ugrpc/server/impl/generic_service_worker.cpp b/grpc/src/ugrpc/server/impl/generic_service_worker.cpp
index 47287e0a865f..1c5a34dcb870 100644
--- a/grpc/src/ugrpc/server/impl/generic_service_worker.cpp
+++ b/grpc/src/ugrpc/server/impl/generic_service_worker.cpp
@@ -12,11 +12,14 @@ namespace ugrpc::server::impl {
 
 namespace {
 
-constexpr std::string_view kGenericMethodFullNamesFake[] = {
-    "Generic/Generic",
-};
-constexpr std::string_view kGenericServiceNameFake = "Generic";
-constexpr ugrpc::impl::StaticServiceMetadata kGenericMetadataFake{kGenericServiceNameFake, kGenericMethodFullNamesFake};
+constexpr std::string_view kGenericServiceFullNameFake = "Generic";
+
+constexpr std::array kGenericMethodsFake = {ugrpc::impl::MethodDescriptor{
+    /*method_full_name*/ "Generic/Generic",
+    /*method_type*/ ugrpc::impl::RpcType::kBidiStreaming,
+}};
+
+constexpr ugrpc::impl::StaticServiceMetadata kGenericMetadataFake{kGenericServiceFullNameFake, kGenericMethodsFake};
 
 }  // namespace
 
diff --git a/grpc/src/ugrpc/server/impl/parse_config.cpp b/grpc/src/ugrpc/server/impl/parse_config.cpp
index 8ca976fc293d..b442905d2df8 100644
--- a/grpc/src/ugrpc/server/impl/parse_config.cpp
+++ b/grpc/src/ugrpc/server/impl/parse_config.cpp
@@ -1,7 +1,9 @@
 #include <ugrpc/server/impl/parse_config.hpp>
 
+#include <boost/container/flat_map.hpp>
 #include <boost/range/adaptor/transformed.hpp>
 
+#include <userver/formats/parse/common_containers.hpp>
 #include <userver/fs/blocking/read.hpp>
 #include <userver/logging/component.hpp>
 #include <userver/logging/impl/logger_base.hpp>
@@ -11,6 +13,7 @@
 #include <userver/utils/algo.hpp>
 
 #include <userver/ugrpc/server/middlewares/base.hpp>
+#include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -19,6 +22,7 @@ namespace ugrpc::server::impl {
 namespace {
 
 constexpr std::string_view kTaskProcessorKey = "task-processor";
+constexpr std::string_view kStatusCodesLogLevelKey = "status-codes-log-level";
 
 template <typename ParserFunc>
 auto ParseOptional(
@@ -71,6 +75,8 @@ server::ServiceConfig ParseServiceConfig(
             value[kTaskProcessorKey], defaults.task_processor, context, ParseTaskProcessor
         ),
         /*middlewares=*/{},
+        /*status_codes_log_level=*/
+        value[kStatusCodesLogLevelKey].As<boost::container::flat_map<grpc::StatusCode, logging::Level>>({}),
     };
 }
 
diff --git a/grpc/src/ugrpc/server/middlewares/access_log/log_extra.cpp b/grpc/src/ugrpc/server/middlewares/access_log/log_extra.cpp
new file mode 100644
index 000000000000..5c13942d55dc
--- /dev/null
+++ b/grpc/src/ugrpc/server/middlewares/access_log/log_extra.cpp
@@ -0,0 +1,21 @@
+#include <userver/ugrpc/server/middlewares/access_log/log_extra.hpp>
+
+#include <userver/ugrpc/server/middlewares/access_log/component.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace ugrpc::server::middlewares::access_log {
+
+void SetAdditionalLogKeys(MiddlewareCallContext& context, logging::LogExtra&& log_extra) {
+    auto* extra = context.GetStorageContext().GetOptional(kLogExtraTag);
+
+    if (extra) {
+        extra->Extend(std::move(log_extra));
+    } else {
+        context.GetStorageContext().Emplace(kLogExtraTag, std::move(log_extra));
+    }
+}
+
+}  // namespace ugrpc::server::middlewares::access_log
+
+USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/server/middlewares/access_log/middleware.cpp b/grpc/src/ugrpc/server/middlewares/access_log/middleware.cpp
index b339ddcb3805..a202cfa608ed 100644
--- a/grpc/src/ugrpc/server/middlewares/access_log/middleware.cpp
+++ b/grpc/src/ugrpc/server/middlewares/access_log/middleware.cpp
@@ -21,14 +21,20 @@ void WriteAccessLog(
         constexpr auto kLevel = logging::Level::kInfo;
 
         if (access_tskv_logger.ShouldLog(kLevel)) {
-            logging::impl::TextLogItem log_item{impl::FormatLogMessage(
-                server_context.client_metadata(),
-                server_context.peer(),
-                context.GetSpan().GetStartSystemTime(),
-                context.GetCallName(),
-                status.error_code()
-            )};
-            access_tskv_logger.Log(kLevel, log_item);
+            const auto* log_extra = context.GetStorageContext().GetOptional(kLogExtraTag);
+
+            access_tskv_logger.Log(
+                kLevel,
+                impl::FormatLogMessage(
+                    server_context.client_metadata(),
+                    server_context.peer(),
+                    context.GetSpan().GetStartSystemTime(),
+                    context.GetCallName(),
+                    status.error_code(),
+                    log_extra
+                )
+                    .ExtractTextLogItem()
+            );
         }
     } catch (const std::exception& ex) {
         LOG_ERROR() << "Error in WriteAccessLog: " << ex;
diff --git a/grpc/src/ugrpc/server/middlewares/access_log/middleware.hpp b/grpc/src/ugrpc/server/middlewares/access_log/middleware.hpp
index 1647e694faa7..760be090158b 100644
--- a/grpc/src/ugrpc/server/middlewares/access_log/middleware.hpp
+++ b/grpc/src/ugrpc/server/middlewares/access_log/middleware.hpp
@@ -2,6 +2,7 @@
 
 #include <userver/logging/fwd.hpp>
 
+#include <userver/ugrpc/server/middlewares/access_log/component.hpp>
 #include <userver/ugrpc/server/middlewares/base.hpp>
 
 USERVER_NAMESPACE_BEGIN
diff --git a/grpc/src/ugrpc/server/middlewares/log/component.cpp b/grpc/src/ugrpc/server/middlewares/log/component.cpp
index 2dfc9cc63c21..baf2851a0204 100644
--- a/grpc/src/ugrpc/server/middlewares/log/component.cpp
+++ b/grpc/src/ugrpc/server/middlewares/log/component.cpp
@@ -1,12 +1,14 @@
 #include <userver/ugrpc/server/middlewares/log/component.hpp>
 
 #include <userver/components/component_config.hpp>
+#include <userver/formats/parse/common_containers.hpp>
 #include <userver/logging/level_serialization.hpp>
 #include <userver/yaml_config/merge_schemas.hpp>
 
 #include <ugrpc/server/middlewares/log/middleware.hpp>
 #include <userver/middlewares/groups.hpp>
 #include <userver/ugrpc/server/middlewares/access_log/component.hpp>
+#include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -18,6 +20,8 @@ Settings Parse(const yaml_config::YamlConfig& config, formats::parse::To<Setting
     settings.msg_log_level = config["msg-log-level"].As<logging::Level>(settings.msg_log_level);
     settings.max_msg_size = config["msg-size-log-limit"].As<std::size_t>(settings.max_msg_size);
     settings.local_log_level = config["local-log-level"].As<logging::Level>(settings.local_log_level);
+    settings.status_codes_log_level =
+        config["status-codes-log-level"].As<boost::container::flat_map<grpc::StatusCode, logging::Level>>({});
     return settings;
 }
 
@@ -57,6 +61,21 @@ additionalProperties: false
     local-log-level:
         type: string
         description: local log level of the span for user-provided handler
+    status-codes-log-level:
+        type: object
+        properties: {}
+        additionalProperties:
+            type: string
+            description: log level
+        description: |
+            gRPC status code string -> log level map.
+            Allows overriding the log level for the response for individual statuses.
+            See grpcpp StatusCode documentation for the list of possible values:
+            https://grpc.github.io/grpc/cpp/namespacegrpc.html#aff1730578c90160528f6a8d67ef5c43b
+
+            Example:
+              -  FAILED_PRECONDITION: info
+
 )");
 }
 
diff --git a/grpc/src/ugrpc/server/middlewares/log/middleware.cpp b/grpc/src/ugrpc/server/middlewares/log/middleware.cpp
index ae510ce1156c..95c2c967bbed 100644
--- a/grpc/src/ugrpc/server/middlewares/log/middleware.cpp
+++ b/grpc/src/ugrpc/server/middlewares/log/middleware.cpp
@@ -2,8 +2,8 @@
 
 #include <userver/logging/log_extra.hpp>
 #include <userver/tracing/tags.hpp>
-
-#include <userver/ugrpc/status_codes.hpp>
+#include <userver/ugrpc/protobuf_logging.hpp>
+#include <userver/utils/algo.hpp>
 
 #include <ugrpc/impl/logging.hpp>
 
@@ -17,7 +17,7 @@ std::string GetMessageForLogging(const google::protobuf::Message& message, const
     if (!logging::ShouldLog(settings.msg_log_level)) {
         return "";
     }
-    return ugrpc::impl::GetMessageForLogging(message, settings.max_msg_size);
+    return ugrpc::ToLimitedDebugString(message, settings.max_msg_size);
 }
 
 class Logger {
@@ -93,15 +93,17 @@ void Middleware::OnCallFinish(MiddlewareCallContext& context, const grpc::Status
             );
         }
     } else {
-        auto error_details = ugrpc::impl::GetErrorDetailsForLogging(status);
+        auto error_details = ugrpc::ToLimitedDebugString(status, settings_.max_msg_size);
         logging::LogExtra extra{
             {"type", "response"},
             {ugrpc::impl::kCodeTag, ugrpc::ToString(status.error_code())},
             {ugrpc::impl::kTypeTag, "error_status"},
             {ugrpc::impl::kBodyTag, std::move(error_details)},
         };
-        const auto error_log_level =
+        const auto default_error_log_level =
             IsServerError(status.error_code()) ? logging::Level::kError : logging::Level::kWarning;
+        const auto error_log_level =
+            utils::FindOrDefault(settings_.status_codes_log_level, status.error_code(), default_error_log_level);
         logger.Log(error_log_level, "gRPC error", std::move(extra));
     }
 }
diff --git a/grpc/src/ugrpc/server/middlewares/log/middleware.hpp b/grpc/src/ugrpc/server/middlewares/log/middleware.hpp
index 7d8ad7013cc2..a9284a2660ef 100644
--- a/grpc/src/ugrpc/server/middlewares/log/middleware.hpp
+++ b/grpc/src/ugrpc/server/middlewares/log/middleware.hpp
@@ -2,9 +2,12 @@
 
 #include <cstddef>
 
+#include <boost/container/flat_map.hpp>
+
 #include <userver/logging/level.hpp>
 
 #include <userver/ugrpc/server/middlewares/base.hpp>
+#include <userver/ugrpc/status_codes.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -35,6 +38,10 @@ struct Settings final {
     /// It applies to logs in user-provided handler
     /// @ref tracing::Span::SetLocalLogLevel
     logging::Level local_log_level{logging::Level::kDebug};
+
+    /// map of "status_code": log_level items to override span log level for specific status codes
+    /// see @ref ugrpc::kStatusCodesMap for available statuses
+    boost::container::flat_map<grpc::StatusCode, logging::Level> status_codes_log_level;
 };
 
 class Middleware final : public MiddlewareBase {
diff --git a/grpc/src/ugrpc/server/server.cpp b/grpc/src/ugrpc/server/server.cpp
index c580bad28444..508202c22a40 100644
--- a/grpc/src/ugrpc/server/server.cpp
+++ b/grpc/src/ugrpc/server/server.cpp
@@ -198,6 +198,7 @@ impl::ServiceInternals Server::Impl::MakeServiceInternals(ServiceConfig&& config
         statistics_storage_,
         std::move(config.middlewares),
         config_source_,
+        std::move(config.status_codes_log_level),
     };
 }
 
diff --git a/grpc/src/ugrpc/server/service_component_base.cpp b/grpc/src/ugrpc/server/service_component_base.cpp
index 8cece85ba3ba..8a59d9284dac 100644
--- a/grpc/src/ugrpc/server/service_component_base.cpp
+++ b/grpc/src/ugrpc/server/service_component_base.cpp
@@ -52,6 +52,20 @@ additionalProperties: false
         type: string
         description: the task processor to use for responses
         defaultDescription: uses grpc-server.service-defaults.task-processor
+    status-codes-log-level:
+        type: object
+        properties: {}
+        additionalProperties:
+            type: string
+            description: log level
+        description: |
+            gRPC status code string -> log level map.
+            Allows overriding the log level for the span for individual statuses.
+            See grpcpp StatusCode documentation for the list of possible values:
+            https://grpc.github.io/grpc/cpp/namespacegrpc.html#aff1730578c90160528f6a8d67ef5c43b
+
+            Example:
+              -  FAILED_PRECONDITION: info
 )");
 }
 
diff --git a/grpc/src/ugrpc/status_codes.cpp b/grpc/src/ugrpc/status_codes.cpp
index b7caf9deeefd..021e77874251 100644
--- a/grpc/src/ugrpc/status_codes.cpp
+++ b/grpc/src/ugrpc/status_codes.cpp
@@ -2,9 +2,12 @@
 
 #include <fmt/format.h>
 
+#include <userver/formats/json.hpp>
+#include <userver/utils/algo.hpp>
 #include <userver/utils/assert.hpp>
 #include <userver/utils/trivial_map.hpp>
 #include <userver/utils/underlying_value.hpp>
+#include <userver/yaml_config/yaml_config.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -72,4 +75,30 @@ bool IsServerError(grpc::StatusCode status) noexcept {
 
 }  // namespace ugrpc
 
+namespace formats::parse {
+
+grpc::StatusCode Parse(const yaml_config::YamlConfig& value, To<grpc::StatusCode>) {
+    return utils::ParseFromValueString(value, ugrpc::kStatusCodesMap);
+}
+
+grpc::StatusCode Parse(std::string_view value, To<grpc::StatusCode>) {
+    const auto result = ugrpc::kStatusCodesMap.TryFind(value);
+    if (!result) {
+        throw std::runtime_error(fmt::format(
+            "Invalid value of grpc::StatusCode: '{}' is not one of {}", value, ugrpc::kStatusCodesMap.DescribeSecond()
+        ));
+    }
+    return *result;
+}
+
+}  // namespace formats::parse
+
+namespace formats::serialize {
+
+formats::json::Value Serialize(const grpc::StatusCode& value, formats::serialize::To<formats::json::Value>) {
+    return formats::json::ValueBuilder(ugrpc::ToString(value)).ExtractValue();
+}
+
+}  // namespace formats::serialize
+
 USERVER_NAMESPACE_END
diff --git a/grpc/src/ugrpc/status_utils.cpp b/grpc/src/ugrpc/status_utils.cpp
index 2d05370ccd0e..3eef83b2786e 100644
--- a/grpc/src/ugrpc/status_utils.cpp
+++ b/grpc/src/ugrpc/status_utils.cpp
@@ -1,6 +1,6 @@
 #include <userver/ugrpc/status_utils.hpp>
 
-#include <ugrpc/impl/protobuf_utils.hpp>
+#include <userver/ugrpc/protobuf_logging.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -27,7 +27,7 @@ std::optional<google::rpc::Status> ToGoogleRpcStatus(const grpc::Status& status)
 
 std::string GetGStatusLimitedMessage(const google::rpc::Status& status) {
     constexpr std::size_t kLengthLimit = 1024;
-    return impl::ToLimitedDebugString(status, kLengthLimit);
+    return ToLimitedDebugString(status, kLengthLimit);
 }
 
 }  // namespace ugrpc
diff --git a/grpc/src/ugrpc/tests/service.cpp b/grpc/src/ugrpc/tests/service.cpp
index c63975d07b0c..5475b5b660a2 100644
--- a/grpc/src/ugrpc/tests/service.cpp
+++ b/grpc/src/ugrpc/tests/service.cpp
@@ -30,10 +30,7 @@ void ServiceBase::RegisterService(server::GenericServiceBase& service) {
 
 server::ServiceConfig ServiceBase::MakeServiceConfig() {
     middlewares_change_allowed_ = false;
-    return server::ServiceConfig{
-        engine::current_task::GetTaskProcessor(),
-        server_middlewares_,
-    };
+    return server::ServiceConfig{engine::current_task::GetTaskProcessor(), server_middlewares_, {}};
 }
 
 void ServiceBase::StartServer(client::ClientFactorySettings&& client_factory_settings) {
diff --git a/grpc/tests/channel_arguments_builder_test.cpp b/grpc/tests/channel_arguments_builder_test.cpp
deleted file mode 100644
index d270d4bedcca..000000000000
--- a/grpc/tests/channel_arguments_builder_test.cpp
+++ /dev/null
@@ -1,462 +0,0 @@
-#include <userver/utest/utest.hpp>
-
-#include <google/protobuf/util/time_util.h>
-
-#include <userver/formats/json/inline.hpp>
-#include <userver/formats/json/serialize.hpp>
-#include <userver/formats/json/value_builder.hpp>
-#include <userver/formats/serialize/common_containers.hpp>
-#include <userver/logging/log.hpp>
-
-#include <userver/ugrpc/client/client_qos.hpp>
-#include <userver/ugrpc/client/impl/channel_arguments_builder.hpp>
-#include <userver/ugrpc/impl/to_string.hpp>
-
-#include <tests/unit_test_client.usrv.pb.hpp>
-
-USERVER_NAMESPACE_BEGIN
-
-namespace {
-
-formats::json::Value BuildSimpleRetryPolicyConfig() {
-    formats::json::ValueBuilder retry_policy{formats::common::Type::kObject};
-    retry_policy["maxAttempts"] = 5;
-    retry_policy["initialBackoff"] = "0.010s";
-    retry_policy["maxBackoff"] = "0.300s";
-    retry_policy["backoffMultiplier"] = 2;
-    retry_policy["retryableStatusCodes"] = formats::json::MakeArray("UNAVAILABLE");
-    return retry_policy.ExtractValue();
-}
-
-formats::json::Value BuildMethodConfig(
-    const std::vector<std::pair<std::string_view, std::string_view>>& name,
-    std::optional<google::protobuf::Duration> timeout,
-    const formats::json::Value& retry_policy
-) {
-    formats::json::ValueBuilder method_config{formats::common::Type::kObject};
-
-    for (auto [service_name, method_name] : name) {
-        method_config["name"].PushBack(formats::json::MakeObject("service", service_name, "method", method_name));
-    }
-
-    if (timeout.has_value()) {
-        method_config["timeout"] = ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(*timeout));
-    }
-
-    method_config["retryPolicy"] = retry_policy;
-
-    return method_config.ExtractValue();
-}
-
-formats::json::Value BuildMethodConfig(
-    std::string_view service_name,
-    std::string_view method_name,
-    std::optional<google::protobuf::Duration> timeout,
-    const formats::json::Value& retry_policy
-) {
-    return BuildMethodConfig({{service_name, method_name}}, timeout, retry_policy);
-}
-
-formats::json::Value
-BuildDefaultMethodConfig(std::optional<google::protobuf::Duration> timeout, const formats::json::Value& retry_policy) {
-    // If the 'service' field is empty, the 'method' field must be empty, and
-    //   this MethodConfig specifies the default for all methods (it's the default
-    //   config).
-    return BuildMethodConfig("", "", timeout, retry_policy);
-}
-
-void VerifyMethodConfig(
-    const formats::json::Value& method_config,
-    std::optional<std::string_view> service_name,
-    std::optional<std::string_view> method_name,
-    std::optional<google::protobuf::Duration> timeout,
-    std::optional<std::uint32_t> attempts
-) {
-    ASSERT_TRUE(method_config["name"].IsArray());
-    ASSERT_EQ(1, method_config["name"].GetSize());
-    const auto& name = method_config["name"][0];
-    ASSERT_EQ(service_name, name["service"].As<std::optional<std::string>>());
-    ASSERT_EQ(method_name, name["method"].As<std::optional<std::string>>());
-
-    ASSERT_EQ(timeout.has_value(), method_config.HasMember("timeout"));
-    if (timeout.has_value()) {
-        ASSERT_EQ(google::protobuf::util::TimeUtil::ToString(*timeout), method_config["timeout"].As<std::string>());
-    }
-
-    ASSERT_EQ(attempts.has_value(), method_config.HasMember("retryPolicy"));
-    if (attempts.has_value()) {
-        const auto& retry_policy = method_config["retryPolicy"];
-        ASSERT_TRUE(retry_policy.IsObject());
-        ASSERT_TRUE(retry_policy.HasMember("maxAttempts"));
-        ASSERT_EQ(attempts, retry_policy["maxAttempts"].As<std::uint32_t>());
-    }
-}
-
-}  // namespace
-
-UTEST(ServiceConfigBuilderTest, BuildEmpty) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    {
-        const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{metadata, std::nullopt};
-        const auto service_config = service_config_builder.Build(ugrpc::client::ClientQos{});
-        ASSERT_TRUE(service_config.IsNull());
-    }
-
-    {
-        const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{metadata, "{}"};
-        const auto service_config = service_config_builder.Build(ugrpc::client::ClientQos{});
-        ASSERT_TRUE(service_config.IsObject() && service_config.IsEmpty());
-    }
-}
-
-UTEST(ServiceConfigBuilderTest, BuildEmptyRetryPolicy) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto default_timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-    const auto method_config_json = BuildDefaultMethodConfig(default_timeout, retry_policy_json);
-    const auto static_service_config =
-        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos_default{/*attempts*/ 1, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.SetDefault(qos_default);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(1, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/{},
-        /*method_name=*/{},
-        /*timeout=*/default_timeout,
-        /*attempts=*/{}
-    );
-}
-
-UTEST(ServiceConfigBuilderTest, StaticAndQosSameMethod) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto service_name = metadata.service_full_name;
-
-    const auto timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-    const auto method_config_json =
-        BuildMethodConfig(service_name, GetMethodName(metadata, 0), timeout, retry_policy_json);
-    const auto static_service_config =
-        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos0{/*attempts*/ 3, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.Set(GetMethodFullName(metadata, 0), qos0);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(1, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 0),
-        /*timeout=*/timeout,
-        /*attempts=*/qos0.attempts
-    );
-}
-
-UTEST(ServiceConfigBuilderTest, StaticAndQosDifferentMethods) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto service_name = metadata.service_full_name;
-
-    const auto timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-    const auto method_config_json =
-        BuildMethodConfig(service_name, GetMethodName(metadata, 0), timeout, retry_policy_json);
-    const auto static_service_config =
-        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos1{/*attempts*/ 3, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.Set(GetMethodFullName(metadata, 1), qos1);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(2, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 0),
-        /*timeout=*/timeout,
-        /*attempts=*/retry_policy_json["maxAttempts"].As<std::uint32_t>()
-    );
-
-    VerifyMethodConfig(
-        method_config[1],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 1),
-        /*timeout=*/{},
-        /*attempts=*/qos1.attempts
-    );
-}
-
-UTEST(ServiceConfigBuilderTest, StaticAndDefaultQos) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto service_name = metadata.service_full_name;
-
-    const auto timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-    const auto method_config_json =
-        BuildMethodConfig(service_name, GetMethodName(metadata, 0), timeout, retry_policy_json);
-    const auto static_service_config =
-        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos_default{/*attempts*/ 3, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.SetDefault(qos_default);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(2, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 0),
-        /*timeout=*/timeout,
-        /*attempts=*/qos_default.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[1],
-        /*service_name=*/{},
-        /*method_name=*/{},
-        /*timeout=*/{},
-        /*attempts=*/qos_default.attempts
-    );
-}
-
-UTEST(ServiceConfigBuilderTest, DefaultStaticAndQos) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto service_name = metadata.service_full_name;
-
-    const auto default_timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-    const auto method_config_json = BuildDefaultMethodConfig(default_timeout, retry_policy_json);
-    const auto static_service_config =
-        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos0{/*attempts*/ 3, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.Set(GetMethodFullName(metadata, 0), qos0);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(2, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 0),
-        /*timeout=*/default_timeout,
-        /*attempts=*/qos0.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[1],
-        /*service_name=*/{},
-        /*method_name=*/{},
-        /*timeout=*/default_timeout,
-        /*attempts=*/retry_policy_json["maxAttempts"].As<std::uint32_t>()
-    );
-}
-
-UTEST(ServiceConfigBuilderTest, ComplexName) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto service_name = metadata.service_full_name;
-
-    const auto timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-    const auto name = std::vector<std::pair<std::string_view, std::string_view>>{
-        {service_name, GetMethodName(metadata, 0)}, {service_name, GetMethodName(metadata, 1)}, {"", ""}};
-    const auto method_config_json = BuildMethodConfig(name, timeout, retry_policy_json);
-
-    const auto static_service_config =
-        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos0{/*attempts*/ 3, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.Set(GetMethodFullName(metadata, 0), qos0);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(3, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 0),
-        /*timeout=*/timeout,
-        /*attempts=*/qos0.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[1],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 1),
-        /*timeout=*/timeout,
-        /*attempts=*/retry_policy_json["maxAttempts"].As<std::uint32_t>()
-    );
-
-    VerifyMethodConfig(
-        method_config[2],
-        /*service_name=*/{},
-        /*method_name=*/{},
-        /*timeout=*/timeout,
-        /*attempts=*/retry_policy_json["maxAttempts"].As<std::uint32_t>()
-    );
-}
-
-UTEST(ServiceConfigBuilderTest, Complex) {
-    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
-
-    const auto service_name = metadata.service_full_name;
-
-    const auto timeout0 = google::protobuf::util::TimeUtil::MillisecondsToDuration(100);
-    const auto timeout2 = google::protobuf::util::TimeUtil::MillisecondsToDuration(500);
-    const auto default_timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1500);
-
-    const auto retry_policy_json = BuildSimpleRetryPolicyConfig();
-
-    const auto method0_config_json =
-        BuildMethodConfig(service_name, GetMethodName(metadata, 0), timeout0, retry_policy_json);
-    const auto method2_config_json =
-        BuildMethodConfig(service_name, GetMethodName(metadata, 2), timeout2, retry_policy_json);
-    const auto method3_config_json =
-        BuildMethodConfig(service_name, GetMethodName(metadata, 3), std::nullopt, retry_policy_json);
-    const auto default_method_config_json = BuildDefaultMethodConfig(default_timeout, retry_policy_json);
-
-    const auto static_service_config = formats::json::MakeObject(
-        "methodConfig",
-        formats::json::MakeArray(
-            method0_config_json, method2_config_json, method3_config_json, default_method_config_json
-        )
-    );
-    LOG_DEBUG() << "static_service_config: " << static_service_config;
-
-    const ugrpc::client::impl::ServiceConfigBuilder service_config_builder{
-        metadata, formats::json::ToString(static_service_config)};
-
-    const ugrpc::client::Qos qos0{/*attempts*/ 2, /**/ std::nullopt};
-    const ugrpc::client::Qos qos1{/*attempts*/ 3, /**/ std::nullopt};
-    const ugrpc::client::Qos qos3{/*attempts*/ std::nullopt, /**/ std::nullopt};
-    const ugrpc::client::Qos qos_default{/*attempts*/ 4, /**/ std::nullopt};
-    ugrpc::client::ClientQos client_qos;
-    client_qos.methods.Set(GetMethodFullName(metadata, 0), qos0);
-    client_qos.methods.Set(GetMethodFullName(metadata, 1), qos1);
-    client_qos.methods.Set(GetMethodFullName(metadata, 3), qos3);
-    client_qos.methods.SetDefault(qos_default);
-
-    const auto service_config = service_config_builder.Build(client_qos);
-    LOG_DEBUG() << "service_config: " << service_config;
-
-    ASSERT_TRUE(service_config.HasMember("methodConfig"));
-    const auto& method_config = service_config["methodConfig"];
-    ASSERT_TRUE(method_config.IsArray());
-    ASSERT_EQ(5, method_config.GetSize());
-
-    VerifyMethodConfig(
-        method_config[0],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 0),
-        /*timeout=*/timeout0,
-        /*attempts=*/qos0.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[1],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 1),
-        /*timeout=*/default_timeout,
-        /*attempts=*/qos1.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[2],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 2),
-        /*timeout=*/timeout2,
-        /*attempts=*/qos_default.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[3],
-        /*service_name=*/service_name,
-        /*method_name=*/GetMethodName(metadata, 3),
-        /*timeout=*/std::nullopt,
-        /*attempts=*/qos_default.attempts
-    );
-
-    VerifyMethodConfig(
-        method_config[4],
-        /*service_name=*/{},
-        /*method_name=*/{},
-        /*timeout=*/default_timeout,
-        /*attempts=*/qos_default.attempts
-    );
-}
-
-USERVER_NAMESPACE_END
diff --git a/grpc/tests/client_factory_test.cpp b/grpc/tests/client_factory_test.cpp
index 00510a607015..bbbada0f523a 100644
--- a/grpc/tests/client_factory_test.cpp
+++ b/grpc/tests/client_factory_test.cpp
@@ -1,6 +1,7 @@
 #include <userver/ugrpc/client/client_factory.hpp>
 
 #include <userver/ugrpc/client/impl/client_data.hpp>
+#include <userver/ugrpc/client/impl/client_data_accessor.hpp>
 #include <userver/utest/utest.hpp>
 
 #include <tests/service_multichannel.hpp>
@@ -13,7 +14,7 @@ using GrpcClientMultichannel = tests::ServiceFixtureMultichannel<sample::ugrpc::
 
 UTEST_P(GrpcClientMultichannel, ChannelsCount) {
     auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
-    const auto& data = ugrpc::client::impl::GetClientData(client);
+    const auto& data = ugrpc::client::impl::ClientDataAccessor::GetClientData(client);
     const auto stub_state = data.GetStubState();
     ASSERT_EQ(stub_state->stubs.Size(), GetParam());
 }
diff --git a/grpc/tests/client_middleware_hooks_test.cpp b/grpc/tests/client_middleware_hooks_test.cpp
index 838d7942dcf7..d6e50d63b065 100644
--- a/grpc/tests/client_middleware_hooks_test.cpp
+++ b/grpc/tests/client_middleware_hooks_test.cpp
@@ -218,25 +218,32 @@ UTEST_F(ClientMiddlewaresHooksTest, HappyPathBidirectionalStreaming) {
 }
 
 UTEST_F(ClientMiddlewaresHooksTest, HappyPathDetailedUnary) {
-    SetHappyPathUnary();
-
     ::testing::MockFunction<void(std::string_view checkpoint_name)> checkpoint;
+
+    EXPECT_CALL(Service(), SayHello).WillOnce([&](CallContext&, Request&& request) {
+        checkpoint.Call("Handler");
+
+        Response response;
+        response.set_name("Hello " + request.name());
+        return response;
+    });
+
     {
         const ::testing::InSequence s;
 
-        // Pre* called after request created
+        // Pre* called before Handler
         EXPECT_CALL(Middleware(0), PreStartCall).Times(1);
         EXPECT_CALL(Middleware(0), PreSendMessage).Times(1);
         EXPECT_CALL(Middleware(0), PostRecvMessage).Times(0);
         EXPECT_CALL(Middleware(0), PostFinish).Times(0);
-        EXPECT_CALL(checkpoint, Call("AfterCallStart"));
 
-        // Post* called after Finish
+        EXPECT_CALL(checkpoint, Call("Handler"));
+
+        // Post* called after Handler
         EXPECT_CALL(Middleware(0), PreStartCall).Times(0);
         EXPECT_CALL(Middleware(0), PreSendMessage).Times(0);
         EXPECT_CALL(Middleware(0), PostRecvMessage).Times(1);
         EXPECT_CALL(Middleware(0), PostFinish).Times(1);
-        EXPECT_CALL(checkpoint, Call("AfterCallDone"));
     }
 
     Request request;
@@ -244,14 +251,12 @@ UTEST_F(ClientMiddlewaresHooksTest, HappyPathDetailedUnary) {
 
     // Pre* called after request created
     auto future = Client().AsyncSayHello(request);
-    checkpoint.Call("AfterCallStart");
 
     const auto status = future.WaitUntil(engine::Deadline::FromDuration(utest::kMaxTestWaitTime));
     EXPECT_EQ(status, engine::FutureStatus::kReady);
 
     const auto response = future.Get();
     EXPECT_EQ(response.name(), "Hello userver");
-    checkpoint.Call("AfterCallDone");
 }
 
 UTEST_F(ClientMiddlewaresHooksTest, HappyPathDetailedClientStreaming) {
@@ -408,7 +413,7 @@ UTEST_F(ClientMiddlewaresHooksTest, MiddlewareExceptionUnaryPreStart) {
 
     Request request;
     request.set_name("userver");
-    UEXPECT_THROW(auto future = Client().AsyncSayHello(request), std::runtime_error);
+    UEXPECT_THROW(auto future = Client().SayHello(request), std::runtime_error);
 }
 
 UTEST_F(ClientMiddlewaresHooksTest, MiddlewareExceptionUnaryPreSend) {
@@ -426,7 +431,7 @@ UTEST_F(ClientMiddlewaresHooksTest, MiddlewareExceptionUnaryPreSend) {
 
     Request request;
     request.set_name("userver");
-    UEXPECT_THROW(auto future = Client().AsyncSayHello(request), std::runtime_error);
+    UEXPECT_THROW(auto future = Client().SayHello(request), std::runtime_error);
 }
 
 UTEST_F(ClientMiddlewaresHooksTest, MiddlewareExceptionUnaryPostRecv) {
@@ -519,22 +524,24 @@ UTEST_F(ClientMiddlewaresHooksTest, MiddlewareExceptionBidirectionalStreaming) {
 }
 
 UTEST_F(ClientMiddlewaresHooksTest, ExceptionWhenCancelledUnary) {
+    engine::SingleUseEvent event;
+    EXPECT_CALL(Service(), SayHello).WillOnce([&](CallContext&, Request&&) {
+        event.Send();
+        engine::InterruptibleSleepFor(utest::kMaxTestWaitTime);
+        return Response{};
+    });
+
     EXPECT_CALL(Middleware(0), PreStartCall).Times(1);
     EXPECT_CALL(Middleware(0), PreSendMessage).Times(1);
     EXPECT_CALL(Middleware(0), PostRecvMessage).Times(0);  // skipped, because no response message.
     EXPECT_CALL(Middleware(0), PostFinish).Times(0);
 
-    SetUnary([](CallContext&, Request&&) -> UnaryResult {
-        engine::InterruptibleSleepFor(utest::kMaxTestWaitTime);
-
-        return Response{};
-    });
-
     {
         Request request;
         request.set_name("userver");
         const auto future = Client().AsyncSayHello(request);
 
+        event.Wait();
         engine::current_task::GetCancellationToken().RequestCancel();
 
         // The destructor of `future` will cancel the RPC and await grpcpp cleanup (and don't run middlewares).
@@ -580,16 +587,45 @@ UTEST_F(ClientMiddlewaresHooksTest, BadStatusClientStreaming) {
     UEXPECT_THROW(auto response = stream.Finish(), ugrpc::client::InvalidArgumentError);
 }
 
-UTEST_F(ClientMiddlewaresHooksTest, Abandoned) {
+UTEST_F(ClientMiddlewaresHooksTest, AbandonedUnary) {
+    engine::SingleUseEvent event;
+    EXPECT_CALL(Service(), SayHello).WillOnce([&](CallContext&, Request&&) {
+        event.Send();
+        engine::InterruptibleSleepFor(utest::kMaxTestWaitTime);
+        return Response{};
+    });
+
+    EXPECT_CALL(Middleware(0), PreStartCall).Times(1);
+    EXPECT_CALL(Middleware(0), PreSendMessage).Times(1);
+    EXPECT_CALL(Middleware(0), PostRecvMessage).Times(0);
+    EXPECT_CALL(Middleware(0), PostFinish).Times(0);
+
+    EXPECT_FALSE(GetStatistics("grpc.client.total").SingleMetricOptional("abandoned-error"));
+    EXPECT_FALSE(GetStatistics("grpc.client.total", {{"grpc_code", "CANCELLED"}}).SingleMetricOptional("status"));
+
+    {
+        Request request;
+        auto response_future = Client().AsyncSayHello(request);
+        event.Wait();
+    }
+
+    EXPECT_EQ(GetMetric("abandoned-error"), 1);
+    EXPECT_FALSE(GetStatistics("grpc.client.total", {{"grpc_code", "CANCELLED"}}).SingleMetricOptional("status"));
+
+    EXPECT_EQ(GetMetric("cancelled"), 0);
+    EXPECT_EQ(GetMetric("status", {{"grpc_code", "OK"}}), 0);
+    EXPECT_EQ(GetMetric("status", {{"grpc_code", "UNKNOWN"}}), 0);
+}
+
+UTEST_F(ClientMiddlewaresHooksTest, AbandonedStreaming) {
     SetHappyPathBidirectionalStreaming();
     SetHappyPathClientStreaming();
     SetHappyPathServerStreaming();
-    SetHappyPathUnary();
 
-    // Five streams were created.
-    EXPECT_CALL(Middleware(0), PreStartCall).Times(5);
-    // WriteAndCheck + ReadMany + AsyncSayHello
-    EXPECT_CALL(Middleware(0), PreSendMessage).Times(3);
+    // Four streams were created.
+    EXPECT_CALL(Middleware(0), PreStartCall).Times(4);
+    // WriteAndCheck + ReadMany
+    EXPECT_CALL(Middleware(0), PreSendMessage).Times(2);
     // Skipped, because no response messages.
     EXPECT_CALL(Middleware(0), PostRecvMessage).Times(0);
     // We don't run middlewares in a destructors of RPC.
@@ -625,17 +661,12 @@ UTEST_F(ClientMiddlewaresHooksTest, Abandoned) {
         UEXPECT_NO_THROW(const auto stream = Client().ReadMany(request));
     }
     check_metrics(3);
-    {
-        Request request;
-        UEXPECT_NO_THROW(auto future = Client().AsyncSayHello(request));
-    }
-    check_metrics(4);
     {
         auto stream = Client().Chat();
         StreamResponse response;
         UEXPECT_NO_THROW(const auto future = stream.ReadAsync(response));
     }
-    check_metrics(5);
+    check_metrics(4);
 }
 
 UTEST_F(ClientMiddlewaresHooksTest, BadStatusServerStreaming) {
diff --git a/grpc/tests/compat/channel_arguments_builder_test.cpp b/grpc/tests/compat/channel_arguments_builder_test.cpp
new file mode 100644
index 000000000000..b11b0a788854
--- /dev/null
+++ b/grpc/tests/compat/channel_arguments_builder_test.cpp
@@ -0,0 +1,321 @@
+#include <userver/utest/utest.hpp>
+
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/formats/json/inline.hpp>
+#include <userver/formats/json/serialize.hpp>
+#include <userver/formats/json/value_builder.hpp>
+#include <userver/formats/serialize/common_containers.hpp>
+#include <userver/logging/log.hpp>
+
+#include <userver/ugrpc/client/client_qos.hpp>
+#include <userver/ugrpc/client/impl/compat/channel_arguments_builder.hpp>
+#include <userver/ugrpc/impl/to_string.hpp>
+
+#include <tests/unit_test_client.usrv.pb.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+formats::json::Value BuildSimpleRetryPolicyConfig(std::uint32_t max_attempts) {
+    formats::json::ValueBuilder retry_policy{formats::common::Type::kObject};
+    retry_policy["maxAttempts"] = max_attempts;
+    retry_policy["initialBackoff"] = "0.010s";
+    retry_policy["maxBackoff"] = "0.300s";
+    retry_policy["backoffMultiplier"] = 2;
+    retry_policy["retryableStatusCodes"] = formats::json::MakeArray("UNAVAILABLE");
+    return retry_policy.ExtractValue();
+}
+
+formats::json::Value BuildMethodConfig(
+    const std::vector<std::pair<std::optional<std::string_view>, std::optional<std::string_view>>>& name,
+    std::optional<google::protobuf::Duration> timeout,
+    const formats::json::Value& retry_policy
+) {
+    formats::json::ValueBuilder method_config{formats::common::Type::kObject};
+
+    for (const auto& [service, method] : name) {
+        formats::json::ValueBuilder name_entry{formats::common::Type::kObject};
+        if (service.has_value()) {
+            name_entry["service"] = service;
+        }
+        if (method.has_value()) {
+            name_entry["method"] = method;
+        }
+        method_config["name"].PushBack(name_entry.ExtractValue());
+    }
+
+    if (timeout.has_value()) {
+        method_config["timeout"] = ugrpc::impl::ToString(google::protobuf::util::TimeUtil::ToString(*timeout));
+    }
+
+    method_config["retryPolicy"] = retry_policy;
+
+    return method_config.ExtractValue();
+}
+
+formats::json::Value
+BuildDefaultMethodConfig(std::optional<google::protobuf::Duration> timeout, const formats::json::Value& retry_policy) {
+    // If the 'service' field is empty, the 'method' field must be empty, and
+    //   this MethodConfig specifies the default for all methods (it's the default
+    //   config).
+    return BuildMethodConfig({{std::nullopt, std::nullopt}}, timeout, retry_policy);
+}
+
+void VerifyMethodConfig(
+    const formats::json::Value& method_config,
+    std::vector<std::pair<std::optional<std::string_view>, std::optional<std::string_view>>> name,
+    std::optional<google::protobuf::Duration> timeout,
+    std::optional<std::uint32_t> attempts
+) {
+    ASSERT_TRUE(method_config["name"].IsArray());
+    ASSERT_EQ(name.size(), method_config["name"].GetSize());
+    size_t i = 0;
+    for (const auto& [service, method] : name) {
+        ASSERT_EQ(service, method_config["name"][i]["service"].As<std::optional<std::string>>());
+        ASSERT_EQ(method, method_config["name"][i]["method"].As<std::optional<std::string>>());
+        ++i;
+    }
+
+    ASSERT_EQ(timeout.has_value(), method_config.HasMember("timeout"));
+    if (timeout.has_value()) {
+        ASSERT_EQ(google::protobuf::util::TimeUtil::ToString(*timeout), method_config["timeout"].As<std::string>());
+    }
+
+    ASSERT_EQ(attempts.has_value(), method_config.HasMember("retryPolicy"));
+    if (attempts.has_value()) {
+        const auto& retry_policy = method_config["retryPolicy"];
+        ASSERT_TRUE(retry_policy.IsObject());
+        ASSERT_TRUE(retry_policy.HasMember("maxAttempts"));
+        ASSERT_EQ(attempts, retry_policy["maxAttempts"].As<std::uint32_t>());
+    }
+}
+
+}  // namespace
+
+UTEST(ServiceConfigBuilderTest, BuildEmpty) {
+    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
+
+    const ugrpc::client::RetryConfig retry_config;
+
+    {
+        const ugrpc::client::impl::compat::ServiceConfigBuilder service_config_builder{
+            metadata, retry_config, /*static_service_config=*/std::nullopt};
+        const auto service_config = service_config_builder.Build(ugrpc::client::ClientQos{});
+        ASSERT_TRUE(service_config.IsNull());
+    }
+
+    {
+        const ugrpc::client::impl::compat::ServiceConfigBuilder service_config_builder{
+            metadata, retry_config, /*static_service_config=*/"{}"};
+        const auto service_config = service_config_builder.Build(ugrpc::client::ClientQos{});
+        ASSERT_TRUE(service_config.IsObject() && service_config.IsEmpty());
+    }
+}
+
+UTEST(ServiceConfigBuilderTest, Static) {
+    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
+
+    const ugrpc::client::RetryConfig retry_config{/*attempts=*/2};
+
+    const ugrpc::client::impl::compat::ServiceConfigBuilder service_config_builder{
+        metadata, retry_config, /*static_service_config=*/std::nullopt};
+    const auto service_config = service_config_builder.Build(ugrpc::client::ClientQos{});
+    LOG_DEBUG() << "service_config: " << service_config;
+
+    ASSERT_TRUE(service_config.HasMember("methodConfig"));
+    const auto& method_config = service_config["methodConfig"];
+    ASSERT_TRUE(method_config.IsArray());
+    ASSERT_EQ(1, method_config.GetSize());
+
+    VerifyMethodConfig(
+        method_config[0],
+        {{"sample.ugrpc.UnitTestService", "ReadMany"},
+         {"sample.ugrpc.UnitTestService", "WriteMany"},
+         {"sample.ugrpc.UnitTestService", "Chat"}},
+        /*timeout=*/std::nullopt,
+        /*attempts=*/retry_config.attempts
+    );
+}
+
+UTEST(ServiceConfigBuilderTest, Qos) {
+    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
+
+    const ugrpc::client::RetryConfig retry_config;
+
+    const auto default_timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
+
+    std::uint32_t max_attempts = 5;
+    const auto retry_policy_json = BuildSimpleRetryPolicyConfig(max_attempts);
+    const auto method_config_json = BuildDefaultMethodConfig(default_timeout, retry_policy_json);
+    const auto static_service_config =
+        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
+    LOG_DEBUG() << "static_service_config: " << static_service_config;
+
+    const ugrpc::client::impl::compat::ServiceConfigBuilder service_config_builder{
+        metadata, retry_config, formats::json::ToString(static_service_config)};
+
+    const ugrpc::client::Qos qos_default{/*attempts=*/2, /*timeout=*/std::nullopt};
+    ugrpc::client::ClientQos client_qos;
+    client_qos.methods.SetDefault(qos_default);
+
+    const auto service_config = service_config_builder.Build(client_qos);
+    LOG_DEBUG() << "service_config: " << service_config;
+
+    ASSERT_TRUE(service_config.HasMember("methodConfig"));
+    const auto& method_config = service_config["methodConfig"];
+    ASSERT_TRUE(method_config.IsArray());
+    ASSERT_EQ(2, method_config.GetSize());
+
+    VerifyMethodConfig(
+        method_config[0],
+        {{"sample.ugrpc.UnitTestService", "ReadMany"},
+         {"sample.ugrpc.UnitTestService", "WriteMany"},
+         {"sample.ugrpc.UnitTestService", "Chat"}},
+        /*timeout=*/default_timeout,
+        /*attempts=*/*qos_default.attempts
+    );
+
+    VerifyMethodConfig(
+        method_config[1],
+        {{/*service_name=*/std::nullopt, /*method_name=*/std::nullopt}},
+        /*timeout=*/default_timeout,
+        /*attempts=*/max_attempts
+    );
+}
+
+UTEST(ServiceConfigBuilderTest, QosNoRetry) {
+    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
+
+    const ugrpc::client::RetryConfig retry_config;
+
+    const auto default_timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1000);
+
+    std::uint32_t max_attempts = 5;
+    const auto retry_policy_json = BuildSimpleRetryPolicyConfig(max_attempts);
+    const auto method_config_json = BuildDefaultMethodConfig(default_timeout, retry_policy_json);
+    const auto static_service_config =
+        formats::json::MakeObject("methodConfig", formats::json::MakeArray(method_config_json));
+    LOG_DEBUG() << "static_service_config: " << static_service_config;
+
+    const ugrpc::client::impl::compat::ServiceConfigBuilder service_config_builder{
+        metadata, retry_config, formats::json::ToString(static_service_config)};
+
+    const ugrpc::client::Qos qos_default{/*attempts=*/1, /*timeout=*/std::nullopt};
+    ugrpc::client::ClientQos client_qos;
+    client_qos.methods.SetDefault(qos_default);
+
+    const auto service_config = service_config_builder.Build(client_qos);
+    LOG_DEBUG() << "service_config: " << service_config;
+
+    ASSERT_TRUE(service_config.HasMember("methodConfig"));
+    const auto& method_config = service_config["methodConfig"];
+    ASSERT_TRUE(method_config.IsArray());
+    ASSERT_EQ(2, method_config.GetSize());
+
+    VerifyMethodConfig(
+        method_config[0],
+        {{"sample.ugrpc.UnitTestService", "ReadMany"},
+         {"sample.ugrpc.UnitTestService", "WriteMany"},
+         {"sample.ugrpc.UnitTestService", "Chat"}},
+        /*timeout=*/default_timeout,
+        /*attempts=*/{}
+    );
+
+    VerifyMethodConfig(
+        method_config[1],
+        {{/*service_name=*/std::nullopt, /*method_name=*/std::nullopt}},
+        /*timeout=*/default_timeout,
+        /*attempts=*/max_attempts
+    );
+}
+
+UTEST(ServiceConfigBuilderTest, Complex) {
+    const auto metadata = sample::ugrpc::UnitTestServiceClient::GetMetadata();
+
+    const ugrpc::client::RetryConfig retry_config;
+
+    const auto service_name = metadata.service_full_name;
+
+    const auto timeout0 = google::protobuf::util::TimeUtil::MillisecondsToDuration(100);
+    const auto timeout2 = google::protobuf::util::TimeUtil::MillisecondsToDuration(500);
+    const auto default_timeout = google::protobuf::util::TimeUtil::MillisecondsToDuration(1500);
+
+    std::uint32_t max_attempts = 5;
+    const auto retry_policy_json = BuildSimpleRetryPolicyConfig(max_attempts);
+
+    const auto method0_config_json =
+        BuildMethodConfig({{service_name, GetMethodName(metadata, 0)}}, timeout0, retry_policy_json);
+    const auto method2_config_json =
+        BuildMethodConfig({{service_name, GetMethodName(metadata, 2)}}, timeout2, retry_policy_json);
+    const auto method3_config_json =
+        BuildMethodConfig({{service_name, GetMethodName(metadata, 3)}}, std::nullopt, retry_policy_json);
+    const auto default_method_config_json = BuildDefaultMethodConfig(default_timeout, retry_policy_json);
+
+    const auto static_service_config = formats::json::MakeObject(
+        "methodConfig",
+        formats::json::MakeArray(
+            method0_config_json, method2_config_json, method3_config_json, default_method_config_json
+        )
+    );
+    LOG_DEBUG() << "static_service_config: " << static_service_config;
+
+    const ugrpc::client::impl::compat::ServiceConfigBuilder service_config_builder{
+        metadata, retry_config, formats::json::ToString(static_service_config)};
+
+    const ugrpc::client::Qos qos0{/*attempts=*/2, /*timeout=*/std::nullopt};
+    const ugrpc::client::Qos qos1{/*attempts=*/3, /*timeout=*/std::nullopt};
+    const ugrpc::client::Qos qos3{/*attempts=*/std::nullopt, /*timeout=*/std::nullopt};
+    const ugrpc::client::Qos qos_default{/*attempts=*/4, /*timeout=*/std::nullopt};
+    ugrpc::client::ClientQos client_qos;
+    client_qos.methods.Set(GetMethodFullName(metadata, 0), qos0);
+    client_qos.methods.Set(GetMethodFullName(metadata, 1), qos1);
+    client_qos.methods.Set(GetMethodFullName(metadata, 3), qos3);
+    client_qos.methods.SetDefault(qos_default);
+
+    const auto service_config = service_config_builder.Build(client_qos);
+    LOG_DEBUG() << "service_config: " << service_config;
+
+    ASSERT_TRUE(service_config.HasMember("methodConfig"));
+    const auto& method_config = service_config["methodConfig"];
+    ASSERT_TRUE(method_config.IsArray());
+    ASSERT_EQ(5, method_config.GetSize());
+
+    VerifyMethodConfig(
+        method_config[0],
+        {{service_name, GetMethodName(metadata, 0)}},
+        /*timeout=*/timeout0,
+        /*attempts=*/max_attempts
+    );
+
+    VerifyMethodConfig(
+        method_config[1],
+        {{service_name, GetMethodName(metadata, 1)}},
+        /*timeout=*/default_timeout,
+        /*attempts=*/qos1.attempts
+    );
+
+    VerifyMethodConfig(
+        method_config[2],
+        {{service_name, GetMethodName(metadata, 2)}},
+        /*timeout=*/timeout2,
+        /*attempts=*/qos_default.attempts
+    );
+
+    VerifyMethodConfig(
+        method_config[3],
+        {{service_name, GetMethodName(metadata, 3)}},
+        /*timeout=*/std::nullopt,
+        /*attempts=*/qos_default.attempts
+    );
+
+    VerifyMethodConfig(
+        method_config[4],
+        {{/*service_name=*/std::nullopt, /*method_name=*/std::nullopt}},
+        /*timeout=*/default_timeout,
+        /*attempts=*/max_attempts
+    );
+}
+
+USERVER_NAMESPACE_END
diff --git a/grpc/tests/deadline_metrics_test.cpp b/grpc/tests/deadline_metrics_test.cpp
index 45d4ed5e17ec..ca4e1a8c5450 100644
--- a/grpc/tests/deadline_metrics_test.cpp
+++ b/grpc/tests/deadline_metrics_test.cpp
@@ -149,6 +149,9 @@ UTEST_F(DeadlineStatsTests, ClientDeadlineUpdated) {
     expected_value += 3;
     EXPECT_EQ(GetClientStatistic(kDeadlinePropagated), expected_value);
 
+    // reset TaskInheritedDeadline, set once is too short for many requests
+    tests::InitTaskInheritedDeadline();
+
     // Requests without deadline
     // TaskInheritedData will be set as deadline
     EXPECT_TRUE(PerformRequest(false));
diff --git a/grpc/tests/logging_test.cpp b/grpc/tests/logging_test.cpp
index 6fa0a5c4d79e..f6940b0e93a8 100644
--- a/grpc/tests/logging_test.cpp
+++ b/grpc/tests/logging_test.cpp
@@ -2,11 +2,11 @@
 
 #include <gmock/gmock.h>
 
+#include <ugrpc/server/middlewares/access_log/middleware.hpp>
+#include <userver/ugrpc/server/middlewares/access_log/log_extra.hpp>
 #include <userver/utest/log_capture_fixture.hpp>
 #include <userver/utils/regex.hpp>
 
-#include <ugrpc/server/middlewares/access_log/middleware.hpp>
-
 #include <tests/unit_test_client.usrv.pb.hpp>
 #include <tests/unit_test_service.usrv.pb.hpp>
 #include <userver/ugrpc/tests/service_fixtures.hpp>
@@ -15,6 +15,28 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
+constexpr std::string_view kBaseTskvPattern = R"(tskv\t)"
+                                              R"(timestamp=\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\t)"
+                                              R"(timezone=[-+]\d{2}\d{2}\t)"
+                                              R"(user_agent=.+\t)"
+                                              R"(ip=[.0-9a-f:\[\]]+\:[0-9]+\t)"
+                                              R"(x_real_ip=[.0-9a-f:\[\]]+\:[0-9]+\t)"
+                                              R"(request=[a-zA-Z./0-9]+\t)"
+                                              R"(request_time=\d+\.\d+\t)"
+                                              R"(upstream_response_time=\d+\.\d+\t)"
+                                              R"(grpc_status=\d+\t)"
+                                              R"(grpc_status_code=[A-Z_]+)";
+
+const utils::regex kBaseTskvRegex{std::string{kBaseTskvPattern} + R"(\n)"};
+
+// Constant to check result of LogExtra middleware
+const utils::regex kTskvWithTagsRegex{
+    std::string{kBaseTskvPattern} + R"(\tuser_id=12345)"
+                                    R"(\tsession_id=abc-def-ghi)"
+                                    R"(\trequest_id=req-98765)"
+                                    R"(\tcustom_tag=test-value)"
+                                    R"(\tnumeric_tag=42\n)"};
+
 class UnitTestService final : public sample::ugrpc::UnitTestServiceBase {
 public:
     SayHelloResult SayHello(CallContext& /*context*/, sample::ugrpc::GreetingRequest&& request) override {
@@ -48,9 +70,54 @@ class ServiceWithAccessLogFixture : public ugrpc::tests::ServiceFixtureBase {
     GrpcService service_{};
 };
 
+// Test middleware that adds custom tags to LogExtra
+class TagsMiddleware final : public ugrpc::server::MiddlewareBase {
+public:
+    /// [grpc log extra tag]
+    void OnCallStart(ugrpc::server::MiddlewareCallContext& context) const override {
+        ugrpc::server::middlewares::access_log::SetAdditionalLogKeys(
+            context,
+            logging::LogExtra{
+                std::pair<std::string, std::string>("user_id", "12345"),
+                std::pair<std::string, std::string>("session_id", "abc-def-ghi"),
+                std::pair<std::string, std::string>("request_id", "req-98765"),
+                std::pair<std::string, std::string>("custom_tag", "test-value"),
+                std::pair<std::string, std::string>("numeric_tag", "42"),
+            }
+        );
+    }
+    /// [grpc log extra tag]
+};
+
+template <typename GrpcService>
+class ServiceWithAccessLogTagsFixture : public ugrpc::tests::ServiceFixtureBase {
+public:
+    ServiceWithAccessLogTagsFixture() {
+        ugrpc::server::middlewares::access_log::Settings access_log_settings;
+        access_log_settings.access_tskv_logger = access_logger_.GetLogger();
+
+        SetServerMiddlewares({
+            std::make_shared<ugrpc::server::middlewares::access_log::Middleware>(std::move(access_log_settings)),
+            std::make_shared<TagsMiddleware>(),
+        });
+
+        RegisterService(service_);
+        StartServer();
+    }
+
+    ~ServiceWithAccessLogTagsFixture() override { StopServer(); }
+
+    utest::LogCaptureLogger& AccessLog() { return access_logger_; }
+
+private:
+    utest::LogCaptureLogger access_logger_{logging::Format::kRaw};
+    GrpcService service_{};
+};
+
 }  // namespace
 
 using GrpcAccessLog = ServiceWithAccessLogFixture<UnitTestService>;
+using GrpcAccessLogWithTags = ServiceWithAccessLogTagsFixture<UnitTestService>;
 
 UTEST_F(GrpcAccessLog, Test) {
     auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
@@ -60,20 +127,20 @@ UTEST_F(GrpcAccessLog, Test) {
 
     GetServer().StopServing();
 
-    constexpr std::string_view kExpectedPattern = R"(tskv\t)"
-                                                  R"(timestamp=\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\t)"
-                                                  R"(timezone=[-+]\d{2}\d{2}\t)"
-                                                  R"(user_agent=.+\t)"
-                                                  R"(ip=[.0-9a-f:\[\]]+\:[0-9]+\t)"
-                                                  R"(x_real_ip=[.0-9a-f:\[\]]+\:[0-9]+\t)"
-                                                  R"(request=[a-zA-Z./0-9]+\t)"
-                                                  R"(request_time=\d+\.\d+\t)"
-                                                  R"(upstream_response_time=\d+\.\d+\t)"
-                                                  R"(grpc_status=\d+\t)"
-                                                  R"(grpc_status_code=[A-Z_]+\n)";
+    const auto logs = GetSingleLog(AccessLog().GetAll());
+    EXPECT_TRUE(utils::regex_match(logs.GetLogRaw(), kBaseTskvRegex)) << logs;
+}
+
+UTEST_F(GrpcAccessLogWithTags, TestWithCustomTags) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+    sample::ugrpc::GreetingRequest out;
+    out.set_name("userver");
+    auto response = client.SayHello(out);
+
+    GetServer().StopServing();
 
     const auto logs = GetSingleLog(AccessLog().GetAll());
-    EXPECT_TRUE(utils::regex_match(logs.GetLogRaw(), utils::regex(kExpectedPattern))) << logs;
+    EXPECT_TRUE(utils::regex_match(logs.GetLogRaw(), kTskvWithTagsRegex)) << logs;
 }
 
 USERVER_NAMESPACE_END
diff --git a/grpc/tests/metadata_test.cpp b/grpc/tests/metadata_test.cpp
new file mode 100644
index 000000000000..c949fb11ef58
--- /dev/null
+++ b/grpc/tests/metadata_test.cpp
@@ -0,0 +1,161 @@
+#include <userver/utest/utest.hpp>
+
+#include <string>
+#include <utility>
+
+#include <gmock/gmock.h>
+
+#include <userver/utils/algo.hpp>
+
+#include <tests/unit_test_client.usrv.pb.hpp>
+#include <tests/unit_test_service.usrv.pb.hpp>
+#include <userver/ugrpc/tests/service_fixtures.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace {
+
+class SimpleMetadataService final : public sample::ugrpc::UnitTestServiceBase {
+public:
+    SayHelloResult SayHello(CallContext& context, sample::ugrpc::GreetingRequest&& request) override {
+        /// [server_read_client_metadata]
+        const std::multimap<grpc::string_ref, grpc::string_ref>& client_metadata =
+            context.GetServerContext().client_metadata();
+        const std::optional<grpc::string_ref> custom_header = utils::FindOptional(client_metadata, "custom-header");
+        /// [server_read_client_metadata]
+
+        /// [server_write_initial_metadata]
+        context.GetServerContext().AddInitialMetadata("response-header", "response-value");
+        /// [server_write_initial_metadata]
+
+        /// [server_write_trailing_metadata]
+        context.GetServerContext().AddTrailingMetadata("request-id", "req-123");
+        /// [server_write_trailing_metadata]
+
+        const std::optional<grpc::string_ref> user_id = utils::FindOptional(client_metadata, "user-id");
+        context.GetServerContext().AddInitialMetadata("server-version", "1.0.0");
+        context.GetServerContext().AddTrailingMetadata("processing-time", "42ms");
+
+        std::string greeting = "Hello " + request.name();
+        if (custom_header) {
+            greeting += " (header: " + std::string(custom_header->data(), custom_header->size()) + ")";
+        }
+        if (user_id) {
+            greeting += " (user: " + std::string(user_id->data(), user_id->size()) + ")";
+        }
+
+        sample::ugrpc::GreetingResponse response;
+        response.set_name(greeting);
+        return response;
+    }
+
+    ReadManyResult
+    ReadMany(CallContext& context, sample::ugrpc::StreamGreetingRequest&& request, ReadManyWriter& writer) override {
+        context.GetServerContext().AddInitialMetadata("stream-started", "true");
+        context.GetServerContext().AddInitialMetadata("total-items", std::to_string(request.number()));
+
+        sample::ugrpc::StreamGreetingResponse response;
+        response.set_name("Stream response for " + request.name());
+
+        for (int i = 0; i < request.number(); ++i) {
+            response.set_number(i);
+            writer.Write(response);
+        }
+
+        context.GetServerContext().AddTrailingMetadata("stream-completed", "true");
+
+        return grpc::Status::OK;
+    }
+};
+
+}  // namespace
+
+using MetadataTest = ugrpc::tests::ServiceFixture<SimpleMetadataService>;
+
+UTEST_F(MetadataTest, ClientSendMetadata) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+
+    sample::ugrpc::GreetingRequest request;
+    request.set_name("test");
+
+    /// [client_write_metadata]
+    ugrpc::client::CallOptions call_options;
+    call_options.AddMetadata("custom-header", "custom-value");
+    /// [client_write_metadata]
+    call_options.AddMetadata("user-id", "12345");
+
+    auto response = client.SayHello(request, std::move(call_options));
+    EXPECT_EQ(response.name(), "Hello test (header: custom-value) (user: 12345)");
+}
+
+UTEST_F(MetadataTest, ClientReadInitialMetadata) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+
+    sample::ugrpc::GreetingRequest request;
+    request.set_name("test");
+
+    auto future = client.AsyncSayHello(request, {});
+    auto response = future.Get();
+
+    /// [client_read_initial_metadata]
+    const std::multimap<grpc::string_ref, grpc::string_ref>& initial_metadata =
+        future.GetContext().GetClientContext().GetServerInitialMetadata();
+    /// [client_read_initial_metadata]
+
+    EXPECT_THAT(initial_metadata, testing::Contains(testing::Pair("response-header", "response-value")));
+    EXPECT_THAT(initial_metadata, testing::Contains(testing::Pair("server-version", "1.0.0")));
+}
+
+UTEST_F(MetadataTest, ClientReadTrailingMetadata) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+
+    sample::ugrpc::GreetingRequest request;
+    request.set_name("test");
+
+    auto future = client.AsyncSayHello(request, {});
+    auto response = future.Get();
+
+    /// [client_read_trailing_metadata]
+    const std::multimap<grpc::string_ref, grpc::string_ref>& trailing_metadata =
+        future.GetContext().GetClientContext().GetServerTrailingMetadata();
+    /// [client_read_trailing_metadata]
+
+    EXPECT_THAT(trailing_metadata, testing::Contains(testing::Pair("request-id", "req-123")));
+    EXPECT_THAT(trailing_metadata, testing::Contains(testing::Pair("processing-time", "42ms")));
+}
+
+UTEST_F(MetadataTest, StreamingRequestResponseMetadata) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+
+    sample::ugrpc::StreamGreetingRequest request;
+    request.set_name("stream-test");
+    request.set_number(3);
+
+    ugrpc::client::CallOptions call_options;
+    call_options.AddMetadata("stream-id", "stream-123");
+    call_options.AddMetadata("custom-request-header", "request-value");
+
+    auto stream = client.ReadMany(request, std::move(call_options));
+
+    sample::ugrpc::StreamGreetingResponse response;
+    int count = 0;
+    while (stream.Read(response)) {
+        EXPECT_EQ(response.name(), "Stream response for stream-test");
+        EXPECT_EQ(response.number(), count);
+        ++count;
+    }
+    EXPECT_EQ(count, 3);
+
+    const grpc::ClientContext& client_context = stream.GetContext().GetClientContext();
+
+    const std::multimap<grpc::string_ref, grpc::string_ref>& initial_metadata =
+        client_context.GetServerInitialMetadata();
+    EXPECT_THAT(initial_metadata, testing::Contains(testing::Pair("stream-started", "true")));
+    EXPECT_THAT(initial_metadata, testing::Contains(testing::Pair("total-items", "3")));
+
+    const std::multimap<grpc::string_ref, grpc::string_ref>& trailing_metadata =
+        client_context.GetServerTrailingMetadata();
+    EXPECT_THAT(trailing_metadata, testing::Contains(testing::Pair("stream-completed", "true")));
+}
+
+USERVER_NAMESPACE_END
diff --git a/grpc/tests/protobuf_logging_test.cpp b/grpc/tests/protobuf_logging_test.cpp
new file mode 100644
index 000000000000..5711b819040e
--- /dev/null
+++ b/grpc/tests/protobuf_logging_test.cpp
@@ -0,0 +1,169 @@
+#include <userver/ugrpc/protobuf_logging.hpp>
+
+#include <gmock/gmock.h>
+#include <google/protobuf/empty.pb.h>
+#include <google/protobuf/wrappers.pb.h>
+#include <google/rpc/status.pb.h>
+#include <grpcpp/support/status.h>
+
+#include <userver/logging/log.hpp>
+#include <userver/utest/log_capture_fixture.hpp>
+#include <userver/utest/utest.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+UTEST(ProtobufLogging, GetMessageWithData) {
+    google::protobuf::StringValue test_message;
+    test_message.set_value("test string with some content");
+
+    const auto result = ugrpc::ToLimitedDebugString(test_message, 1000);
+
+    EXPECT_THAT(result, testing::HasSubstr("test string with some content"));
+    EXPECT_THAT(result, testing::HasSubstr("value:"));
+}
+
+UTEST(ProtobufLogging, GetMessageEmptyMessage) {
+    google::protobuf::Empty empty_message;
+    const auto result = ugrpc::ToLimitedDebugString(empty_message, 100);
+
+    EXPECT_EQ(result, "<EMPTY>");
+}
+
+UTEST(ProtobufLogging, GetMessageSizeLimit) {
+    google::protobuf::StringValue test_message;
+    test_message.set_value("test string with some content");
+
+    const auto small_result = ugrpc::ToLimitedDebugString(test_message, 10);
+    const auto large_result = ugrpc::ToLimitedDebugString(test_message, 1000);
+
+    EXPECT_LE(small_result.size(), 10u);
+    EXPECT_GT(large_result.size(), small_result.size());
+    EXPECT_THAT(large_result, testing::HasSubstr("test string with some content"));
+}
+
+UTEST(ProtobufLogging, OkStatus) {
+    grpc::Status ok_status = grpc::Status::OK;
+    const auto result = ugrpc::ToUnlimitedDebugString(ok_status);
+
+    EXPECT_EQ(result, "OK");
+}
+
+UTEST(ProtobufLogging, SimpleError) {
+    grpc::Status simple_error(grpc::StatusCode::NOT_FOUND, "Resource not found");
+    const auto result = ugrpc::ToUnlimitedDebugString(simple_error);
+
+    EXPECT_THAT(result, testing::HasSubstr("NOT_FOUND"));
+    EXPECT_THAT(result, testing::HasSubstr("Resource not found"));
+    EXPECT_THAT(result, testing::HasSubstr("code:"));
+    EXPECT_THAT(result, testing::HasSubstr("error message:"));
+}
+
+UTEST(ProtobufLogging, ComplexError) {
+    google::rpc::Status error_details;
+    error_details.set_code(static_cast<int>(grpc::StatusCode::INVALID_ARGUMENT));
+    error_details.set_message("Invalid parameter provided");
+
+    auto* detail = error_details.add_details();
+    detail->set_type_url("type.googleapis.com/google.protobuf.StringValue");
+    google::protobuf::StringValue detail_value;
+    detail_value.set_value("Additional error context");
+    detail->set_value(detail_value.SerializeAsString());
+
+    grpc::Status complex_status(
+        grpc::StatusCode::INVALID_ARGUMENT, "Invalid parameter provided", error_details.SerializeAsString()
+    );
+
+    const auto result = ugrpc::ToUnlimitedDebugString(complex_status);
+
+    EXPECT_THAT(result, testing::HasSubstr("INVALID_ARGUMENT"));
+    EXPECT_THAT(result, testing::HasSubstr("Invalid parameter provided"));
+    EXPECT_THAT(result, testing::HasSubstr("error details:"));
+    EXPECT_THAT(result, testing::HasSubstr("Additional error context"));
+    EXPECT_THAT(result, testing::HasSubstr("type.googleapis.com"));
+}
+
+UTEST(ProtobufLogging, EdgeCasesZeroMaxSize) {
+    google::protobuf::StringValue test_message;
+    test_message.set_value("test string with some content");
+
+    const auto result = ugrpc::ToLimitedDebugString(test_message, 0);
+    EXPECT_TRUE(result.empty());
+}
+
+UTEST(ProtobufLogging, GetErrorDetailsSizeLimiting) {
+    std::string large_message(2000, 'A');
+    google::rpc::Status error_details;
+    error_details.set_code(static_cast<int>(grpc::StatusCode::NOT_FOUND));
+    error_details.set_message("Some error");
+    auto* detail = error_details.add_details();
+    google::protobuf::StringValue detail_value;
+    detail_value.set_value(large_message);
+    detail->set_value(detail_value.SerializeAsString());
+    grpc::Status large_error(
+        grpc::StatusCode::NOT_FOUND, "Invalid parameter provided", error_details.SerializeAsString()
+    );
+    const auto small_result = ugrpc::ToLimitedDebugString(large_error, 100);
+    EXPECT_LE(small_result.size(), 200u);
+
+    const auto medium_result = ugrpc::ToLimitedDebugString(large_error, 500);
+    EXPECT_LE(medium_result.size(), 600u);
+    EXPECT_GT(medium_result.size(), small_result.size());
+
+    const auto large_result = ugrpc::ToLimitedDebugString(large_error, 3000);
+    EXPECT_GT(large_result.size(), medium_result.size());
+}
+
+UTEST(ProtobufLogging, GetErrorDetailsUnlimited) {
+    std::string large_message(5000, 'B');
+    google::rpc::Status error_details;
+    auto* detail = error_details.add_details();
+    google::protobuf::StringValue detail_value;
+    detail_value.set_value(large_message);
+    detail->set_value(detail_value.SerializeAsString());
+    grpc::Status large_error(
+        grpc::StatusCode::NOT_FOUND, "Invalid parameter provided", error_details.SerializeAsString()
+    );
+    const auto unlimited_result = ugrpc::ToUnlimitedDebugString(large_error);
+
+    EXPECT_THAT(unlimited_result, testing::HasSubstr(large_message));
+    EXPECT_THAT(unlimited_result, testing::HasSubstr("Invalid parameter provided"));
+    EXPECT_GT(unlimited_result.size(), 5000);
+}
+
+UTEST(ProtobufLogging, EdgeCasesEmptyDetails) {
+    grpc::Status status_with_empty_details(grpc::StatusCode::INTERNAL, "Internal error", "");
+
+    const auto result = ugrpc::ToLimitedDebugString(status_with_empty_details);
+    EXPECT_THAT(result, testing::HasSubstr("INTERNAL"));
+    EXPECT_THAT(result, testing::HasSubstr("Internal error"));
+    EXPECT_THAT(result, testing::Not(testing::HasSubstr("error details:")));
+}
+
+UTEST(ProtobufLogging, LogHelperOperator) {
+    google::protobuf::StringValue message;
+    message.set_value("stdout test message");
+    LOG_INFO("Stdout test: {}", message);
+}
+
+UTEST(ProtobufLogging, LogHelperOperatorEmptyMessage) {
+    google::protobuf::Empty empty_message;
+    LOG_INFO("Empty protobuf: {}", empty_message);
+}
+
+UTEST(ProtobufLogging, FmtFormatterWithData) {
+    std::string message = "test string with some content";
+    google::protobuf::StringValue test_message;
+    test_message.set_value(message);
+
+    const auto result = fmt::format("Message: {}", test_message);
+    EXPECT_THAT(result, testing::HasSubstr(message));
+}
+
+UTEST(ProtobufLogging, FmtFormatterEmptyMessage) {
+    google::protobuf::Empty empty_message;
+    const auto result = fmt::format("Empty: {}", empty_message);
+
+    EXPECT_EQ(result, "Empty: <EMPTY>");
+}
+
+USERVER_NAMESPACE_END
diff --git a/grpc/tests/protobuf_utils_test.cpp b/grpc/tests/protobuf_utils_test.cpp
index 4547667a6bad..06c8ba0bf8a4 100644
--- a/grpc/tests/protobuf_utils_test.cpp
+++ b/grpc/tests/protobuf_utils_test.cpp
@@ -1,8 +1,7 @@
 #include <userver/utest/utest.hpp>
 
 #include <userver/ugrpc/impl/to_string.hpp>
-
-#include <ugrpc/impl/protobuf_utils.hpp>
+#include <userver/ugrpc/protobuf_logging.hpp>
 
 #include <tests/logging.pb.h>
 #include <tests/messages.pb.h>
@@ -45,11 +44,11 @@ UTEST(ToLimitedDebugString, Basic) {
     message.set_id("swag");
     *message.add_names() = "test-name-1";
     *message.add_names() = "test-name-2";
-    auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     const auto expected = message.DebugString();
     EXPECT_EQ(out, expected);
 
-    out = ugrpc::impl::ToLimitedDebugString(message, 8);
+    out = ugrpc::ToLimitedDebugString(message, 8);
     EXPECT_EQ(out, expected.substr(0, 8));
 }
 
@@ -57,7 +56,7 @@ UTEST(ToLimitedDebugString, Fit) {
     constexpr std::size_t kLimit = 20;
     sample::ugrpc::GreetingResponse message;
     message.set_name("1234567890");
-    const auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    const auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     EXPECT_EQ(out, "name: \"1234567890\"\n");
 }
 
@@ -65,7 +64,7 @@ UTEST(ToLimitedDebugString, Limited) {
     constexpr std::size_t kLimit = 10;
     sample::ugrpc::GreetingResponse message;
     message.set_name("1234567890");
-    const auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    const auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     EXPECT_EQ(out, "name: \"123");
 }
 
@@ -73,7 +72,7 @@ UTEST(ToLimitedDebugString, Complex) {
     constexpr std::size_t kLimit = 512;
     const auto message = ConstructComplexMessage();
     const auto expected = ugrpc::impl::ToString(message.Utf8DebugString().substr(0, kLimit));
-    ASSERT_EQ(expected, ugrpc::impl::ToLimitedDebugString(message, kLimit));
+    ASSERT_EQ(expected, ugrpc::ToLimitedDebugString(message, kLimit));
 }
 
 USERVER_NAMESPACE_END
diff --git a/grpc/tests/retry_test.cpp b/grpc/tests/retry_test.cpp
index 559b1ce49695..888b668511e5 100644
--- a/grpc/tests/retry_test.cpp
+++ b/grpc/tests/retry_test.cpp
@@ -32,7 +32,7 @@ using RetryTest = ugrpc::tests::ServiceFixture<UnitTestService>;
 
 }  // namespace
 
-UTEST_F(RetryTest, Attempts) {
+UTEST_F(RetryTest, QosAttempts) {
     ugrpc::client::Qos qos;
     qos.attempts = 4;
     ugrpc::client::ClientQos client_qos;
@@ -53,4 +53,18 @@ UTEST_F(RetryTest, Attempts) {
     UEXPECT_NO_THROW(response = client.SayHello(request));
 }
 
+UTEST_F(RetryTest, CallOptionsAttempts) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+
+    sample::ugrpc::GreetingRequest request;
+    request.set_name("testname");
+    /// [SetAttempts]
+    ugrpc::client::CallOptions call_options;
+    call_options.SetAttempts(4);
+
+    sample::ugrpc::GreetingResponse response;
+    UEXPECT_NO_THROW(response = client.SayHello(request, std::move(call_options)));
+    /// [SetAttempts]
+}
+
 USERVER_NAMESPACE_END
diff --git a/grpc/tests/secret_fields_test.cpp b/grpc/tests/secret_fields_test.cpp
index f9c0a65f63e2..1e1f0670e2ee 100644
--- a/grpc/tests/secret_fields_test.cpp
+++ b/grpc/tests/secret_fields_test.cpp
@@ -1,15 +1,15 @@
-#include <userver/utest/utest.hpp>
-
 #include <google/protobuf/stubs/common.h>
 #if defined(ARCADIA_ROOT) || GOOGLE_PROTOBUF_VERSION >= 4022000
 
-#include <ugrpc/client/middlewares/log/middleware.hpp>
-#include <ugrpc/impl/protobuf_utils.hpp>
-#include <ugrpc/server/middlewares/log/middleware.hpp>
+#include <userver/ugrpc/protobuf_logging.hpp>
 #include <userver/ugrpc/tests/service_fixtures.hpp>
 #include <userver/utest/log_capture_fixture.hpp>
+#include <userver/utest/utest.hpp>
 #include <userver/utils/flags.hpp>
 
+#include <ugrpc/client/middlewares/log/middleware.hpp>
+#include <ugrpc/server/middlewares/log/middleware.hpp>
+
 #include <tests/secret_fields.pb.h>
 #include <tests/secret_fields_client.usrv.pb.hpp>
 #include <tests/secret_fields_service.usrv.pb.hpp>
@@ -138,11 +138,11 @@ UTEST(ToLimitedDebugStringWithSecrets, Basic) {
     message.set_password("qwerty12345678");
     message.set_name("test-name");
     message.set_count(7);
-    auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     const std::string_view expected = "id: \"swag\"\nname: \"test-name\"\npassword: [REDACTED]\ncount: [REDACTED]\n";
     EXPECT_EQ(out, expected);
 
-    out = ugrpc::impl::ToLimitedDebugString(message, 44);
+    out = ugrpc::ToLimitedDebugString(message, 44);
     EXPECT_EQ(out, expected.substr(0, 44));
 }
 
@@ -157,7 +157,7 @@ UTEST(ToLimitedDebugStringWithSecrets, InnerSecrets) {
     item->set_value("value");
     const std::string_view expected = "id: \"swag\"\nitems {\n  index: 7\n  value: [REDACTED]\n}\n";
 
-    const auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    const auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     EXPECT_EQ(out, expected);
 }
 
@@ -172,7 +172,7 @@ UTEST(ToLimitedDebugStringWithSecrets, SecretsAndFit) {
     item->set_value("value");
     const std::string_view expected = "id: \"swag\"\n";
 
-    const auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    const auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     EXPECT_EQ(out, expected);
 }
 
@@ -187,7 +187,7 @@ UTEST(ToLimitedDebugStringWithSecrets, TheSameName) {
 
     const auto expected = message.DebugString();
 
-    const auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    const auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     EXPECT_EQ(out, expected);
 }
 
@@ -203,7 +203,7 @@ UTEST(ToLimitedDebugStringWithSecrets, StructSecret) {
 
     const auto expected = "name1: \"name1\"\ncurrent_state: [REDACTED]\nname2: \"name2\"\n";
 
-    const auto out = ugrpc::impl::ToLimitedDebugString(message, kLimit);
+    const auto out = ugrpc::ToLimitedDebugString(message, kLimit);
     EXPECT_EQ(out, expected);
 }
 
diff --git a/grpc/tests/service_config_test.cpp b/grpc/tests/service_config_test.cpp
index 671a934badce..35d2a2ab434b 100644
--- a/grpc/tests/service_config_test.cpp
+++ b/grpc/tests/service_config_test.cpp
@@ -5,6 +5,7 @@
 
 #include <userver/ugrpc/client/channels.hpp>
 #include <userver/ugrpc/client/impl/client_data.hpp>
+#include <userver/ugrpc/client/impl/client_data_accessor.hpp>
 #include <userver/ugrpc/impl/to_string.hpp>
 #include <userver/ugrpc/tests/service_fixtures.hpp>
 
@@ -55,7 +56,7 @@ class GrpcClientWithServiceConfig : public ugrpc::tests::ServiceFixtureBase {
 UTEST_F(GrpcClientWithServiceConfig, DefaultServiceConfig) {
     auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
 
-    auto& data = ugrpc::client::impl::GetClientData(client);
+    const auto& data = ugrpc::client::impl::ClientDataAccessor::GetClientData(client);
 
     // This is a very important moment. THe default service_config is applied not
     // upon creation, but when the name resolution process returns no service
diff --git a/grpc/tests/timeout_test.cpp b/grpc/tests/timeout_test.cpp
index 16d592684da5..ee4b9e1ecfe1 100644
--- a/grpc/tests/timeout_test.cpp
+++ b/grpc/tests/timeout_test.cpp
@@ -1,7 +1,5 @@
 #include <userver/utest/utest.hpp>
 
-#include <grpc/grpc.h>  // for GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-
 #include <userver/engine/sleep.hpp>
 
 #include <userver/ugrpc/tests/service_fixtures.hpp>
@@ -15,14 +13,6 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
-#ifdef GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define DISABLED_IN_OLD_GRPC_TEST_NAME(name) name
-#else
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define DISABLED_IN_OLD_GRPC_TEST_NAME(name) DISABLED_##name
-#endif
-
 class UnitTestService final : public sample::ugrpc::UnitTestServiceBase {
 public:
     SayHelloResult SayHello(CallContext& context, sample::ugrpc::GreetingRequest&& request) override {
@@ -49,7 +39,7 @@ using TimeoutTest = ugrpc::tests::ServiceFixture<UnitTestService>;
 
 }  // namespace
 
-UTEST_F(TimeoutTest, DISABLED_IN_OLD_GRPC_TEST_NAME(PerAttemptTimeout)) {
+UTEST_F(TimeoutTest, QosTimeout) {
     ugrpc::client::Qos qos;
     qos.attempts = 4;
     qos.timeout = tests::kLongTimeout;
@@ -71,4 +61,18 @@ UTEST_F(TimeoutTest, DISABLED_IN_OLD_GRPC_TEST_NAME(PerAttemptTimeout)) {
     UEXPECT_NO_THROW(response = client.SayHello(request));
 }
 
+UTEST_F(TimeoutTest, CallOptionsTimeout) {
+    auto client = MakeClient<sample::ugrpc::UnitTestServiceClient>();
+
+    sample::ugrpc::GreetingRequest request;
+    request.set_name("testname");
+
+    ugrpc::client::CallOptions call_options;
+    call_options.SetAttempts(4);
+    call_options.SetTimeout(tests::kLongTimeout);
+
+    sample::ugrpc::GreetingResponse response;
+    UEXPECT_NO_THROW(response = client.SayHello(request, std::move(call_options)));
+}
+
 USERVER_NAMESPACE_END
diff --git a/kafka/CMakeLists.txt b/kafka/CMakeLists.txt
index dd7c202d58f5..4e2ffbe422d1 100644
--- a/kafka/CMakeLists.txt
+++ b/kafka/CMakeLists.txt
@@ -12,6 +12,7 @@ userver_module(
     LINK_LIBRARIES_PRIVATE RdKafka::rdkafka
     DBTEST_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests"
     DBTEST_LINK_LIBRARIES userver::kafka-utest
+    DEPENDS core
 )
 
 target_compile_options(${PROJECT_NAME} PRIVATE "-Wno-ignored-qualifiers")
diff --git a/kafka/include/userver/kafka/exceptions.hpp b/kafka/include/userver/kafka/exceptions.hpp
index 265e1a79f3b6..634ca7b5fa8f 100644
--- a/kafka/include/userver/kafka/exceptions.hpp
+++ b/kafka/include/userver/kafka/exceptions.hpp
@@ -117,18 +117,18 @@ class ParseHeadersException final : std::runtime_error {
 };
 
 /// @brief Exception thrown when Seek* process failed.
-/// @ref ConsumeScope::Seek
-/// @ref ConsumeScope::SeekToBeginning
-/// @ref ConsumeScope::SeekToEnd
+/// @ref ConsumerScope::Seek
+/// @ref ConsumerScope::SeekToBeginning
+/// @ref ConsumerScope::SeekToEnd
 class SeekException final : public std::runtime_error {
 public:
     using std::runtime_error::runtime_error;
 };
 
 /// @brief Exception thrown when Seek* arguments are invalid.
-/// @ref ConsumeScope::Seek
-/// @ref ConsumeScope::SeekToBeginning
-/// @ref ConsumeScope::SeekToEnd
+/// @ref ConsumerScope::Seek
+/// @ref ConsumerScope::SeekToBeginning
+/// @ref ConsumerScope::SeekToEnd
 class SeekInvalidArgumentException final : public std::invalid_argument {
 public:
     using std::invalid_argument::invalid_argument;
diff --git a/kafka/include/userver/kafka/impl/broker_secrets.hpp b/kafka/include/userver/kafka/impl/broker_secrets.hpp
index 5991cce553f9..1e4fe5187586 100644
--- a/kafka/include/userver/kafka/impl/broker_secrets.hpp
+++ b/kafka/include/userver/kafka/impl/broker_secrets.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <map>
+#include <optional>
+#include <variant>
 
 #include <userver/formats/json/value.hpp>
 #include <userver/utils/strong_typedef.hpp>
@@ -12,9 +14,32 @@ namespace kafka::impl {
 struct Secret final {
     using SecretType = utils::NonLoggable<class SecretTag, std::string>;
 
+    struct SaslCredentials final {
+        /// @brief SASL username for use with the PLAIN and SASL-SCRAM-.. mechanisms.
+        SecretType username;
+        /// @brief SASL password for use with the PLAIN and SASL-SCRAM-.. mechanisms.
+        SecretType password;
+    };
+
+    struct SslCredentials final {
+        /// @brief Path to client's public key (PEM) used for authentication.
+        SecretType ssl_certificate_location;
+        /// @brief Path to client's private key (PEM) used for authentication.
+        SecretType ssl_key_location;
+        /// @brief (Optional) Private key passphrase.
+        std::optional<SecretType> ssl_key_password{};
+    };
+
+    /// @brief Brokers URI comma-separated list.
+    /// @note Is is allowed to pass only one broker URI.
+    /// Client discovers over brokers automatically.
     std::string brokers;
-    SecretType username;
-    SecretType password;
+
+    /// @brief Security protocol corresponding credentials.
+    /// PLAINTEXT -> none
+    /// SASL_PLAINTEXT/SASL_SSL -> SaslCredentials
+    /// SSL -> SslCredentials
+    std::variant<std::monostate, SaslCredentials, SslCredentials> credentials{};
 };
 
 class BrokerSecrets final {
diff --git a/kafka/include/userver/kafka/impl/configuration.hpp b/kafka/include/userver/kafka/impl/configuration.hpp
index 60ab628a2f2f..2ca75b8ff4c0 100644
--- a/kafka/include/userver/kafka/impl/configuration.hpp
+++ b/kafka/include/userver/kafka/impl/configuration.hpp
@@ -33,8 +33,11 @@ struct SecurityConfiguration final {
         std::string security_mechanism;
         std::string ssl_ca_location;
     };
+    struct Ssl final {
+        std::string ssl_ca_location;
+    };
 
-    using SecurityProtocol = std::variant<Plaintext, SaslPlaintext, SaslSsl>;
+    using SecurityProtocol = std::variant<Plaintext, SaslPlaintext, SaslSsl, Ssl>;
     SecurityProtocol security_protocol{};
 };
 
diff --git a/kafka/include/userver/kafka/impl/holders.hpp b/kafka/include/userver/kafka/impl/holders.hpp
index 405d26485de1..76e1abf5a5d8 100644
--- a/kafka/include/userver/kafka/impl/holders.hpp
+++ b/kafka/include/userver/kafka/impl/holders.hpp
@@ -43,7 +43,7 @@ class HolderBase final {
     friend class ConsumerImpl;
     friend class HeadersHolder;
 
-    [[nodiscard]] T* release() noexcept;
+    [[nodiscard]] T* Release() noexcept;
 
     std::unique_ptr<T, DeleterType<T>> ptr_;
 };
@@ -75,7 +75,7 @@ enum class ClientType : std::uint8_t { kConsumer, kProducer };
 
 /// @brief Kafka client wrapper (consumer or producer).
 /// Holds the client and its events queue.
-template <ClientType client_type>
+template <ClientType TClientType>
 class KafkaClientHolder final {
 public:
     explicit KafkaClientHolder(ConfHolder conf);
diff --git a/kafka/include/userver/kafka/rebalance_types.hpp b/kafka/include/userver/kafka/rebalance_types.hpp
index 14f63c3c62b1..b08c1e36878d 100644
--- a/kafka/include/userver/kafka/rebalance_types.hpp
+++ b/kafka/include/userver/kafka/rebalance_types.hpp
@@ -2,6 +2,7 @@
 
 #include <cstdint>
 #include <functional>
+#include <optional>
 
 #include <userver/utils/span.hpp>
 #include <userver/utils/zstring_view.hpp>
@@ -30,7 +31,7 @@ struct TopicPartitionView final {
 using TopicPartitionBatchView = utils::span<const TopicPartitionView>;
 
 /// @brief Callback invoked when a rebalance event occurs.
-/// @warning The rebalance callback must be set before calling ConsumeScope::Start or after calling ConsumeScope::Stop .
+/// @warning The rebalance callback should be set before calling ConsumerScope::Start or after ConsumerScope::Stop.
 /// The callback must not throw exceptions; any thrown exceptions will be caught and logged by the consumer
 /// implementation.
 /// @note The callback is invoked after the assign or revoke event has been successfully processed.
diff --git a/kafka/src/kafka/consumer_component.cpp b/kafka/src/kafka/consumer_component.cpp
index b22e00f66ac2..5040b44619b5 100644
--- a/kafka/src/kafka/consumer_component.cpp
+++ b/kafka/src/kafka/consumer_component.cpp
@@ -74,7 +74,10 @@ additionalProperties: false
         description: |
             Client identifier.
             May be an arbitrary string.
-            Optional, but you should set this property on each instance because it enables you to more easily correlate requests on the broker with the client instance which made it, which can be helpful in debugging and troubleshooting scenarios.
+            Optional, but you should set this property on each instance
+            because it enables you to more easily correlate requests on the broker
+            with the client instance which made it,
+            which can be helpful in debugging and troubleshooting scenarios.
         defaultDescription: userver
     topics:
         type: array
@@ -146,6 +149,7 @@ additionalProperties: false
           - PLAINTEXT
           - SASL_SSL
           - SASL_PLAINTEXT
+          - SSL
     sasl_mechanisms:
         type: string
         description: |
@@ -159,7 +163,7 @@ additionalProperties: false
         type: string
         description: |
             file or directory path to CA certificate(s) for verifying the broker's key.
-            Must be set if `security_protocol` equals `SASL_SSL`.
+            Must be set if `security_protocol` equals `SASL_SSL` or `SSL`.
             If set to `probe`, CA certificates are probed from the default certificates paths
         defaultDescription: none
     topic_metadata_refresh_interval:
diff --git a/kafka/src/kafka/impl/broker_secrets.cpp b/kafka/src/kafka/impl/broker_secrets.cpp
index 8a4ecff16eb0..5024375d35e5 100644
--- a/kafka/src/kafka/impl/broker_secrets.cpp
+++ b/kafka/src/kafka/impl/broker_secrets.cpp
@@ -8,12 +8,25 @@ USERVER_NAMESPACE_BEGIN
 namespace kafka::impl {
 
 Secret Parse(const formats::json::Value& doc, formats::parse::To<Secret>) {
-    Secret secret{
-        doc["brokers"].As<std::string>(),
-        doc["username"].As<Secret::SecretType>(),
-        doc["password"].As<Secret::SecretType>()};
-
-    return secret;
+    auto brokers = doc["brokers"].As<std::string>();
+    if (doc.HasMember("username")) {
+        return Secret{
+            std::move(brokers),
+            Secret::SaslCredentials{
+                doc["username"].As<Secret::SecretType>(),
+                doc["password"].As<Secret::SecretType>(),
+            }};
+    } else if (doc.HasMember("ssl_certificate_location")) {
+        return Secret{
+            std::move(brokers),
+            Secret::SslCredentials{
+                doc["ssl_certificate_location"].As<Secret::SecretType>(),
+                doc["ssl_key_location"].As<Secret::SecretType>(),
+                doc["ssl_key_password"].As<std::optional<Secret::SecretType>>(),
+            }};
+    } else {
+        return Secret{std::move(brokers)};
+    }
 }
 
 BrokerSecrets::BrokerSecrets(const formats::json::Value& doc) {
@@ -29,7 +42,7 @@ const Secret& BrokerSecrets::GetSecretByComponentName(const std::string& compone
         return secret_it->second;
     }
 
-    throw std::runtime_error{fmt::format("No secrets for {} component", component_name)};
+    throw std::runtime_error{fmt::format("No secrets for '{}' component", component_name)};
 }
 
 }  // namespace kafka::impl
diff --git a/kafka/src/kafka/impl/configuration.cpp b/kafka/src/kafka/impl/configuration.cpp
index 145bd4cdb73f..b33cf7c6191c 100644
--- a/kafka/src/kafka/impl/configuration.cpp
+++ b/kafka/src/kafka/impl/configuration.cpp
@@ -28,7 +28,7 @@ namespace {
 // https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a06ade2ca41f32eb82c6f7e3d4acbe19f
 void KafkaLogCallback(const rd_kafka_t*, int level, const char* facility, const char* message) noexcept {
     try {
-        LOG(impl::convertRdKafkaLogLevelToLoggingLevel(level))
+        LOG(impl::ConvertRdKafkaLogLevelToLoggingLevel(level))
             << logging::LogExtra{{{"facility", facility}}} << message;
     } catch (const std::exception& e) {
         UASSERT_MSG(false, e.what());
@@ -107,10 +107,12 @@ SecurityConfiguration Parse(const yaml_config::YamlConfig& config, formats::pars
     static constexpr std::string_view kPlainTextProtocol{"PLAINTEXT"};
     static constexpr std::string_view kSaslPlainTextProtocol{"SASL_PLAINTEXT"};
     static constexpr std::string_view kSaslSSLProtocol{"SASL_SSL"};
+    static constexpr std::string_view kSSLProtocol{"SSL"};
     static constexpr std::array kSupportedSecurityProtocols{
         kPlainTextProtocol,
         kSaslSSLProtocol,
         kSaslPlainTextProtocol,
+        kSSLProtocol,
     };
     static constexpr std::array kSupportedSaslSecurityMechanisms{"PLAIN", "SCRAM-SHA-512"};
 
@@ -125,6 +127,13 @@ SecurityConfiguration Parse(const yaml_config::YamlConfig& config, formats::pars
         return security;
     }
 
+    if (protocol == kSSLProtocol) {
+        security.security_protocol.emplace<SecurityConfiguration::Ssl>(SecurityConfiguration::Ssl{
+            /*ssl_ca_location=*/config["ssl_ca_location"].As<std::string>(),
+        });
+        return security;
+    }
+
     const auto mechanism = config["sasl_mechanisms"].As<std::string>();
     if (!IsSupportedOption(kSupportedSaslSecurityMechanisms, mechanism)) {
         ThrowUnsupportedOption("SASL security mechanism", mechanism, kSupportedSaslSecurityMechanisms);
@@ -244,22 +253,54 @@ void Configuration::SetSecurity(const SecurityConfiguration& security, const Sec
     utils::Visit(
         security.security_protocol,
         [](const SecurityConfiguration::Plaintext&) { LOG_INFO("Using PLAINTEXT security protocol"); },
-        [this, &secrets](const SecurityConfiguration::SaslPlaintext& sasl_ssl) {
+        [this, &secrets](const SecurityConfiguration::SaslPlaintext& sasl_plaintext) {
             LOG_INFO("Using SASL_PLAINTEXT security protocol");
 
+            UINVARIANT(
+                std::holds_alternative<Secret::SaslCredentials>(secrets.credentials),
+                "For 'SASL_PLAINTEXT' security protocol, 'username' and 'password' are required in secdist "
+                "'kafka_settings'"
+            );
+            const auto& credentials = std::get<Secret::SaslCredentials>(secrets.credentials);
+
             SetOption("security.protocol", "SASL_PLAINTEXT");
-            SetOption("sasl.mechanism", sasl_ssl.security_mechanism);
-            SetOption("sasl.username", secrets.username);
-            SetOption("sasl.password", secrets.password);
+            SetOption("sasl.mechanism", sasl_plaintext.security_mechanism);
+            SetOption("sasl.username", credentials.username);
+            SetOption("sasl.password", credentials.password);
         },
         [this, &secrets](const SecurityConfiguration::SaslSsl& sasl_ssl) {
             LOG_INFO("Using SASL_SSL security protocol");
 
+            UINVARIANT(
+                std::holds_alternative<Secret::SaslCredentials>(secrets.credentials),
+                "For 'SASL_SSL' security protocol, 'username' and 'password' are required in secdist "
+                "'kafka_settings'"
+            );
+            const auto& credentials = std::get<Secret::SaslCredentials>(secrets.credentials);
+
             SetOption("security.protocol", "SASL_SSL");
-            SetOption("sasl.mechanism", sasl_ssl.security_mechanism);
-            SetOption("sasl.username", secrets.username);
-            SetOption("sasl.password", secrets.password);
             SetOption("ssl.ca.location", sasl_ssl.ssl_ca_location);
+            SetOption("sasl.mechanism", sasl_ssl.security_mechanism);
+            SetOption("sasl.username", credentials.username);
+            SetOption("sasl.password", credentials.password);
+        },
+        [this, &secrets](const SecurityConfiguration::Ssl& ssl) {
+            LOG_INFO("Using SSL security protocol");
+
+            UINVARIANT(
+                std::holds_alternative<Secret::SslCredentials>(secrets.credentials),
+                "For 'SSL' security protocol, 'ssl_certificate_location', 'ssl_key_location' and optionally "
+                "'ssl_key_password' are required in secdist 'kafka_settings'"
+            );
+
+            const auto& credentials = std::get<Secret::SslCredentials>(secrets.credentials);
+            SetOption("security.protocol", "SSL");
+            SetOption("ssl.ca.location", ssl.ssl_ca_location);
+            SetOption("ssl.certificate.location", credentials.ssl_certificate_location);
+            SetOption("ssl.key.location", credentials.ssl_key_location);
+            if (credentials.ssl_key_password.has_value()) {
+                SetOption("ssl.key.password", *credentials.ssl_key_password);
+            }
         }
     );
 }
diff --git a/kafka/src/kafka/impl/consumer_impl.cpp b/kafka/src/kafka/impl/consumer_impl.cpp
index f02cae940a30..ea06f13ffc39 100644
--- a/kafka/src/kafka/impl/consumer_impl.cpp
+++ b/kafka/src/kafka/impl/consumer_impl.cpp
@@ -296,7 +296,7 @@ void ConsumerImpl::ErrorCallback(rd_kafka_resp_err_t error, const char* reason,
 }
 
 void ConsumerImpl::LogCallback(const char* facility, const char* message, int log_level) {
-    LOG(convertRdKafkaLogLevelToLoggingLevel(log_level))
+    LOG(ConvertRdKafkaLogLevelToLoggingLevel(log_level))
         << logging::LogExtra{{{"kafka_callback", "log_callback"}, {"facility", facility}}} << message;
 }
 
@@ -583,7 +583,7 @@ std::optional<Message> ConsumerImpl::TakeEventMessage(EventHolder&& event_holder
     UASSERT(IsMessageEvent(event_holder));
     UASSERT(rd_kafka_event_message_count(event_holder.GetHandle()) == 1);
 
-    MessageHolder message{event_holder.release()};
+    MessageHolder message{event_holder.Release()};
     if (message->err != RD_KAFKA_RESP_ERR_NO_ERROR) {
         LOG_WARNING("Polled messages contains an error: {}", rd_kafka_err2str(message->err));
 
diff --git a/kafka/src/kafka/impl/holders.cpp b/kafka/src/kafka/impl/holders.cpp
index 08dd30ee9cb6..86db0fde9a50 100644
--- a/kafka/src/kafka/impl/holders.cpp
+++ b/kafka/src/kafka/impl/holders.cpp
@@ -38,7 +38,7 @@ void HolderBase<T, Deleter>::reset() noexcept {
 }
 
 template <class T, DeleterType<T> Deleter>
-T* HolderBase<T, Deleter>::release() noexcept {
+T* HolderBase<T, Deleter>::Release() noexcept {
     return ptr_.release();
 }
 
@@ -70,14 +70,14 @@ rd_kafka_conf_t* ConfHolder::GetHandle() const noexcept { return impl_->conf.Get
 
 void ConfHolder::ForgetUnderlyingConf() noexcept { [[maybe_unused]] auto _ = impl_->conf.ptr_.release(); }
 
-template <ClientType client_type>
-struct KafkaClientHolder<client_type>::Impl {
+template <ClientType TClientType>
+struct KafkaClientHolder<TClientType>::Impl {
     explicit Impl(ConfHolder conf)
         : handle([conf = std::move(conf)]() mutable {
               ErrorBuffer err_buf;
 
               const auto rd_kafka_client_type =
-                  client_type == ClientType::kConsumer ? RD_KAFKA_CONSUMER : RD_KAFKA_PRODUCER;
+                  TClientType == ClientType::kConsumer ? RD_KAFKA_CONSUMER : RD_KAFKA_PRODUCER;
 #if defined(__GNUC__) && !defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
@@ -92,7 +92,7 @@ struct KafkaClientHolder<client_type>::Impl {
                   /// `rd_kafka_new` succeeds
 
                   const auto type_str = [] {
-                      switch (client_type) {
+                      switch (TClientType) {
                           case ClientType::kConsumer:
                               return "consumer";
                           case ClientType::kProducer:
@@ -106,7 +106,7 @@ struct KafkaClientHolder<client_type>::Impl {
 
               conf.ForgetUnderlyingConf();
 
-              if (client_type == ClientType::kConsumer) {
+              if (TClientType == ClientType::kConsumer) {
                   /// Redirects main queue to consumer's queue.
                   rd_kafka_poll_set_consumer(holder.GetHandle());
               }
@@ -114,7 +114,7 @@ struct KafkaClientHolder<client_type>::Impl {
               return holder;
           }()),
           queue([this] {
-              switch (client_type) {
+              switch (TClientType) {
                   case ClientType::kConsumer:
                       return rd_kafka_queue_get_consumer(handle.GetHandle());
                   case ClientType::kProducer:
@@ -128,24 +128,24 @@ struct KafkaClientHolder<client_type>::Impl {
     HolderBase<rd_kafka_queue_t, &rd_kafka_queue_destroy> queue;
 };
 
-template <ClientType client_type>
-KafkaClientHolder<client_type>::KafkaClientHolder(ConfHolder conf) : impl_(std::move(conf)) {}
+template <ClientType TClientType>
+KafkaClientHolder<TClientType>::KafkaClientHolder(ConfHolder conf) : impl_(std::move(conf)) {}
 
-template <ClientType client_type>
-KafkaClientHolder<client_type>::~KafkaClientHolder() = default;
+template <ClientType TClientType>
+KafkaClientHolder<TClientType>::~KafkaClientHolder() = default;
 
-template <ClientType client_type>
-rd_kafka_t* KafkaClientHolder<client_type>::GetHandle() const noexcept {
+template <ClientType TClientType>
+rd_kafka_t* KafkaClientHolder<TClientType>::GetHandle() const noexcept {
     return impl_->handle.GetHandle();
 }
 
-template <ClientType client_type>
-rd_kafka_queue_t* KafkaClientHolder<client_type>::GetQueue() const noexcept {
+template <ClientType TClientType>
+rd_kafka_queue_t* KafkaClientHolder<TClientType>::GetQueue() const noexcept {
     return impl_->queue.GetHandle();
 }
 
-template <ClientType client_type>
-void KafkaClientHolder<client_type>::reset() noexcept {
+template <ClientType TClientType>
+void KafkaClientHolder<TClientType>::reset() noexcept {
     impl_->queue.reset();
     impl_->handle.reset();
 }
@@ -190,7 +190,7 @@ HeadersHolder::HeadersHolder(HeaderViews headers) : impl_{headers} {}
 
 rd_kafka_headers_t* HeadersHolder::GetHandle() const noexcept { return impl_->holder.GetHandle(); }
 
-rd_kafka_headers_t* HeadersHolder::release() noexcept { return impl_->holder.release(); }
+rd_kafka_headers_t* HeadersHolder::release() noexcept { return impl_->holder.Release(); }
 
 HeadersHolder::HeadersHolder(HeadersHolder&& other) noexcept = default;
 
diff --git a/kafka/src/kafka/impl/log_level.cpp b/kafka/src/kafka/impl/log_level.cpp
index 1136b6d0a9a2..c4af010b5632 100644
--- a/kafka/src/kafka/impl/log_level.cpp
+++ b/kafka/src/kafka/impl/log_level.cpp
@@ -22,7 +22,7 @@ enum class RdKafkaLogLevel {
 
 }  // namespace
 
-logging::Level convertRdKafkaLogLevelToLoggingLevel(int log_level) noexcept {
+logging::Level ConvertRdKafkaLogLevelToLoggingLevel(int log_level) noexcept {
     const auto rd_kafka_log_level = static_cast<RdKafkaLogLevel>(log_level);
 
     switch (rd_kafka_log_level) {
diff --git a/kafka/src/kafka/impl/log_level.hpp b/kafka/src/kafka/impl/log_level.hpp
index 48185a9a49d4..18cb613b351c 100644
--- a/kafka/src/kafka/impl/log_level.hpp
+++ b/kafka/src/kafka/impl/log_level.hpp
@@ -6,7 +6,7 @@ USERVER_NAMESPACE_BEGIN
 
 namespace kafka::impl {
 
-logging::Level convertRdKafkaLogLevelToLoggingLevel(int log_level) noexcept;
+logging::Level ConvertRdKafkaLogLevelToLoggingLevel(int log_level) noexcept;
 
 }
 
diff --git a/kafka/src/kafka/impl/producer_impl.cpp b/kafka/src/kafka/impl/producer_impl.cpp
index bda8fe940c73..a857226e3020 100644
--- a/kafka/src/kafka/impl/producer_impl.cpp
+++ b/kafka/src/kafka/impl/producer_impl.cpp
@@ -47,7 +47,7 @@ void ProducerImpl::ErrorCallback(rd_kafka_resp_err_t error, const char* reason,
 }
 
 void ProducerImpl::LogCallback(const char* facility, const char* message, int log_level) const {
-    LOG(convertRdKafkaLogLevelToLoggingLevel(log_level))
+    LOG(ConvertRdKafkaLogLevelToLoggingLevel(log_level))
         << logging::LogExtra{{{"kafka_callback", "log_callback"}, {"facility", facility}}} << message;
 }
 
diff --git a/kafka/src/kafka/producer_component.cpp b/kafka/src/kafka/producer_component.cpp
index dfd092b790d9..f8db7089d45e 100644
--- a/kafka/src/kafka/producer_component.cpp
+++ b/kafka/src/kafka/producer_component.cpp
@@ -48,7 +48,10 @@ additionalProperties: false
         description: |
             Client identifier.
             May be an arbitrary string.
-            Optional, but you should set this property on each instance because it enables you to more easily correlate requests on the broker with the client instance which made it, which can be helpful in debugging and troubleshooting scenarios.
+            Optional, but you should set this property on each instance
+            because it enables you to more easily correlate requests on the broker
+            with the client instance which made it,
+            which can be helpful in debugging and troubleshooting scenarios.
         defaultDescription: userver
     delivery_timeout:
         type: string
@@ -108,6 +111,7 @@ additionalProperties: false
           - PLAINTEXT
           - SASL_SSL
           - SASL_PLAINTEXT
+          - SSL
     sasl_mechanisms:
         type: string
         description: |
@@ -121,9 +125,10 @@ additionalProperties: false
         type: string
         description: |
             file or directory path to CA certificate(s) for verifying the broker's key.
-            Must be set if `security_protocol` equals `SASL_SSL`.
+            Must be set if `security_protocol` equals `SASL_SSL` or `SSL`.
             If set to `probe`, CA certificates are probed from the default certificates paths
         defaultDescription: none
+
     rd_kafka_custom_options:
         type: object
         description: |
diff --git a/kafka/tests/configuration_test.cpp b/kafka/tests/configuration_test.cpp
index c18b1df723ec..ba7d0d228866 100644
--- a/kafka/tests/configuration_test.cpp
+++ b/kafka/tests/configuration_test.cpp
@@ -12,6 +12,8 @@ using namespace std::chrono_literals;
 
 class ConfigurationTest : public kafka::utest::KafkaCluster {};
 
+using ConfigurationDeathTest = ConfigurationTest;
+
 }  // namespace
 
 UTEST_F(ConfigurationTest, Producer) {
@@ -129,7 +131,7 @@ UTEST_F(ConfigurationTest, ConsumerNonDefault) {
     EXPECT_EQ(configuration->GetOption("socket.keepalive.enable"), "true");
 }
 
-UTEST_F(ConfigurationTest, ProducerSecure) {
+UTEST_F(ConfigurationTest, ProducerSaslSsl) {
     kafka::impl::ProducerConfiguration producer_configuration{};
     producer_configuration.security.security_protocol = kafka::impl::SecurityConfiguration::SaslSsl{
         /*security_mechanism=*/"SCRAM-SHA-512",
@@ -137,8 +139,10 @@ UTEST_F(ConfigurationTest, ProducerSecure) {
     };
 
     kafka::impl::Secret secrets;
-    secrets.username = kafka::impl::Secret::SecretType{"username"};
-    secrets.password = kafka::impl::Secret::SecretType{"password"};
+    secrets.credentials = kafka::impl::Secret::SaslCredentials{
+        kafka::impl::Secret::SecretType{"username"},
+        kafka::impl::Secret::SecretType{"password"},
+    };
 
     std::optional<kafka::impl::Configuration> configuration;
     UEXPECT_NO_THROW(configuration.emplace(MakeProducerConfiguration("kafka-producer", producer_configuration, secrets))
@@ -151,15 +155,17 @@ UTEST_F(ConfigurationTest, ProducerSecure) {
     EXPECT_EQ(configuration->GetOption("ssl.ca.location"), "probe");
 }
 
-UTEST_F(ConfigurationTest, ProducerSecurePlaintext) {
+UTEST_F(ConfigurationTest, ProducerSaslPlaintext) {
     kafka::impl::ProducerConfiguration producer_configuration{};
     producer_configuration.security.security_protocol = kafka::impl::SecurityConfiguration::SaslPlaintext{
         /*security_mechanism=*/"SCRAM-SHA-512",
     };
 
     kafka::impl::Secret secrets;
-    secrets.username = kafka::impl::Secret::SecretType{"username"};
-    secrets.password = kafka::impl::Secret::SecretType{"password"};
+    secrets.credentials = kafka::impl::Secret::SaslCredentials{
+        kafka::impl::Secret::SecretType{"username"},
+        kafka::impl::Secret::SecretType{"password"},
+    };
 
     std::optional<kafka::impl::Configuration> configuration;
     UEXPECT_NO_THROW(configuration.emplace(MakeProducerConfiguration("kafka-producer", producer_configuration, secrets))
@@ -171,7 +177,7 @@ UTEST_F(ConfigurationTest, ProducerSecurePlaintext) {
     EXPECT_EQ(configuration->GetOption("sasl.password"), "password");
 }
 
-UTEST_F(ConfigurationTest, ConsumerSecure) {
+UTEST_F(ConfigurationTest, ConsumerSaslSsl) {
     kafka::impl::ConsumerConfiguration consumer_configuration{};
     consumer_configuration.security.security_protocol = kafka::impl::SecurityConfiguration::SaslSsl{
         /*security_mechanism=*/"SCRAM-SHA-512",
@@ -179,8 +185,10 @@ UTEST_F(ConfigurationTest, ConsumerSecure) {
     };
 
     kafka::impl::Secret secrets;
-    secrets.username = kafka::impl::Secret::SecretType{"username"};
-    secrets.password = kafka::impl::Secret::SecretType{"password"};
+    secrets.credentials = kafka::impl::Secret::SaslCredentials{
+        kafka::impl::Secret::SecretType{"username"},
+        kafka::impl::Secret::SecretType{"password"},
+    };
 
     std::optional<kafka::impl::Configuration> configuration;
     UEXPECT_NO_THROW(configuration.emplace(MakeConsumerConfiguration("kafka-consumer", consumer_configuration, secrets))
@@ -193,15 +201,17 @@ UTEST_F(ConfigurationTest, ConsumerSecure) {
     EXPECT_EQ(configuration->GetOption("ssl.ca.location"), "/etc/ssl/cert.ca");
 }
 
-UTEST_F(ConfigurationTest, ConsumerSecurePlaintext) {
+UTEST_F(ConfigurationTest, ConsumerSaslPlaintext) {
     kafka::impl::ConsumerConfiguration consumer_configuration{};
     consumer_configuration.security.security_protocol = kafka::impl::SecurityConfiguration::SaslPlaintext{
         /*security_mechanism=*/"SCRAM-SHA-512",
     };
 
     kafka::impl::Secret secrets;
-    secrets.username = kafka::impl::Secret::SecretType{"username"};
-    secrets.password = kafka::impl::Secret::SecretType{"password"};
+    secrets.credentials = kafka::impl::Secret::SaslCredentials{
+        kafka::impl::Secret::SecretType{"username"},
+        kafka::impl::Secret::SecretType{"password"},
+    };
 
     std::optional<kafka::impl::Configuration> configuration;
     UEXPECT_NO_THROW(configuration.emplace(MakeConsumerConfiguration("kafka-consumer", consumer_configuration, secrets))
@@ -213,6 +223,52 @@ UTEST_F(ConfigurationTest, ConsumerSecurePlaintext) {
     EXPECT_EQ(configuration->GetOption("sasl.password"), "password");
 }
 
+UTEST_F(ConfigurationTest, ProducerSsl) {
+    kafka::impl::ProducerConfiguration producer_configuration{};
+    producer_configuration.security.security_protocol = kafka::impl::SecurityConfiguration::Ssl{
+        /*ssl_ca_location=*/"/etc/ssl/ca.crt",
+    };
+
+    kafka::impl::Secret secrets;
+    secrets.credentials = kafka::impl::Secret::SslCredentials{
+        kafka::impl::Secret::SecretType{"/etc/ssl/client.crt"},
+        kafka::impl::Secret::SecretType{"/etc/ssl/client.key"},
+        kafka::impl::Secret::SecretType{"password123"},
+    };
+
+    std::optional<kafka::impl::Configuration> configuration;
+    UEXPECT_NO_THROW(configuration.emplace(MakeProducerConfiguration("kafka-producer", producer_configuration, secrets))
+    );
+
+    EXPECT_EQ(configuration->GetOption("security.protocol"), "ssl");
+    EXPECT_EQ(configuration->GetOption("ssl.ca.location"), "/etc/ssl/ca.crt");
+    EXPECT_EQ(configuration->GetOption("ssl.certificate.location"), "/etc/ssl/client.crt");
+    EXPECT_EQ(configuration->GetOption("ssl.key.location"), "/etc/ssl/client.key");
+    EXPECT_EQ(configuration->GetOption("ssl.key.password"), "password123");
+}
+
+UTEST_F(ConfigurationTest, ConsumerSSL) {
+    kafka::impl::ConsumerConfiguration consumer_configuration{};
+    consumer_configuration.security.security_protocol = kafka::impl::SecurityConfiguration::Ssl{
+        /*ssl_ca_location=*/"/etc/ssl/ca.crt",
+    };
+
+    kafka::impl::Secret secrets;
+    secrets.credentials = kafka::impl::Secret::SslCredentials{
+        kafka::impl::Secret::SecretType{"/etc/ssl/client.crt"},
+        kafka::impl::Secret::SecretType{"/etc/ssl/client.key"},
+    };
+
+    std::optional<kafka::impl::Configuration> configuration;
+    UEXPECT_NO_THROW(configuration.emplace(MakeConsumerConfiguration("kafka-consumer", consumer_configuration, secrets))
+    );
+
+    EXPECT_EQ(configuration->GetOption("security.protocol"), "ssl");
+    EXPECT_EQ(configuration->GetOption("ssl.ca.location"), "/etc/ssl/ca.crt");
+    EXPECT_EQ(configuration->GetOption("ssl.certificate.location"), "/etc/ssl/client.crt");
+    EXPECT_EQ(configuration->GetOption("ssl.key.location"), "/etc/ssl/client.key");
+}
+
 UTEST_F(ConfigurationTest, IncorrectComponentName) {
     UEXPECT_THROW(MakeProducerConfiguration("producer"), std::runtime_error);
     UEXPECT_THROW(MakeConsumerConfiguration("consumer"), std::runtime_error);
@@ -234,4 +290,178 @@ UTEST_F(ConfigurationTest, ConsumerResolveGroupId) {
     EXPECT_EQ(configuration->GetOption("group.id"), "test-group-pod-example-com");
 }
 
+UTEST_F_DEATH(ConfigurationDeathTest, ContradictorySecurityConfiguration) {
+    kafka::impl::ProducerConfiguration sasl_ssl{};
+    sasl_ssl.security.security_protocol = kafka::impl::SecurityConfiguration::SaslSsl{
+        /*security_mechanism=*/"SCRAM-SHA-512",
+        /*ssl_ca_location=*/"probe",
+    };
+    kafka::impl::ProducerConfiguration sasl_plaintext{};
+    sasl_plaintext.security.security_protocol = kafka::impl::SecurityConfiguration::SaslPlaintext{
+        /*security_mechanism=*/"SCRAM-SHA-512",
+    };
+    kafka::impl::ConsumerConfiguration ssl{};
+    ssl.security.security_protocol = kafka::impl::SecurityConfiguration::Ssl{
+        /*ssl_ca_location=*/"/etc/ssl/ca.crt",
+    };
+
+    kafka::impl::Secret secrets_none;
+    kafka::impl::Secret secrets_sasl;
+    secrets_sasl.credentials = kafka::impl::Secret::SaslCredentials{
+        kafka::impl::Secret::SecretType{"username"},
+        kafka::impl::Secret::SecretType{"password"},
+    };
+    kafka::impl::Secret secrets_ssl;
+    secrets_ssl.credentials = kafka::impl::Secret::SslCredentials{
+        kafka::impl::Secret::SecretType{"/etc/ssl/client.crt"},
+        kafka::impl::Secret::SecretType{"/etc/ssl/client.key"},
+        kafka::impl::Secret::SecretType{"password123"},
+    };
+
+    std::optional<kafka::impl::Configuration> configuration;
+#ifdef NDEBUG
+    UEXPECT_THROW(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_ssl, secrets_none)), std::exception
+    );
+    UEXPECT_THROW(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_ssl, secrets_ssl)), std::exception
+    );
+    UEXPECT_THROW(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_plaintext, secrets_none)), std::exception
+    );
+    UEXPECT_THROW(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_plaintext, secrets_ssl)), std::exception
+    );
+    UEXPECT_THROW(
+        configuration.emplace(MakeConsumerConfiguration("kafka-consumer", ssl, secrets_none)), std::exception
+    );
+    UEXPECT_THROW(
+        configuration.emplace(MakeConsumerConfiguration("kafka-consumer", ssl, secrets_sasl)), std::exception
+    );
+#else
+    UEXPECT_DEATH(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_ssl, secrets_none)),
+        "For 'SASL_SSL' security protocol, 'username' and 'password' are required in secdist 'kafka_settings'"
+    );
+    UEXPECT_DEATH(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_ssl, secrets_ssl)),
+        "For 'SASL_SSL' security protocol, 'username' and 'password' are required in secdist 'kafka_settings'"
+    );
+    UEXPECT_DEATH(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_plaintext, secrets_none)),
+        "For 'SASL_PLAINTEXT' security protocol, 'username' and 'password' are required in secdist 'kafka_settings'"
+    );
+    UEXPECT_DEATH(
+        configuration.emplace(MakeProducerConfiguration("kafka-producer", sasl_plaintext, secrets_ssl)),
+        "For 'SASL_PLAINTEXT' security protocol, 'username' and 'password' are required in secdist 'kafka_settings'"
+    );
+    UEXPECT_DEATH(
+        configuration.emplace(MakeConsumerConfiguration("kafka-consumer", ssl, secrets_none)),
+        "For 'SSL' security protocol, 'ssl_certificate_location', 'ssl_key_location' and optionally 'ssl_key_password' "
+        "are required in secdist 'kafka_settings'"
+    );
+    UEXPECT_DEATH(
+        configuration.emplace(MakeConsumerConfiguration("kafka-consumer", ssl, secrets_sasl)),
+        "For 'SSL' security protocol, 'ssl_certificate_location', 'ssl_key_location' and optionally 'ssl_key_password' "
+        "are required in secdist 'kafka_settings'"
+    );
+#endif
+}
+
+UTEST_F(ConfigurationTest, BrokerSecrets) {
+    const auto make_kafka_settings = [](formats::json::Value component_settings) {
+        return formats::json::MakeObject(
+            "kafka_settings", formats::json::MakeObject("kafka-client", std::move(component_settings))
+        );
+    };
+
+    const auto only_brokers = formats::json::MakeObject("brokers", "localhost:1111");
+    const auto sasl = formats::json::MakeObject(
+        "brokers",
+        "localhost:1111",
+        //
+        "username",
+        "user",
+        //
+        "password",
+        "pass"
+        //
+    );
+    const auto ssl = formats::json::MakeObject(
+        "brokers",
+        "localhost:1111",
+        //
+        "ssl_certificate_location",
+        "/etc/ssl/client.crt",
+        //
+        "ssl_key_location",
+        "/etc/ssl/client.key",
+        //
+        "ssl_key_password",
+        "pass"
+        //
+    );
+    const auto ssl_no_password = formats::json::MakeObject(
+        "brokers",
+        "localhost:1111",
+        //
+        "ssl_certificate_location",
+        "/etc/ssl/client.crt",
+        //
+        "ssl_key_location",
+        "/etc/ssl/client.key"
+        //
+    );
+
+    std::optional<kafka::impl::BrokerSecrets> broker_secrets;
+    std::optional<kafka::impl::Secret> secret;
+
+    {
+        UEXPECT_NO_THROW(broker_secrets.emplace(make_kafka_settings(only_brokers)));
+        UEXPECT_NO_THROW(secret.emplace(broker_secrets->GetSecretByComponentName("kafka-client")));
+        ASSERT_TRUE(std::holds_alternative<std::monostate>(secret->credentials));
+        EXPECT_EQ(secret->brokers, "localhost:1111");
+    }
+    {
+        UEXPECT_NO_THROW(broker_secrets.emplace(make_kafka_settings(sasl)));
+        UEXPECT_NO_THROW(secret.emplace(broker_secrets->GetSecretByComponentName("kafka-client")));
+        ASSERT_TRUE(std::holds_alternative<kafka::impl::Secret::SaslCredentials>(secret->credentials));
+        EXPECT_EQ(secret->brokers, "localhost:1111");
+        EXPECT_EQ(std::get<kafka::impl::Secret::SaslCredentials>(secret->credentials).username.GetUnderlying(), "user");
+        EXPECT_EQ(std::get<kafka::impl::Secret::SaslCredentials>(secret->credentials).password.GetUnderlying(), "pass");
+    }
+    {
+        UEXPECT_NO_THROW(broker_secrets.emplace(make_kafka_settings(ssl)));
+        UEXPECT_NO_THROW(secret.emplace(broker_secrets->GetSecretByComponentName("kafka-client")));
+        ASSERT_TRUE(std::holds_alternative<kafka::impl::Secret::SslCredentials>(secret->credentials));
+        EXPECT_EQ(secret->brokers, "localhost:1111");
+        EXPECT_EQ(
+            std::get<kafka::impl::Secret::SslCredentials>(secret->credentials).ssl_certificate_location.GetUnderlying(),
+            "/etc/ssl/client.crt"
+        );
+        EXPECT_EQ(
+            std::get<kafka::impl::Secret::SslCredentials>(secret->credentials).ssl_key_location.GetUnderlying(),
+            "/etc/ssl/client.key"
+        );
+        EXPECT_EQ(
+            std::get<kafka::impl::Secret::SslCredentials>(secret->credentials).ssl_key_password->GetUnderlying(), "pass"
+        );
+    }
+    {
+        UEXPECT_NO_THROW(broker_secrets.emplace(make_kafka_settings(ssl_no_password)));
+        UEXPECT_NO_THROW(secret.emplace(broker_secrets->GetSecretByComponentName("kafka-client")));
+        ASSERT_TRUE(std::holds_alternative<kafka::impl::Secret::SslCredentials>(secret->credentials));
+        EXPECT_EQ(secret->brokers, "localhost:1111");
+        EXPECT_EQ(
+            std::get<kafka::impl::Secret::SslCredentials>(secret->credentials).ssl_certificate_location.GetUnderlying(),
+            "/etc/ssl/client.crt"
+        );
+        EXPECT_EQ(
+            std::get<kafka::impl::Secret::SslCredentials>(secret->credentials).ssl_key_location.GetUnderlying(),
+            "/etc/ssl/client.key"
+        );
+        EXPECT_FALSE(std::get<kafka::impl::Secret::SslCredentials>(secret->credentials).ssl_key_password.has_value());
+    }
+}
+
 USERVER_NAMESPACE_END
diff --git a/kafka/utest/include/userver/kafka/utest/kafka_fixture.hpp b/kafka/utest/include/userver/kafka/utest/kafka_fixture.hpp
index 86d0262ae59d..8ad91f6f0e1d 100644
--- a/kafka/utest/include/userver/kafka/utest/kafka_fixture.hpp
+++ b/kafka/utest/include/userver/kafka/utest/kafka_fixture.hpp
@@ -88,7 +88,7 @@ class KafkaCluster : public ::testing::Test {
 
     std::deque<Producer> MakeProducers(
         std::size_t count,
-        std::function<std::string(std::size_t)> nameGenerator,
+        std::function<std::string(std::size_t)> name_generator,
         impl::ProducerConfiguration configuration = {}
     );
 
diff --git a/kafka/utest/src/kafka/utest/kafka_fixture.cpp b/kafka/utest/src/kafka/utest/kafka_fixture.cpp
index 21942e363d48..737fc2d8b2d3 100644
--- a/kafka/utest/src/kafka/utest/kafka_fixture.cpp
+++ b/kafka/utest/src/kafka/utest/kafka_fixture.cpp
@@ -129,12 +129,12 @@ Producer KafkaCluster::MakeProducer(const std::string& name, impl::ProducerConfi
 
 std::deque<Producer> KafkaCluster::MakeProducers(
     std::size_t count,
-    std::function<std::string(std::size_t)> nameGenerator,
+    std::function<std::string(std::size_t)> name_generator,
     impl::ProducerConfiguration configuration
 ) {
     std::deque<Producer> producers;
     for (std::size_t i{0}; i < count; ++i) {
-        producers.emplace_back(utils::LazyPrvalue([&] { return MakeProducer(nameGenerator(i), configuration); }));
+        producers.emplace_back(utils::LazyPrvalue([&] { return MakeProducer(name_generator(i), configuration); }));
     }
 
     return producers;
diff --git a/libraries/easy/CMakeLists.txt b/libraries/easy/CMakeLists.txt
index 33f6da209c43..7b5c38799531 100644
--- a/libraries/easy/CMakeLists.txt
+++ b/libraries/easy/CMakeLists.txt
@@ -5,6 +5,7 @@ userver_module(
     SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
     LINK_LIBRARIES userver::postgresql
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    DEPENDS core
 )
 
 if(USERVER_BUILD_SAMPLES)
diff --git a/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/client/impl/codegen_declarations.hpp b/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/client/impl/codegen_declarations.hpp
new file mode 100644
index 000000000000..a1d2e41cde7a
--- /dev/null
+++ b/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/client/impl/codegen_declarations.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+// This header contains all static includes for code-generated
+// *_client.structs.usrv.pb.hpp files.
+//
+// Do not include this header in your code, use non-impl includes instead!
diff --git a/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/impl/codegen_declarations.hpp b/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/impl/codegen_declarations.hpp
new file mode 100644
index 000000000000..debf33293563
--- /dev/null
+++ b/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/impl/codegen_declarations.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+// This header contains all static includes for code-generated
+// *_service.structs.usrv.pb.hpp files.
+//
+// Do not include this header in your code, use non-impl includes instead!
+
+#include <userver/grpc-proto-structs/server/stream.hpp>
diff --git a/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/stream.hpp b/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/stream.hpp
new file mode 100644
index 000000000000..0b1ad5920775
--- /dev/null
+++ b/libraries/grpc-proto-structs/include/userver/grpc-proto-structs/server/stream.hpp
@@ -0,0 +1,110 @@
+#pragma once
+
+/// @file userver/grpc-proto-structs/server/stream.hpp
+/// @brief proto-struct based server streaming interfaces
+
+#include <utility>
+
+#include <userver/proto-structs/convert.hpp>
+#include <userver/ugrpc/server/stream.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace grpc_proto_structs::server {
+
+/// @brief proto-struct based Reader adapter
+///
+/// This class is not thread-safe.
+///
+/// If any method throws, further methods must not be called on the same stream.
+/// @see @ref ugrpc::server::Reader.
+template <typename Request>
+class Reader {
+public:
+    using RequestMessage = proto_structs::traits::CompatibleMessageType<Request>;
+    using ProtobufMessageReader = ugrpc::server::Reader<RequestMessage>;
+
+    explicit Reader(ProtobufMessageReader& reader) : reader_{reader} {}
+
+    /// @brief Await and read the next incoming message.
+    ///
+    /// Read protobuf message corresponding to `Request` with @ref ugrpc::server::Reader::Read
+    /// and construct `Request` from it.
+    ///
+    /// @see @ref ugrpc::server::Reader::Read method for details.
+    bool Read(Request& request) {
+        RequestMessage message;
+        if (reader_.Read(message)) {
+            proto_structs::MessageToStruct(message, request);
+            return true;
+        }
+        return false;
+    }
+
+private:
+    ProtobufMessageReader& reader_;
+};
+
+/// @brief proto-struct based Writer adapter
+///
+/// This class is not thread-safe.
+///
+/// If any method throws, further methods must not be called on the same stream.
+/// @see @ref ugrpc::server::Writer.
+template <typename Response>
+class Writer {
+public:
+    using ResponseMessage = proto_structs::traits::CompatibleMessageType<Response>;
+    using ProtobufMessageWriter = ugrpc::server::Writer<ResponseMessage>;
+
+    explicit Writer(ProtobufMessageWriter& writer) : writer_{writer} {}
+
+    /// @{
+    /// @brief Write the next outgoing message.
+    ///
+    /// Convert response to corresponding protobuf message and pass it to @ref ugrpc::server::Writer::Write.
+    ///
+    /// @see @ref ugrpc::server::Writer::Write method for details.
+    void Write(Response& response) { writer_.Write(proto_structs::StructToMessage(response)); }
+
+    void Write(Response& response, const grpc::WriteOptions& options) {
+        writer_.Write(proto_structs::StructToMessage(response), options);
+    }
+
+    void Write(Response&& response) { writer_.Write(proto_structs::StructToMessage(std::move(response))); }
+
+    void Write(Response&& response, const grpc::WriteOptions& options) {
+        writer_.Write(proto_structs::StructToMessage(std::move(response)), options);
+    }
+    /// @}
+
+private:
+    ProtobufMessageWriter& writer_;
+};
+
+/// @brief proto-struct based ReaderWriter adapter
+///
+/// If any method throws, further methods must not be called on the same stream.
+///
+/// This class allows the following concurrent calls:
+///
+///   - `Read`;
+///   - `Write`
+///
+/// and there can only be one Read and one Write in flight at a time.
+///
+/// If any method throws, further methods must not be called on the same stream.
+/// @see @ref ugrpc::server::ReaderWriter.
+template <typename Request, typename Response>
+class ReaderWriter : public Reader<Request>, public Writer<Response> {
+public:
+    using ProtobufMessageReaderWriter = ugrpc::server::
+        ReaderWriter<typename Reader<Request>::RequestMessage, typename Writer<Response>::ResponseMessage>;
+
+    explicit ReaderWriter(ProtobufMessageReaderWriter& reader_writer)
+        : Reader<Request>{reader_writer}, Writer<Response>{reader_writer} {}
+};
+
+}  // namespace grpc_proto_structs::server
+
+USERVER_NAMESPACE_END
diff --git a/libraries/grpc-proto-structs/src/grpc-proto-structs.cpp b/libraries/grpc-proto-structs/src/grpc-proto-structs.cpp
new file mode 100644
index 000000000000..467e96908389
--- /dev/null
+++ b/libraries/grpc-proto-structs/src/grpc-proto-structs.cpp
@@ -0,0 +1 @@
+namespace grpc_proto_structs {}
diff --git a/libraries/grpc-reflection/CMakeLists.txt b/libraries/grpc-reflection/CMakeLists.txt
index dfac35d21cc6..f712c542e006 100644
--- a/libraries/grpc-reflection/CMakeLists.txt
+++ b/libraries/grpc-reflection/CMakeLists.txt
@@ -9,6 +9,7 @@ userver_module(
     SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
     LINK_LIBRARIES ${PROJECT_NAME}-proto userver::grpc
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    DEPENDS grpc
 )
 
 if(USERVER_BUILD_TESTS)
diff --git a/libraries/proto-structs/codegen-tests/proto/box/autobox/cycles.proto b/libraries/proto-structs/codegen-tests/proto/box/autobox/cycles.proto
new file mode 100644
index 000000000000..0cab10c82b76
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/box/autobox/cycles.proto
@@ -0,0 +1,115 @@
+syntax = "proto3";
+
+package box.autobox;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox;boxautobox";
+
+message Self {
+    Self self = 1;
+}
+
+message First {
+    Second c = 1;
+}
+
+message Second {
+    Third c = 1;
+}
+
+message Third {
+    First c = 1;
+}
+
+message CycleEnd {
+    CycleStart cycle = 1;
+}
+
+message CycleStart {
+    CycleEnd cycle = 1;
+    repeated CycleEnd not_boxed = 2;
+}
+
+message Main1 {
+    message Inner {
+        ImBelowMain1 cycle = 1;
+    }
+    Main1.Inner inner = 1;
+}
+
+message ImBelowMain1 {
+    Main1 cycle = 1;
+}
+
+message IamAboveMain2 {
+    Main2 cycle = 1;
+}
+
+message Main2 {
+    message Outer {
+        Main2.Inner inner = 1;
+    }
+    message Inner {
+        IamAboveMain2 cycle = 1;
+    }
+    Inner inner = 1;
+}
+
+message NewCycle {
+    message Inner1 {
+        message InnerInner {
+            NewCycle.Inner2Below inner = 1;
+        }
+        InnerInner inner = 1;
+    }
+    message Inner2Below {
+        message InnerInner {
+            NewCycle.Inner1 inner = 1;
+        }
+        InnerInner i = 1;
+    }
+    Inner1 inner = 1;
+}
+
+message NewCycle2 {
+    message Inner2Above {
+        message InnerInner {
+            NewCycle2.Inner1 inner = 1;
+        }
+        NewCycle2.Inner2Above.InnerInner i = 1;
+    }
+    message Inner1 {
+        message InnerInner {
+            NewCycle2.Inner2Above inner = 1;
+        }
+        NewCycle2.Inner1.InnerInner inner = 1;
+    }
+    NewCycle2.Inner1 inner = 1;
+}
+
+message OptionalSelf {
+    optional OptionalSelf self = 1;
+}
+
+message OptionalDouble {
+    message First {
+        optional Second c = 1;
+    }
+
+    message Second {
+        optional First c = 1;
+    }
+}
+
+message OptionalTriple {
+    message First {
+        optional Second c = 1;
+    }
+
+    message Second {
+        optional Third c = 1;
+    }
+
+    message Third {
+        optional First c = 1;
+    }
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto b/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto
new file mode 100644
index 000000000000..00adf5c1c53d
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto
@@ -0,0 +1,83 @@
+syntax = "proto3";
+
+package box.autobox;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox;boxautobox";
+
+// There is no dependency cycle, just need to define `Bar` before `Foo`.
+message DependencyOnNested {
+  message Foo {
+    Bar.Nested field = 1;
+  }
+
+  message Bar {
+    message Nested {}
+  }
+}
+
+// Same as above, but with double nesting.
+message DependencyOnNestedNested {
+  message Foo {
+    Bar.Nested.Nested2 field = 1;
+  }
+
+  message Bar {
+    message Nested {
+      message Nested2 {}
+    }
+  }
+}
+
+// There is no dependency cycle, but still need to define `Bar` before `Foo`, despite the field being a `std::vector`.
+// This is because we need the definition of `Bar` to mention `Bar::Nested`.
+message RepeatedDependencyOnNested {
+  message Foo {
+    repeated Bar.Nested field = 1;
+  }
+
+  message Bar {
+    message Nested {}
+  }
+}
+
+// There is a dependency cycle `Foo <-> Bar`, and the dependency `Foo.field -> Bar.Nested` is unbreakable using fwd,
+// because `Bar` needs to be defined to mention `Bar::Nested`.
+message CyclicDependencyOnNested {
+  message Foo {
+    // Should NOT be boxed, it is meaningless. Instead, definition of `Foo` should be moved after `Bar`.
+    Bar.Nested field = 1;
+  }
+
+  message Bar {
+    message Nested {}
+
+    // Should be boxed to break the cycle.
+    Foo field = 1;
+  }
+}
+
+// Same as above. Boxing `Foo.field` is meaningless, because `Bar` needs to be defined to mention `Bar::Nested`.
+message RepeatedCyclicDependencyOnNested {
+  message Foo {
+    // Should NOT be boxed, it is meaningless. Instead, definition of `Foo` should be moved after `Bar`.
+    repeated Bar.Nested field = 1;
+  }
+
+  message Bar {
+    message Nested {}
+
+    // Should be boxed to break the cycle.
+    Foo field = 1;
+  }
+}
+
+// Sanity check: for WEAK dependencies on direct neighbours (not their nested types), a forward declaration is enough.
+message VectorsDoNotCreateCycles {
+  message Foo {
+    repeated Bar field = 1;
+  }
+
+  message Bar {
+    repeated Foo field = 1;
+  }
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_self.proto b/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_self.proto
new file mode 100644
index 000000000000..061daad3c479
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_self.proto
@@ -0,0 +1,54 @@
+syntax = "proto3";
+
+package box.autobox;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox;boxautobox";
+
+message DependencyOnSelfDirect {
+  // Should be boxed.
+  DependencyOnSelfDirect field = 1;
+}
+
+message DependencyOnSelfNested {
+  message Nested {
+    // Should be boxed.
+    DependencyOnSelfNested field = 1;
+  }
+}
+
+message DependencyOnSelfOptional {
+  // Should be boxed.
+  optional DependencyOnSelfOptional field = 1;
+}
+
+message DependencyOnSelfRepeated {
+  // Should not be boxed: the outer struct is already declared at this point.
+  repeated DependencyOnSelfRepeated field = 1;
+}
+
+message DependencyWithinSelf {
+  message A {}
+
+  message B {
+    // Should not be boxed.
+    //
+    // When accounting edges at the namespace level, we should say that there is no edge from DependencyWithinSelf
+    // to itself, even though there is a dependency from within DependencyWithinSelf to within DependencyWithinSelf.
+    A field = 1;
+  }
+}
+
+message DependencyOnSelfCollateral {
+  message A {}
+
+  message B {
+    // Should not be boxed.
+    //
+    // Although there is an edge from within DependencyOnSelfCollateral to DependencyOnSelfCollateral,
+    // this dependency is strictly within DependencyOnSelfCollateral and is irrelevant when sorting dependencies
+    // at namespace scope.
+    A field = 1;
+  }
+
+  optional DependencyOnSelfCollateral field = 1;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/box/autobox/unbreakable_cycle.proto b/libraries/proto-structs/codegen-tests/proto/box/autobox/unbreakable_cycle.proto
new file mode 100644
index 000000000000..6810a2b81ef5
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/box/autobox/unbreakable_cycle.proto
@@ -0,0 +1,19 @@
+syntax = "proto3";
+
+package box.autobox;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/autobox;boxautobox";
+
+message UnbreakableCycle {
+    message A {
+        message Inner {}
+
+        B.Inner b = 1;
+    }
+
+    message B {
+        message Inner {}
+
+        optional A.Inner a = 1;
+    }
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/box/options/cycles.proto b/libraries/proto-structs/codegen-tests/proto/box/options/cycles.proto
new file mode 100644
index 000000000000..a02a21899603
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/box/options/cycles.proto
@@ -0,0 +1,121 @@
+syntax = "proto3";
+
+package box.options;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/options;boxoptions";
+
+import "userver/structs/annotations.proto";
+
+message MyMap {
+    map<string, string> self = 1 [(userver.structs.field).indirect = true];
+}
+
+message Self {
+    Self self = 1 [(userver.structs.field).indirect = true];
+}
+
+message First {
+    Second c = 1;
+}
+
+message Second {
+    Third c = 1;
+}
+
+message Third {
+    First c = 1 [(userver.structs.field).indirect = true];
+}
+
+message CycleEnd {
+    CycleStart cycle = 1;
+}
+
+message CycleStart {
+    CycleEnd cycle = 1 [(userver.structs.field).indirect = true];
+    repeated CycleEnd not_boxed = 2;
+}
+
+message Main1 {
+    message Inner {
+        ImBelowMain1 cycle = 1 [(userver.structs.field).indirect = true];
+    }
+    Main1.Inner inner = 1;
+}
+
+message ImBelowMain1 {
+    Main1 cycle = 1;
+}
+
+message IamAboveMain2 {
+    Main2 cycle = 1;
+}
+
+message Main2 {
+    message Outer {
+        Main2.Inner inner = 1;
+    }
+    message Inner {
+        IamAboveMain2 cycle = 1 [(userver.structs.field).indirect = true];
+    }
+    Inner inner = 1;
+}
+
+message NewCycle {
+    message Inner1 {
+        message InnerInner {
+            NewCycle.Inner2Below inner = 1;
+        }
+        InnerInner inner = 1;
+    }
+    message Inner2Below {
+        message InnerInner {
+            NewCycle.Inner1 inner = 1 [(userver.structs.field).indirect = true];
+        }
+        InnerInner i = 1;
+    }
+    Inner1 inner = 1;
+}
+
+message NewCycle2 {
+    message Inner2Above {
+        message InnerInner {
+            NewCycle2.Inner1 inner = 1 [(userver.structs.field).indirect = true];
+        }
+        NewCycle2.Inner2Above.InnerInner i = 1;
+    }
+    message Inner1 {
+        message InnerInner {
+            NewCycle2.Inner2Above inner = 1;
+        }
+        NewCycle2.Inner1.InnerInner inner = 1;
+    }
+    NewCycle2.Inner1 inner = 1;
+}
+
+message OptionalSelf {
+    optional OptionalSelf self = 1 [(userver.structs.field).indirect = true];
+}
+
+message OptionalDouble {
+    message First {
+        optional Second c = 1 [(userver.structs.field).indirect = true];
+    }
+
+    message Second {
+        optional First c = 1;
+    }
+}
+
+message OptionalTriple {
+    message First {
+        optional Second c = 1;
+    }
+
+    message Second {
+        optional Third c = 1;
+    }
+
+    message Third {
+        optional First c = 1 [(userver.structs.field).indirect = true];
+    }
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/box/options/initialization.proto b/libraries/proto-structs/codegen-tests/proto/box/options/initialization.proto
new file mode 100644
index 000000000000..5b9cd0970c3a
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/box/options/initialization.proto
@@ -0,0 +1,53 @@
+// Fields containing a message that is defined in the same file must be left uninitialized.
+// Otherwise, the compiler suddenly requires definitions of all mentioned forward-declared types:
+//
+// ```cpp
+// struct Foo;
+//
+// struct Bar {
+//     std::vector<Foo> foo;  // ok
+// };
+//
+// struct Baz {
+//     Bar bar{};  // error: std::vector<Foo> needs Foo?!
+// };
+// ```
+//
+// Compare:
+// * https://godbolt.org/z/1796cr4vP
+// * https://godbolt.org/z/fbxc8cz8v
+//
+// Reason for this behavior is that if an initialization is given, then the compiler must immediately check
+// that it is valid, and the constructor of `std::vector` requires that the item type is complete.
+
+syntax = "proto3";
+
+package box.options;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/box/options;boxoptions";
+
+import "userver/structs/annotations.proto";
+
+message DependsOnNotDefinedYet {
+    NotDefinedYet plain_field = 1 [(userver.structs.field).indirect = true];
+    optional NotDefinedYet optional_field = 2 [(userver.structs.field).indirect = true];
+    repeated NotDefinedYet vector_field = 3;
+    map<string, NotDefinedYet> map_field = 4 [(userver.structs.field).indirect = true];
+
+    oneof oneof {
+        NotDefinedYet oneof_field = 5 [(userver.structs.field).indirect = true];
+    }
+}
+
+message IndirectlyDependsOnNotDefinedYet {
+    DependsOnNotDefinedYet plain_field = 1 [(userver.structs.field).indirect = true];
+    optional DependsOnNotDefinedYet optional_field = 2 [(userver.structs.field).indirect = true];
+    repeated DependsOnNotDefinedYet vector_field = 3;
+    map<string, DependsOnNotDefinedYet> map_field = 4 [(userver.structs.field).indirect = true];
+
+    oneof oneof {
+        DependsOnNotDefinedYet oneof_field = 5 [(userver.structs.field).indirect = true];
+    }
+}
+
+message NotDefinedYet {}
diff --git a/libraries/proto-structs/codegen-tests/proto/enums/names.proto b/libraries/proto-structs/codegen-tests/proto/enums/names.proto
new file mode 100644
index 000000000000..3ee691358bf3
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/enums/names.proto
@@ -0,0 +1,51 @@
+syntax = "proto3";
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/enums;enums";
+
+package enums;
+
+// Should be left as-is. Note: unscoped, unprefixed enum values are not recommended.
+enum Unprefixed {
+    UNSPECIFIED = 0;
+    FOO_VAR = 1;
+    BAR_VAR = 2;
+}
+
+// Prefix should be cut when converted to a C++ enum class.
+enum AllowedCuts {
+    ALLOWED_CUTS_UNSPECIFIED = 0;
+    ALLOWED_CUTS_FOO_VAR = 1;
+    ALLOWED_CUTS_DIGITS1 = 2;
+}
+
+enum DisallowedCuts {
+    // Camel-case prefix is not cut away. The proper name should be `DISALLOWED_CUTS_UNSPECIFIED`.
+    DisallowedCuts_UNKNOWN = 0;
+    // Same value name as the enum name.
+    DISALLOWED_CUTS = 1;
+    // `1` is not a valid identifier.
+    DISALLOWED_CUTS1 = 2;
+    // `1` is not a valid identifier.
+    DISALLOWED_CUTS_2 = 3;
+    // Camel-case prefix is not cut away. The naming conventions recommend prefixing with an uppercase enum name.
+    DisallowedCutsCamel = 4;
+}
+
+// This is a common trick that allows to achieve desired scoping for various languages.
+// The message contains nothing except the nested enum. Outer message name should be `<EnumName>Enum`.
+// When converting to a C++ enum class, remove the nested enum.
+message NestedTrickEnum {
+    enum NestedTrick {
+        UNSPECIFIED = 0;
+        FOO_VAR = 1;
+        BAR_VAR = 2;
+    }
+}
+
+enum WithoutPrefix {
+    BarVar = 0;
+    Bar_Foo = 1;
+    Bar_foo1 = 2;
+    Bar_FooQux = 3;
+    Bar_FooQuX1 = 4;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/maps/basic.proto b/libraries/proto-structs/codegen-tests/proto/maps/basic.proto
new file mode 100644
index 000000000000..3bf22012d508
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/maps/basic.proto
@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/maps;maps";
+
+package maps;
+
+message Basic {
+  map<string, int64> string_int = 1;
+  map<string, string> string_string = 2;
+  map<int64, int64> int_int = 3;
+  map<int64, string> int_string = 4;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/not_recommended_field_names/basic.proto b/libraries/proto-structs/codegen-tests/proto/not_recommended_field_names/basic.proto
new file mode 100644
index 000000000000..40dc5fd58073
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/not_recommended_field_names/basic.proto
@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package not_recommended_field_names;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/not_recommended_field_names;not_recommended_field_names";
+
+message Basic {
+    int32 protected = 1;
+    int32 final = 2;
+    int32 void__ = 3;
+    int32 float = 4;
+    int32 typeid = 5;
+    int32 new = 6;
+    int32 double = 7;
+    // Not generated by a plugin.
+    int32 major = 8;
+    int32 minor = 9;
+}
+
+message Upper {
+    int32 XYandexUid = 1;
+    int32 Float = 2;
+    int32 New = 3;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/oneof/basic.proto b/libraries/proto-structs/codegen-tests/proto/oneof/basic.proto
new file mode 100644
index 000000000000..3267d7d289ca
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/oneof/basic.proto
@@ -0,0 +1,45 @@
+syntax = "proto3";
+
+package oneof;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/oneof;oneof";
+
+message Message1 {
+    string field = 1;
+}
+
+enum Enum1 {
+    ENUM1_UNSPECIFIED = 0;
+    ENUM1_FOO = 1;
+}
+
+message Parent {
+    optional string field_before = 1;
+
+    message Message2 {
+        string field = 1;
+    }
+
+    enum Enum2 {
+        ENUM2_UNSPECIFIED = 0;
+        ENUM2_FOO = 1;
+    }
+
+    oneof lowercase {
+        int64 integer = 3;
+        string string = 2;
+        Message1 message1 = 5;
+        Message2 message2 = 6;
+        Enum1 enum1 = 7;
+        Enum2 enum2 = 8;
+    }
+
+    oneof Uppercase {
+        string foo = 9;
+        int64 bar = 10;
+    }
+
+    oneof single_field_oneof {
+        string single = 11;
+    }
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/oneof/custom_oneof_type_name.proto b/libraries/proto-structs/codegen-tests/proto/oneof/custom_oneof_type_name.proto
new file mode 100644
index 000000000000..e416241922fd
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/oneof/custom_oneof_type_name.proto
@@ -0,0 +1,39 @@
+syntax = "proto3";
+
+package oneof;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/oneof;oneof";
+
+import "userver/structs/annotations.proto";
+
+// Demonstrates how to resolve a proto structs naming conflict by manually overriding the generated oneof type name.
+message NameConflict1 {
+  message Nested {
+    // By default, this will generate a type named `FooId` and a field `foo_id`.
+    // Then the type of `simple_id` will be resolved to C++ type of oneof, not to the intended message below.
+    oneof foo_id {
+      // This is a manual work-around to the (hopefully) rare naming conflict.
+      option (userver.structs.oneof).generated_type_name = "FooIdCustom";
+
+      FooId simple_id = 1;
+    }
+  }
+
+  message FooId {}
+}
+
+// Similar to the above except for another naming scheme for the generated type.
+message NameConflict2 {
+  message Nested {
+    // By default, this will generate a type named `TFooId` and a field `FooId`.
+    // Then the type of `simple_id` will be resolved to C++ type of oneof, not to the intended message below.
+    oneof FooId {
+      // This is a manual work-around to the (hopefully) rare naming conflict.
+      option (userver.structs.oneof).generated_type_name = "TFooIdCustom";
+
+      TFooId simple_id = 1;
+    }
+  }
+
+  message TFooId {}
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/oneof/proto2.proto b/libraries/proto-structs/codegen-tests/proto/oneof/proto2.proto
new file mode 100644
index 000000000000..e07b4a4f8152
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/oneof/proto2.proto
@@ -0,0 +1,53 @@
+syntax = "proto2";
+
+package oneof;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/oneof;oneof";
+
+message Proto2 {
+    optional string field_before = 1;
+
+    message Message {
+        required string field = 1;
+    }
+
+    enum Enum {
+        ENUM_UNSPECIFIED = 0;
+        ENUM_FOO = 1;
+    }
+
+    oneof oneof {
+        int64 integer = 3;
+        string string = 2;
+        Message message = 5;
+        Enum enum = 7;
+
+        // https://protobuf.dev/programming-guides/proto2/#groups
+        group Group = 8 {
+            message MessageInGroup {
+                required string foo = 1;
+            }
+
+            enum EnumInGroup {
+                ENUM_IN_GROUP_UNSPECIFIED = 0;
+                ENUM_IN_GROUP_FOO = 1;
+            }
+
+            required int64 x = 1;
+            optional string y = 2;
+
+            oneof group_oneof {
+                Message z = 3;
+                Enum w = 4;
+            }
+        }
+    }
+
+    oneof single_field_oneof {
+        string single = 9;
+    }
+
+    optional Group.MessageInGroup message_from_group = 10;
+    repeated Group.EnumInGroup enum_from_group = 11;
+    optional bool opt_bool = 12;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/simple/base.proto b/libraries/proto-structs/codegen-tests/proto/simple/base.proto
new file mode 100644
index 000000000000..89cb1282169a
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/simple/base.proto
@@ -0,0 +1,59 @@
+syntax = "proto3";
+
+package simple;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/simple;simple";
+
+import "simple/subdirectory/subdirectory.proto";
+import "simple/subdirectory/separate_enum.proto";
+
+message SimpleStruct {
+    int32 some_integer = 1;
+    optional string some_text = 2;
+    bool is_condition = 3;
+
+    oneof something {
+        int64 foo = 4;
+        string bar = 5;
+    };
+
+    repeated bytes some_bytes = 6;
+
+    message NestedStruct {
+        message NestedStruct2 {
+
+            enum InnerEnum1 {
+                FOO_VAL = 0;
+                BAR_VAL = 1;
+            }
+
+            string swag2 = 1;
+            InnerEnum1 swag3 = 2;
+        }
+
+        string swag = 1;
+    }
+
+    enum InnerEnum2 {
+        FOO_VAL = 0;
+        BAR_VAL = 1;
+    }
+
+    InnerEnum2 inner_enum = 7;
+    string digit1u = 8;
+    NestedStruct nested = 9;
+    optional NestedStruct optional_nested = 10;
+}
+
+message SecondStruct {
+    string str = 1;
+
+    simple.subdirectory.SubdirStruct subdir_struct = 2;
+    simple.subdirectory.MyEnum subdir_enum = 3;
+    simple.subdirectory.SeparateEnum separate_enum = 4;
+}
+
+enum GlobalEnum {
+    FOO_VAL = 0;
+    BAR_VAL = 1;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/separate_enum.proto b/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/separate_enum.proto
new file mode 100644
index 000000000000..dab0e85e3617
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/separate_enum.proto
@@ -0,0 +1,10 @@
+syntax = "proto3";
+
+package simple.subdirectory;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/simple/subdirectory;simplesubdirectory";
+
+enum SeparateEnum {
+  ValZero = 0;
+  ValOne = 1;
+}
diff --git a/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/subdirectory.proto b/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/subdirectory.proto
new file mode 100644
index 000000000000..40fff1c5c667
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/proto/simple/subdirectory/subdirectory.proto
@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+package simple.subdirectory;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/codegen-tests/proto/simple/subdirectory;simplesubdirectory";
+
+message SubdirStruct {
+    string name = 1;
+}
+
+enum MyEnum {
+  Zero = 0;
+  One = 1;
+}
diff --git a/libraries/proto-structs/codegen-tests/src/box/autobox/cycles_test.cpp b/libraries/proto-structs/codegen-tests/src/box/autobox/cycles_test.cpp
new file mode 100644
index 000000000000..80c4fbff257c
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/box/autobox/cycles_test.cpp
@@ -0,0 +1,112 @@
+#include <gtest/gtest.h>
+
+#include <fmt/format.h>
+
+#include <box/autobox/cycles.structs.usrv.pb.hpp>
+#include <test_utils/type_assertions.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(AutoboxCycles, Self) {
+    namespace ss = box::autobox::structs;
+    AssertFieldType<decltype(ss::Self::self), utils::Box<ss::Self>>();
+    AssertFieldCount<ss::CycleEnd, 1>();
+}
+
+TEST(AutoboxCycles, CycleLenIsThree) {
+    namespace ss = box::autobox::structs;
+    AssertFieldType<decltype(ss::First::c), utils::Box<ss::Second>>();
+    AssertFieldType<decltype(ss::Second::c), utils::Box<ss::Third>>();
+    AssertFieldType<decltype(ss::Third::c), utils::Box<ss::First>>();
+
+    AssertFieldCount<ss::First, 1>();
+    AssertFieldCount<ss::Second, 1>();
+    AssertFieldCount<ss::Third, 1>();
+}
+
+TEST(AutoboxCycles, box) {
+    namespace ss = box::autobox::structs;
+    AssertFieldType<decltype(ss::CycleStart::cycle), utils::Box<ss::CycleEnd>>();
+    AssertFieldType<decltype(ss::CycleStart::not_boxed), std::vector<ss::CycleEnd>>();
+    AssertFieldType<decltype(ss::CycleEnd::cycle), utils::Box<ss::CycleStart>>();
+
+    AssertFieldCount<ss::CycleEnd, 1>();
+    AssertFieldCount<ss::CycleStart, 2>();
+}
+
+TEST(AutoboxCycles, Main) {
+    namespace ss = box::autobox::structs;
+    AssertFieldType<decltype(ss::Main1::inner), ss::Main1::Inner>();
+    AssertFieldType<decltype(ss::Main1::Inner::cycle), utils::Box<ss::ImBelowMain1>>();
+    AssertFieldType<decltype(ss::IamAboveMain2::cycle), utils::Box<ss::Main2>>();
+    AssertFieldType<decltype(ss::Main2::inner), ss::Main2::Inner>();
+    AssertFieldType<decltype(ss::Main2::Inner::cycle), utils::Box<ss::IamAboveMain2>>();
+    AssertFieldType<decltype(ss::ImBelowMain1::cycle), utils::Box<ss::Main1>>();
+
+    AssertFieldCount<ss::Main1, 1>();
+    AssertFieldCount<ss::Main1::Inner, 1>();
+    AssertFieldCount<ss::IamAboveMain2, 1>();
+    AssertFieldCount<ss::Main2, 1>();
+    AssertFieldCount<ss::Main2::Inner, 1>();
+    AssertFieldCount<ss::ImBelowMain1, 1>();
+}
+
+TEST(AutoboxCycles, NewCycle) {
+    namespace ss = box::autobox::structs;
+    AssertFieldType<decltype(ss::NewCycle::inner), ss::NewCycle::Inner1>();
+    AssertFieldCount<ss::NewCycle, 1>();
+    AssertFieldType<decltype(ss::NewCycle::Inner1::inner), ss::NewCycle::Inner1::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle::Inner1::InnerInner::inner), utils::Box<ss::NewCycle::Inner2Below>>();
+    AssertFieldType<decltype(ss::NewCycle::Inner2Below::i), ss::NewCycle::Inner2Below::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle::Inner2Below::InnerInner::inner), utils::Box<ss::NewCycle::Inner1>>();
+
+    AssertFieldCount<ss::NewCycle::Inner1, 1>();
+    AssertFieldCount<ss::NewCycle::Inner1::InnerInner, 1>();
+    AssertFieldCount<ss::NewCycle::Inner2Below, 1>();
+    AssertFieldCount<ss::NewCycle::Inner2Below::InnerInner, 1>();
+}
+
+TEST(AutoboxCycles, NewCycle2) {
+    namespace ss = box::autobox::structs;
+    AssertFieldType<decltype(ss::NewCycle2::inner), ss::NewCycle2::Inner1>();
+    AssertFieldCount<ss::NewCycle2, 1>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner1::inner), ss::NewCycle2::Inner1::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner1::InnerInner::inner), utils::Box<ss::NewCycle2::Inner2Above>>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner2Above::i), ss::NewCycle2::Inner2Above::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner2Above::InnerInner::inner), utils::Box<ss::NewCycle2::Inner1>>();
+
+    AssertFieldCount<ss::NewCycle2::Inner1, 1>();
+    AssertFieldCount<ss::NewCycle2::Inner1::InnerInner, 1>();
+    AssertFieldCount<ss::NewCycle2::Inner2Above, 1>();
+    AssertFieldCount<ss::NewCycle2::Inner2Above::InnerInner, 1>();
+}
+
+TEST(AutoboxCycles, OptionalSelf) {
+    namespace ss = box::autobox::structs;
+    {
+        // Boost.Pfr refuses to process a struct in which first field is constructible from the same struct.
+        // So we can't use Boost.Pfr to check that `OptionalSelf` has exactly 1 field.
+        const auto [_] = ss::OptionalSelf{};
+    }
+    AssertFieldType<decltype(ss::OptionalSelf::self), std::optional<utils::Box<ss::OptionalSelf>>>();
+}
+
+TEST(AutoboxCycles, OptionalDouble) {
+    namespace ss = box::autobox::structs;
+    AssertFieldCount<ss::OptionalDouble::First, 1>();
+    AssertFieldType<decltype(ss::OptionalDouble::First::c), std::optional<utils::Box<ss::OptionalDouble::Second>>>();
+    AssertFieldCount<ss::OptionalDouble::Second, 1>();
+    AssertFieldType<decltype(ss::OptionalDouble::Second::c), std::optional<utils::Box<ss::OptionalDouble::First>>>();
+}
+
+TEST(AutoboxCycles, OptionalTriple) {
+    namespace ss = box::autobox::structs;
+    AssertFieldCount<ss::OptionalTriple::First, 1>();
+    AssertFieldType<decltype(ss::OptionalTriple::First::c), std::optional<utils::Box<ss::OptionalTriple::Second>>>();
+    AssertFieldCount<ss::OptionalTriple::Second, 1>();
+    AssertFieldType<decltype(ss::OptionalTriple::Second::c), std::optional<utils::Box<ss::OptionalTriple::Third>>>();
+    AssertFieldCount<ss::OptionalTriple::Third, 1>();
+    AssertFieldType<decltype(ss::OptionalTriple::Third::c), std::optional<utils::Box<ss::OptionalTriple::First>>>();
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_nested_test.cpp b/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_nested_test.cpp
new file mode 100644
index 000000000000..ac09a90c3224
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_nested_test.cpp
@@ -0,0 +1,58 @@
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include <userver/utils/box.hpp>
+
+#include <box/autobox/dependency_on_nested.structs.usrv.pb.hpp>
+#include <test_utils/type_assertions.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(BoxDependencyOnNested, NonCyclic) {
+    using Scope = box::autobox::structs::DependencyOnNested;
+    AssertFieldCount<Scope::Foo, 1>();
+    AssertFieldType<decltype(Scope::Foo::field), Scope::Bar::Nested>();
+}
+
+TEST(BoxDependencyOnNested, NonCyclicDoublyNested) {
+    using Scope = box::autobox::structs::DependencyOnNestedNested;
+    AssertFieldCount<Scope::Foo, 1>();
+    AssertFieldType<decltype(Scope::Foo::field), Scope::Bar::Nested::Nested2>();
+}
+
+TEST(BoxDependencyOnNested, RepeatedNonCyclic) {
+    using Scope = box::autobox::structs::RepeatedDependencyOnNested;
+    AssertFieldCount<Scope::Foo, 1>();
+    AssertFieldType<decltype(Scope::Foo::field), std::vector<Scope::Bar::Nested>>();
+}
+
+TEST(BoxDependencyOnNested, Cyclic) {
+    using Scope = box::autobox::structs::CyclicDependencyOnNested;
+
+    AssertFieldCount<Scope::Foo, 1>();
+    AssertFieldType<decltype(Scope::Foo::field), Scope::Bar::Nested>();
+
+    AssertFieldCount<Scope::Bar, 1>();
+    AssertFieldType<decltype(Scope::Bar::field), utils::Box<Scope::Foo>>();
+}
+
+TEST(BoxDependencyOnNested, RepeatedCyclic) {
+    using Scope = box::autobox::structs::RepeatedCyclicDependencyOnNested;
+
+    AssertFieldCount<Scope::Foo, 1>();
+    AssertFieldType<decltype(Scope::Foo::field), std::vector<Scope::Bar::Nested>>();
+
+    AssertFieldCount<Scope::Bar, 1>();
+    AssertFieldType<decltype(Scope::Bar::field), utils::Box<Scope::Foo>>();
+}
+
+TEST(BoxDependencyOnNested, VectorsDoNotCreateCycles) {
+    using Scope = box::autobox::structs::VectorsDoNotCreateCycles;
+
+    AssertFieldCount<Scope::Foo, 1>();
+    AssertFieldType<decltype(Scope::Foo::field), std::vector<Scope::Bar>>();
+
+    AssertFieldCount<Scope::Bar, 1>();
+    AssertFieldType<decltype(Scope::Bar::field), std::vector<Scope::Foo>>();
+}
diff --git a/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_self_test.cpp b/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_self_test.cpp
new file mode 100644
index 000000000000..764718d4a06b
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/box/autobox/dependency_on_self_test.cpp
@@ -0,0 +1,60 @@
+#include <gtest/gtest.h>
+
+#include <optional>
+#include <vector>
+
+#include <userver/utils/box.hpp>
+
+#include <box/autobox/dependency_on_self.structs.usrv.pb.hpp>
+#include <test_utils/type_assertions.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(BoxDependencyOnSelf, Direct) {
+    using Scope = box::autobox::structs::DependencyOnSelfDirect;
+    // Boost.Pfr refuses to process a struct in which first field is constructible from the same struct.
+    // So we can't use Boost.Pfr to check that `Scope` has exactly 1 field.
+    AssertFieldType<decltype(Scope::field), utils::Box<Scope>>();
+}
+
+TEST(BoxDependencyOnSelf, Nested) {
+    using Scope = box::autobox::structs::DependencyOnSelfNested;
+    AssertFieldCount<Scope::Nested, 1>();
+    AssertFieldType<decltype(Scope::Nested::field), utils::Box<Scope>>();
+}
+
+TEST(BoxDependencyOnSelf, Optional) {
+    using Scope = box::autobox::structs::DependencyOnSelfOptional;
+    {
+        // Boost.Pfr refuses to process a struct in which first field is constructible from the same struct.
+        // So we can't use Boost.Pfr to check that `Scope` has exactly 1 field.
+        const auto [_] = Scope{};
+    }
+    AssertFieldType<decltype(Scope::field), std::optional<utils::Box<Scope>>>();
+}
+
+TEST(BoxDependencyOnSelf, Repeated) {
+    using Scope = box::autobox::structs::DependencyOnSelfRepeated;
+    AssertFieldCount<Scope, 1>();
+    AssertFieldType<decltype(Scope::field), std::vector<Scope>>();
+}
+
+TEST(BoxDependencyOnSelf, DependencyWithin) {
+    using Scope = box::autobox::structs::DependencyWithinSelf;
+    AssertFieldCount<Scope::B, 1>();
+    AssertFieldType<decltype(Scope::B::field), Scope::A>();
+}
+
+TEST(BoxDependencyOnSelf, DependencyOnSelfCollateral) {
+    using Scope = box::autobox::structs::DependencyOnSelfCollateral;
+
+    {
+        // Boost.Pfr refuses to process a struct in which first field is constructible from the same struct.
+        // So we can't use Boost.Pfr to check that `Scope` has exactly 1 field.
+        const auto [_] = Scope{};
+    }
+    AssertFieldType<decltype(Scope::field), std::optional<utils::Box<Scope>>>();
+
+    AssertFieldCount<Scope::B, 1>();
+    AssertFieldType<decltype(Scope::B::field), Scope::A>();
+}
diff --git a/libraries/proto-structs/codegen-tests/src/box/autobox/unbreakable_cycle_test.cpp b/libraries/proto-structs/codegen-tests/src/box/autobox/unbreakable_cycle_test.cpp
new file mode 100644
index 000000000000..5e1e4c0cf3bb
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/box/autobox/unbreakable_cycle_test.cpp
@@ -0,0 +1,24 @@
+#include <gtest/gtest.h>
+
+#include <concepts>
+
+#include <fmt/format.h>
+#include <boost/pfr.hpp>
+
+#include <userver/proto-structs/unbreakable_dependency_cycle.hpp>
+
+#include <box/autobox/unbreakable_cycle.structs.usrv.pb.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(AutoboxUnbreakableCycle, SimpleCycle) {
+    namespace ss = box::autobox::structs;
+
+    static_assert(boost::pfr::tuple_size<ss::UnbreakableCycle::A>() == 1);
+    static_assert(std::same_as<decltype(ss::UnbreakableCycle::A::b), proto_structs::UnbreakableDependencyCycle>);
+
+    static_assert(boost::pfr::tuple_size<ss::UnbreakableCycle::B>() == 1);
+    static_assert(std::same_as<decltype(ss::UnbreakableCycle::B::a), proto_structs::UnbreakableDependencyCycle>);
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/box/options/cycles_test.cpp b/libraries/proto-structs/codegen-tests/src/box/options/cycles_test.cpp
new file mode 100644
index 000000000000..11609c03e9de
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/box/options/cycles_test.cpp
@@ -0,0 +1,119 @@
+#include <gtest/gtest.h>
+
+#include <fmt/format.h>
+
+#include <box/options/cycles.structs.usrv.pb.hpp>
+#include <test_utils/type_assertions.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(OptionsCycles, Self) {
+    namespace ss = box::options::structs;
+    AssertFieldType<decltype(ss::Self::self), utils::Box<ss::Self>>();
+    AssertFieldCount<ss::CycleEnd, 1>();
+}
+
+TEST(OptionsCycles, MyMap) {
+    namespace ss = box::options::structs;
+
+    AssertFieldType<decltype(ss::MyMap::self), utils::Box<::proto_structs::HashMap<std::string, std::string>>>();
+
+    AssertFieldCount<ss::MyMap, 1>();
+}
+
+TEST(OptionsCycles, CycleLenIsThree) {
+    namespace ss = box::options::structs;
+    AssertFieldType<decltype(ss::First::c), ss::Second>();
+    AssertFieldType<decltype(ss::Second::c), ss::Third>();
+    AssertFieldType<decltype(ss::Third::c), utils::Box<ss::First>>();
+
+    AssertFieldCount<ss::First, 1>();
+    AssertFieldCount<ss::Second, 1>();
+    AssertFieldCount<ss::Third, 1>();
+}
+
+TEST(OptionsCycles, box) {
+    namespace ss = box::options::structs;
+    AssertFieldType<decltype(ss::CycleStart::cycle), utils::Box<ss::CycleEnd>>();
+    AssertFieldType<decltype(ss::CycleStart::not_boxed), std::vector<ss::CycleEnd>>();
+    AssertFieldType<decltype(ss::CycleEnd::cycle), ss::CycleStart>();
+
+    AssertFieldCount<ss::CycleEnd, 1>();
+    AssertFieldCount<ss::CycleStart, 2>();
+}
+
+TEST(OptionsCycles, Main) {
+    namespace ss = box::options::structs;
+    AssertFieldType<decltype(ss::Main1::inner), ss::Main1::Inner>();
+    AssertFieldType<decltype(ss::Main1::Inner::cycle), utils::Box<ss::ImBelowMain1>>();
+    AssertFieldType<decltype(ss::IamAboveMain2::cycle), ss::Main2>();
+    AssertFieldType<decltype(ss::Main2::inner), ss::Main2::Inner>();
+    AssertFieldType<decltype(ss::Main2::Inner::cycle), utils::Box<ss::IamAboveMain2>>();
+    AssertFieldType<decltype(ss::ImBelowMain1::cycle), ss::Main1>();
+
+    AssertFieldCount<ss::Main1, 1>();
+    AssertFieldCount<ss::Main1::Inner, 1>();
+    AssertFieldCount<ss::IamAboveMain2, 1>();
+    AssertFieldCount<ss::Main2, 1>();
+    AssertFieldCount<ss::Main2::Inner, 1>();
+    AssertFieldCount<ss::ImBelowMain1, 1>();
+}
+
+TEST(OptionsCycles, NewCycle) {
+    namespace ss = box::options::structs;
+    AssertFieldType<decltype(ss::NewCycle::inner), ss::NewCycle::Inner1>();
+    AssertFieldCount<ss::NewCycle, 1>();
+    AssertFieldType<decltype(ss::NewCycle::Inner1::inner), ss::NewCycle::Inner1::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle::Inner1::InnerInner::inner), ss::NewCycle::Inner2Below>();
+    AssertFieldType<decltype(ss::NewCycle::Inner2Below::i), ss::NewCycle::Inner2Below::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle::Inner2Below::InnerInner::inner), utils::Box<ss::NewCycle::Inner1>>();
+
+    AssertFieldCount<ss::NewCycle::Inner1, 1>();
+    AssertFieldCount<ss::NewCycle::Inner1::InnerInner, 1>();
+    AssertFieldCount<ss::NewCycle::Inner2Below, 1>();
+    AssertFieldCount<ss::NewCycle::Inner2Below::InnerInner, 1>();
+}
+
+TEST(OptionsCycles, NewCycle2) {
+    namespace ss = box::options::structs;
+    AssertFieldType<decltype(ss::NewCycle2::inner), ss::NewCycle2::Inner1>();
+    AssertFieldCount<ss::NewCycle2, 1>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner1::inner), ss::NewCycle2::Inner1::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner1::InnerInner::inner), ss::NewCycle2::Inner2Above>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner2Above::i), ss::NewCycle2::Inner2Above::InnerInner>();
+    AssertFieldType<decltype(ss::NewCycle2::Inner2Above::InnerInner::inner), utils::Box<ss::NewCycle2::Inner1>>();
+
+    AssertFieldCount<ss::NewCycle2::Inner1, 1>();
+    AssertFieldCount<ss::NewCycle2::Inner1::InnerInner, 1>();
+    AssertFieldCount<ss::NewCycle2::Inner2Above, 1>();
+    AssertFieldCount<ss::NewCycle2::Inner2Above::InnerInner, 1>();
+}
+
+TEST(OptionsCycles, OptionalSelf) {
+    namespace ss = box::options::structs;
+    // Boost.Pfr actually refuses to process a struct, in which first field is constructible from the same struct.
+#if 0
+        AssertFieldCount<ss::OptionalSelf, 1>();
+#endif
+    AssertFieldType<decltype(ss::OptionalSelf::self), std::optional<utils::Box<ss::OptionalSelf>>>();
+}
+
+TEST(OptionsCycles, OptionalDouble) {
+    namespace ss = box::options::structs;
+    AssertFieldCount<ss::OptionalDouble::First, 1>();
+    AssertFieldType<decltype(ss::OptionalDouble::First::c), std::optional<utils::Box<ss::OptionalDouble::Second>>>();
+    AssertFieldCount<ss::OptionalDouble::Second, 1>();
+    AssertFieldType<decltype(ss::OptionalDouble::Second::c), std::optional<ss::OptionalDouble::First>>();
+}
+
+TEST(OptionsCycles, OptionalTriple) {
+    namespace ss = box::options::structs;
+    AssertFieldCount<ss::OptionalTriple::First, 1>();
+    AssertFieldType<decltype(ss::OptionalTriple::First::c), std::optional<ss::OptionalTriple::Second>>();
+    AssertFieldCount<ss::OptionalTriple::Second, 1>();
+    AssertFieldType<decltype(ss::OptionalTriple::Second::c), std::optional<ss::OptionalTriple::Third>>();
+    AssertFieldCount<ss::OptionalTriple::Third, 1>();
+    AssertFieldType<decltype(ss::OptionalTriple::Third::c), std::optional<utils::Box<ss::OptionalTriple::First>>>();
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/box/options/initialization_test.cpp b/libraries/proto-structs/codegen-tests/src/box/options/initialization_test.cpp
new file mode 100644
index 000000000000..74d78301face
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/box/options/initialization_test.cpp
@@ -0,0 +1,64 @@
+#include <gtest/gtest.h>
+
+#include <concepts>
+#include <optional>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include <userver/proto-structs/convert.hpp>
+#include <userver/proto-structs/hash_map.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+#include <userver/utils/box.hpp>
+
+#include <box/options/initialization.pb.h>
+#include <box/options/initialization.structs.usrv.pb.hpp>
+#include <test_utils/type_assertions.hpp>
+
+namespace structs = box::options::structs;
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(BoxInitialization, NotDefinedYet) { AssertFieldCount<structs::NotDefinedYet, 0>(); }
+
+namespace {
+
+template <typename FieldType, typename MessageType>
+void CheckDependsOnNotDefinedYet() {
+    AssertFieldCount<MessageType, 5>();
+    AssertFieldType<decltype(MessageType::plain_field), utils::Box<FieldType>>();
+    AssertFieldType<decltype(MessageType::optional_field), std::optional<utils::Box<FieldType>>>();
+    AssertFieldType<decltype(MessageType::vector_field), std::vector<FieldType>>();
+    AssertFieldType<decltype(MessageType::map_field), utils::Box<proto_structs::HashMap<std::string, FieldType>>>();
+    AssertFieldType<decltype(MessageType::oneof), typename MessageType::Oneof>();
+
+    static_assert(std::same_as<
+                  proto_structs::OneofAlternativeType<0, typename MessageType::Oneof>,
+                  utils::Box<FieldType>>);
+
+    MessageType test_struct{
+        .plain_field = FieldType{},
+        .optional_field = FieldType{},
+        .vector_field = {FieldType{}},
+        .map_field = {{{"key", FieldType{}}}},
+        .oneof = MessageType::Oneof::make_oneof_field(FieldType{}),
+    };
+
+    auto test_message = proto_structs::StructToMessage(test_struct);
+    auto test_struct_again = proto_structs::MessageToStruct<MessageType>(test_message);
+
+    // TODO re-enable test once operator== is available
+    // ASSERT_EQ(test_struct_again, test_struct);
+}
+
+}  // namespace
+
+TEST(BoxInitialization, DependsOnNotDefinedYet) {
+    CheckDependsOnNotDefinedYet<structs::NotDefinedYet, structs::DependsOnNotDefinedYet>();
+}
+
+TEST(BoxInitialization, IndirectlyDependsOnNotDefinedYet) {
+    CheckDependsOnNotDefinedYet<structs::DependsOnNotDefinedYet, structs::IndirectlyDependsOnNotDefinedYet>();
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/enums/names_test.cpp b/libraries/proto-structs/codegen-tests/src/enums/names_test.cpp
new file mode 100644
index 000000000000..44bf651dc794
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/enums/names_test.cpp
@@ -0,0 +1,48 @@
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include <enums/names.structs.usrv.pb.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(EnumNames, Unprefixed) {
+    using Enum = enums::structs::Unprefixed;
+    static_assert(std::is_enum_v<Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kFooVar), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kBarVar), Enum>);
+}
+
+TEST(EnumNames, AllowedCuts) {
+    using Enum = enums::structs::AllowedCuts;
+    static_assert(std::is_enum_v<Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kFooVar), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kDigits1), Enum>);
+}
+
+TEST(EnumNames, DisallowedCuts) {
+    using Enum = enums::structs::DisallowedCuts;
+    static_assert(std::is_enum_v<Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kDisallowedCutsUnknown), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kDisallowedCuts), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kDisallowedCuts1), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kDisallowedCuts2), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kDisallowedCutsCamel), Enum>);
+}
+
+TEST(EnumNames, NestedTrick) {
+    using Enum = enums::structs::NestedTrickEnum;
+    static_assert(std::is_enum_v<Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kFooVar), Enum>);
+}
+
+TEST(EnumNames, WithoutPrefix) {
+    using Enum = enums::structs::WithoutPrefix;
+    static_assert(std::is_same_v<decltype(Enum::kBarVar), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kBarFoo), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kBarFoo1), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kBarFooQux), Enum>);
+    static_assert(std::is_same_v<decltype(Enum::kBarFooQuX1), Enum>);
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/maps/basic_test.cpp b/libraries/proto-structs/codegen-tests/src/maps/basic_test.cpp
new file mode 100644
index 000000000000..6e06d27d0746
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/maps/basic_test.cpp
@@ -0,0 +1,53 @@
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include <maps/basic.pb.h>
+#include <maps/basic.structs.usrv.pb.hpp>
+
+#include <userver/proto-structs/convert.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(MapsBasic, FundamentalTypes) {
+    using Struct = maps::structs::Basic;
+    static_assert(std::is_same_v<decltype(Struct::string_int), proto_structs::HashMap<std::string, std::int64_t>>);
+    static_assert(std::is_same_v<decltype(Struct::string_string), proto_structs::HashMap<std::string, std::string>>);
+    static_assert(std::is_same_v<decltype(Struct::int_int), proto_structs::HashMap<std::int64_t, std::int64_t>>);
+    static_assert(std::is_same_v<decltype(Struct::int_string), proto_structs::HashMap<std::int64_t, std::string>>);
+
+    Struct s{};
+    s.int_int = {{1, 2}, {3, 4}};
+    s.int_string = {{1, "2"}, {3, "4"}};
+    s.string_int = {{"1", 2}, {"3", 4}};
+    s.string_string = {{"1", "2"}, {"3", "4"}};
+
+    Struct::ProtobufMessage vanilla{};
+    proto_structs::StructToMessage(std::move(s), vanilla);
+    {
+        auto map = vanilla.int_int();
+        ASSERT_EQ(map.size(), 2u);
+        ASSERT_EQ(map.at(1), 2);
+        ASSERT_EQ(map.at(3), 4);
+    }
+    {
+        auto map = vanilla.int_string();
+        ASSERT_EQ(map.size(), 2u);
+        ASSERT_EQ(map.at(1), "2");
+        ASSERT_EQ(map.at(3), "4");
+    }
+    {
+        auto map = vanilla.string_int();
+        ASSERT_EQ(map.size(), 2u);
+        ASSERT_EQ(map.at("1"), 2);
+        ASSERT_EQ(map.at("3"), 4);
+    }
+    {
+        auto map = vanilla.string_string();
+        ASSERT_EQ(map.size(), 2u);
+        ASSERT_EQ(map.at("1"), "2");
+        ASSERT_EQ(map.at("3"), "4");
+    }
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/not_recommended_field_names/basic_test.cpp b/libraries/proto-structs/codegen-tests/src/not_recommended_field_names/basic_test.cpp
new file mode 100644
index 000000000000..8e2ec3445249
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/not_recommended_field_names/basic_test.cpp
@@ -0,0 +1,51 @@
+#include <gtest/gtest.h>
+
+#include <not_recommended_field_names/basic.pb.h>
+#include <not_recommended_field_names/basic.structs.usrv.pb.hpp>
+
+#include <userver/proto-structs/convert.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(NotRecommendedFieldNameBasic, Basic) {
+    using Struct = not_recommended_field_names::structs::Basic;
+    Struct s{};
+
+    s.protected_ = 0;
+    s.final_ = 1;
+    s.void__ = 2;
+    s.float_ = 3;
+    s.typeid_ = 4;
+    s.new_ = 5;
+    s.double_ = 6;
+
+    Struct::ProtobufMessage vanilla{};
+    proto_structs::StructToMessage(std::move(s), vanilla);
+
+    ASSERT_EQ(vanilla.protected_(), 0);
+    ASSERT_EQ(vanilla.final(), 1);
+    ASSERT_EQ(vanilla.void__(), 2);
+    ASSERT_EQ(vanilla.float_(), 3);
+    ASSERT_EQ(vanilla.typeid_(), 4);
+    ASSERT_EQ(vanilla.new_(), 5);
+    ASSERT_EQ(vanilla.double_(), 6);
+    // Not generated by a plagin.
+    ASSERT_EQ(vanilla.minor(), 0);
+    ASSERT_EQ(vanilla.major(), 0);
+}
+
+TEST(NotRecommendedFieldNameBasic, Upper) {
+    using Struct = not_recommended_field_names::structs::Upper;
+    Struct s{};
+    s.XYandexUid = 1;
+    s.Float = 2;
+    s.New = 3;
+
+    Struct::ProtobufMessage vanilla{};
+    proto_structs::StructToMessage(std::move(s), vanilla);
+    ASSERT_EQ(vanilla.xyandexuid(), 1);
+    ASSERT_EQ(vanilla.float_(), 2);
+    ASSERT_EQ(vanilla.new_(), 3);
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/oneof/basic_test.cpp b/libraries/proto-structs/codegen-tests/src/oneof/basic_test.cpp
new file mode 100644
index 000000000000..fbc81ff8bca2
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/oneof/basic_test.cpp
@@ -0,0 +1,88 @@
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include <oneof/basic.structs.usrv.pb.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(OneofBasic, LowercaseEmpty) {
+    oneof::structs::Parent message;
+    static_assert(std::is_same_v<decltype(message.lowercase), oneof::structs::Parent::Lowercase>);
+
+    EXPECT_FALSE(message.lowercase.has_integer());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found = message.lowercase.integer(), proto_structs::OneofAccessError);
+}
+
+TEST(OneofBasic, LowercaseFundamentalTypes) {
+    oneof::structs::Parent message;
+
+    message.lowercase.set_integer(10);
+    EXPECT_TRUE(message.lowercase.has_integer());
+    EXPECT_EQ(message.lowercase.integer(), 10);
+    EXPECT_FALSE(message.lowercase.has_string());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found1 = message.lowercase.string(), proto_structs::OneofAccessError);
+
+    message.lowercase.set_string("text");
+    EXPECT_TRUE(message.lowercase.has_string());
+    EXPECT_EQ(message.lowercase.string(), "text");
+    EXPECT_FALSE(message.lowercase.has_integer());
+    EXPECT_THROW(
+        [[maybe_unused]] const auto& not_found2 = message.lowercase.integer(), proto_structs::OneofAccessError
+    );
+}
+
+TEST(OneofBasic, LowercaseMessage) {
+    oneof::structs::Parent message;
+
+    message.lowercase.set_message1(oneof::structs::Message1{.field = "text"});
+    EXPECT_TRUE(message.lowercase.has_message1());
+    EXPECT_EQ(message.lowercase.message1().field, "text");
+
+    message.lowercase.set_message2({.field = "text"});
+    EXPECT_TRUE(message.lowercase.has_message2());
+    EXPECT_EQ(message.lowercase.message2().field, "text");
+}
+
+TEST(OneofBasic, LowercaseEnum) {
+    oneof::structs::Parent message;
+
+    message.lowercase.set_enum1(oneof::structs::Enum1::kFoo);
+    EXPECT_TRUE(message.lowercase.has_enum1());
+    EXPECT_EQ(message.lowercase.enum1(), oneof::structs::Enum1::kFoo);
+
+    message.lowercase.set_enum2(oneof::structs::Parent::Enum2::kFoo);
+    EXPECT_TRUE(message.lowercase.has_enum2());
+    EXPECT_EQ(message.lowercase.enum2(), oneof::structs::Parent::Enum2::kFoo);
+}
+
+TEST(OneofBasic, Uppercase) {
+    oneof::structs::Parent message;
+    static_assert(std::is_same_v<decltype(message.Uppercase), oneof::structs::Parent::TUppercase>);
+
+    message.Uppercase.set_foo("text");
+    EXPECT_TRUE(message.Uppercase.has_foo());
+    EXPECT_EQ(message.Uppercase.foo(), "text");
+
+    message.Uppercase.set_bar(10);
+    EXPECT_TRUE(message.Uppercase.has_bar());
+    EXPECT_EQ(message.Uppercase.bar(), 10);
+}
+
+TEST(OneofBasic, SingleFieldOneof) {
+    oneof::structs::Parent message;
+    static_assert(std::is_same_v<decltype(message.single_field_oneof), oneof::structs::Parent::SingleFieldOneof>);
+
+    EXPECT_FALSE(message.single_field_oneof.has_single());
+
+    message.single_field_oneof.set_single("text");
+    EXPECT_TRUE(message.single_field_oneof.has_single());
+    EXPECT_EQ(message.single_field_oneof.single(), "text");
+}
+
+TEST(OneofBasic, SyntheticOneofIsIgnored) {
+    [[maybe_unused]] oneof::structs::Parent message;
+    static_assert(std::is_same_v<decltype(message.field_before), std::optional<std::string>>);
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/oneof/custom_oneof_type_name_test.cpp b/libraries/proto-structs/codegen-tests/src/oneof/custom_oneof_type_name_test.cpp
new file mode 100644
index 000000000000..384372ab7810
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/oneof/custom_oneof_type_name_test.cpp
@@ -0,0 +1,30 @@
+#include <gtest/gtest.h>
+
+#include <concepts>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+#include <oneof/custom_oneof_type_name.structs.usrv.pb.hpp>
+#include <test_utils/type_assertions.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(CustomOneofTypeName, Conflict1) {
+    using Scope = oneof::structs::NameConflict1;
+    AssertFieldCount<Scope::Nested, 1>();
+    // `FooIdCustom` type name was set by `option (userver.structs.oneof).generated_type_name`.
+    // Without the option, it would be called `FooId`, and there would be a naming conflict.
+    AssertFieldType<decltype(Scope::Nested::foo_id), Scope::Nested::FooIdCustom>();
+    static_assert(std::same_as<proto_structs::OneofAlternativeType<0, Scope::Nested::FooIdCustom>, Scope::FooId>);
+}
+
+TEST(CustomOneofTypeName, Conflict2) {
+    using Scope = oneof::structs::NameConflict2;
+    AssertFieldCount<Scope::Nested, 1>();
+    // `TFooIdCustom` type name was set by `option (userver.structs.oneof).generated_type_name`.
+    // Without the option, it would be called `TFooId`, and there would be a naming conflict.
+    AssertFieldType<decltype(Scope::Nested::FooId), Scope::Nested::TFooIdCustom>();
+    static_assert(std::same_as<proto_structs::OneofAlternativeType<0, Scope::Nested::TFooIdCustom>, Scope::TFooId>);
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/oneof/proto2_test.cpp b/libraries/proto-structs/codegen-tests/src/oneof/proto2_test.cpp
new file mode 100644
index 000000000000..a0f184540ebf
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/oneof/proto2_test.cpp
@@ -0,0 +1,116 @@
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include <oneof/proto2.structs.usrv.pb.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(OneofProto2, OneofEmpty) {
+    oneof::structs::Proto2 message;
+    static_assert(std::is_same_v<decltype(message.oneof), oneof::structs::Proto2::Oneof>);
+
+    EXPECT_FALSE(message.oneof.has_integer());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found = message.oneof.integer(), proto_structs::OneofAccessError);
+}
+
+TEST(OneofProto2, OneofFundamentalTypes) {
+    oneof::structs::Proto2 message;
+
+    message.oneof.set_integer(42);
+    EXPECT_TRUE(message.oneof.has_integer());
+    EXPECT_EQ(message.oneof.integer(), 42);
+    EXPECT_FALSE(message.oneof.has_string());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found1 = message.oneof.string(), proto_structs::OneofAccessError);
+
+    message.oneof.set_string("proto2_text");
+    EXPECT_TRUE(message.oneof.has_string());
+    EXPECT_EQ(message.oneof.string(), "proto2_text");
+    EXPECT_FALSE(message.oneof.has_integer());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found2 = message.oneof.integer(), proto_structs::OneofAccessError);
+}
+
+TEST(OneofProto2, OneofMessage) {
+    oneof::structs::Proto2 message;
+
+    message.oneof.set_message({.field = "message_text"});
+    EXPECT_TRUE(message.oneof.has_message());
+    EXPECT_EQ(message.oneof.message().field, "message_text");
+}
+
+TEST(OneofProto2, OneofEnum) {
+    oneof::structs::Proto2 message;
+
+    message.oneof.set_enum_(oneof::structs::Proto2::Enum::kFoo);
+    EXPECT_TRUE(message.oneof.has_enum_());
+    EXPECT_EQ(message.oneof.enum_(), oneof::structs::Proto2::Enum::kFoo);
+}
+
+TEST(OneofProto2, OneofGroup) {
+    oneof::structs::Proto2 message;
+
+    oneof::structs::Proto2::Group group;
+    group.x = 100;
+    group.y = "group_text";
+    message.oneof.set_group(group);
+
+    EXPECT_TRUE(message.oneof.has_group());
+    EXPECT_EQ(message.oneof.group().x, 100);
+    EXPECT_EQ(message.oneof.group().y, "group_text");
+}
+
+TEST(OneofProto2, GroupOneof) {
+    oneof::structs::Proto2 message;
+
+    oneof::structs::Proto2::Group group;
+    group.x = 100;
+    group.group_oneof.set_z({.field = "nested_message"});
+    message.oneof.set_group(group);
+
+    EXPECT_TRUE(message.oneof.has_group());
+    EXPECT_TRUE(message.oneof.group().group_oneof.has_z());
+    EXPECT_EQ(message.oneof.group().group_oneof.z().field, "nested_message");
+
+    // Change the oneof inside the group
+    message.oneof.mutable_group().group_oneof.set_w(oneof::structs::Proto2::Enum::kFoo);
+    EXPECT_TRUE(message.oneof.mutable_group().group_oneof.has_w());
+    EXPECT_EQ(message.oneof.mutable_group().group_oneof.w(), oneof::structs::Proto2::Enum::kFoo);
+    EXPECT_FALSE(message.oneof.mutable_group().group_oneof.has_z());
+}
+
+TEST(OneofProto2, NestedTypesOutsideGroup) {
+    oneof::structs::Proto2 message;
+
+    // Using MessageInGroup outside the group context
+    message.message_from_group.foo = "foo_value";
+    EXPECT_EQ(message.message_from_group.foo, "foo_value");
+
+    // Using EnumInGroup outside the group context
+    message.enum_from_group.push_back(oneof::structs::Proto2::Group::EnumInGroup::kFoo);
+    EXPECT_EQ(message.enum_from_group.size(), std::size_t{1});
+    EXPECT_EQ(message.enum_from_group[0], oneof::structs::Proto2::Group::EnumInGroup::kFoo);
+}
+
+TEST(OneofProto2, SingleFieldOneof) {
+    oneof::structs::Proto2 message;
+    static_assert(std::is_same_v<decltype(message.single_field_oneof), oneof::structs::Proto2::SingleFieldOneof>);
+
+    EXPECT_FALSE(message.single_field_oneof.has_single());
+
+    message.single_field_oneof.set_single("single_field_text");
+    EXPECT_TRUE(message.single_field_oneof.has_single());
+    EXPECT_EQ(message.single_field_oneof.single(), "single_field_text");
+}
+
+TEST(OneofProto2, OptionalFieldBefore) {
+    oneof::structs::Proto2 message;
+    static_assert(std::is_same_v<decltype(message.field_before), std::optional<std::string>>);
+
+    EXPECT_FALSE(message.field_before.has_value());
+
+    message.field_before = "field_before_value";
+    EXPECT_TRUE(message.field_before.has_value());
+    EXPECT_EQ(*message.field_before, "field_before_value");
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/simple/simple_test.cpp b/libraries/proto-structs/codegen-tests/src/simple/simple_test.cpp
new file mode 100644
index 000000000000..c429d45533f4
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/simple/simple_test.cpp
@@ -0,0 +1,117 @@
+#include <type_traits>
+
+#include <gtest/gtest.h>
+
+#include <userver/proto-structs/convert.hpp>
+
+#include <simple/base.pb.h>
+#include <simple/base.structs.usrv.pb.hpp>
+
+namespace ss = simple::structs;
+
+USERVER_NAMESPACE_BEGIN
+
+TEST(SingleFile, SimpleStruct) {
+    static_assert(std::is_aggregate_v<ss::SimpleStruct>);
+    [[maybe_unused]] ss::SimpleStruct message;
+    message.some_integer = 5;
+    message.some_text = std::optional<std::string>("foo");
+    message.is_condition = true;
+    message.some_bytes = {"foo", "bar"};
+    message.something.set_bar("bar_val");
+    message.inner_enum = ss::SimpleStruct::InnerEnum2::kFooVal;
+    message.nested.swag = "foo";
+    message.optional_nested = std::optional<ss::SimpleStruct::NestedStruct>{{.swag = "foo"}};
+
+    ss::SimpleStruct::ProtobufMessage vanilla;
+
+    ::proto_structs::StructToMessage(std::move(message), vanilla);
+
+    EXPECT_EQ(vanilla.some_integer(), 5);
+    EXPECT_EQ(vanilla.some_text(), "foo");
+    EXPECT_EQ(vanilla.is_condition(), true);
+    EXPECT_EQ(vanilla.some_bytes().Get(0), "foo");
+    EXPECT_EQ(vanilla.some_bytes().Get(1), "bar");
+    EXPECT_EQ(vanilla.bar(), "bar_val");
+    EXPECT_EQ(vanilla.inner_enum(), ss::SimpleStruct::ProtobufMessage::FOO_VAL);
+    EXPECT_EQ(vanilla.nested().swag(), "foo");
+    EXPECT_EQ(vanilla.optional_nested().swag(), "foo");
+
+    ss::SimpleStruct to;
+    ::proto_structs::MessageToStruct(vanilla, to);
+
+    ASSERT_EQ(to.some_integer, 5);
+    ASSERT_EQ(to.some_text, std::optional<std::string>("foo"));
+    ASSERT_TRUE(to.is_condition);
+    std::vector<std::string> exp = {"foo", "bar"};
+    ASSERT_EQ(to.some_bytes, exp);
+    ASSERT_EQ(to.something.bar(), "bar_val");
+    ASSERT_THROW([[maybe_unused]] auto foo = to.something.foo(), proto_structs::OneofAccessError);
+}
+
+TEST(SingleFile, NestedStruct) {
+    static_assert(std::is_aggregate_v<ss::SimpleStruct::NestedStruct>);
+    [[maybe_unused]] ss::SimpleStruct::NestedStruct nested;
+    nested.swag = "foo";
+
+    static_assert(std::is_aggregate_v<ss::SimpleStruct::NestedStruct::NestedStruct2>);
+    [[maybe_unused]] ss::SimpleStruct::NestedStruct::NestedStruct2 nested2;
+    nested2.swag2 = "bar";
+}
+
+TEST(SingleFile, InnerEnum1) {
+    static_assert(std::is_enum_v<ss::SimpleStruct::NestedStruct::NestedStruct2::InnerEnum1>);
+    [[maybe_unused]] const auto inner_enum1 = ss::SimpleStruct::NestedStruct::NestedStruct2::InnerEnum1::kBarVal;
+}
+
+TEST(SingleFile, InnerEnum2) {
+    static_assert(std::is_enum_v<ss::SimpleStruct::InnerEnum2>);
+    [[maybe_unused]] const auto inner_enum2 = ss::SimpleStruct::InnerEnum2::kFooVal;
+}
+
+TEST(SingleFile, SecondStruct) {
+    static_assert(std::is_aggregate_v<ss::SecondStruct>);
+    [[maybe_unused]] ss::SecondStruct message;
+}
+
+TEST(SingleFile, GlobalEnum) {
+    static_assert(std::is_enum_v<ss::GlobalEnum>);
+    [[maybe_unused]] ss::GlobalEnum message{};
+}
+
+TEST(Oneof, Empty) {
+    const ss::SimpleStruct::Something none;
+    EXPECT_FALSE(none);
+    EXPECT_FALSE(none.has_foo());
+    EXPECT_FALSE(none.has_bar());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found1 = none.foo(), proto_structs::OneofAccessError);
+    EXPECT_THROW([[maybe_unused]] const auto& not_found2 = none.bar(), proto_structs::OneofAccessError);
+}
+
+TEST(Oneof, MakeFoo) {
+    ss::SimpleStruct::Something foo;
+    foo.set_foo(42);
+    EXPECT_TRUE(foo);
+    EXPECT_TRUE(foo.has_foo());
+    EXPECT_NO_THROW(EXPECT_EQ(foo.foo(), 42));
+    EXPECT_FALSE(foo.has_bar());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found = foo.bar(), proto_structs::OneofAccessError);
+}
+
+TEST(Oneof, MakeBar) {
+    ss::SimpleStruct::Something bar;
+    bar.set_bar("bar");
+    EXPECT_TRUE(bar);
+    EXPECT_FALSE(bar.has_foo());
+    EXPECT_THROW([[maybe_unused]] const auto& not_found = bar.foo(), proto_structs::OneofAccessError);
+    EXPECT_TRUE(bar.has_bar());
+    EXPECT_NO_THROW(EXPECT_EQ(bar.bar(), "bar"));
+}
+
+TEST(Oneof, OneofInStruct) {
+    [[maybe_unused]] ss::SimpleStruct message;
+    message.something.set_bar("bar");
+    EXPECT_EQ(message.something.bar(), "bar");
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/codegen-tests/src/test_utils/type_assertions.hpp b/libraries/proto-structs/codegen-tests/src/test_utils/type_assertions.hpp
new file mode 100644
index 000000000000..8b3e85c680f9
--- /dev/null
+++ b/libraries/proto-structs/codegen-tests/src/test_utils/type_assertions.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+#include <boost/pfr/core.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace impl {
+
+template <typename T>
+constexpr std::size_t GetFieldCount() {
+    return boost::pfr::tuple_size<T>::value;
+}
+
+}  // namespace impl
+
+template <typename Field, typename Expected>
+constexpr void AssertFieldType() {
+    static_assert(std::is_same_v<Field, Expected>, "Must be equal");
+}
+
+template <typename T, std::size_t Count>
+constexpr void AssertFieldCount() {
+    static_assert(impl::GetFieldCount<T>() == Count);
+}
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/any.hpp b/libraries/proto-structs/include/userver/proto-structs/any.hpp
new file mode 100644
index 000000000000..a26ad4a3ac8d
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/any.hpp
@@ -0,0 +1,124 @@
+#pragma once
+
+/// @file userver/proto-structs/any.hpp
+/// @brief Class to access `google.protobuf.Any` stored message as a struct
+
+#include <type_traits>
+#include <utility>
+
+#include <google/protobuf/any.pb.h>
+
+#include <userver/proto-structs/convert.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+/// @brief Wrapper for `google.protobuf.Any` which provides interface to access stored message as compatible struct
+class Any final {
+public:
+    using ProtobufMessage = ::google::protobuf::Any;
+
+    /// @brief Creates empty `Any`.
+    Any() noexcept = default;
+
+    /// @brief Creates wrapper initializing its underlying storage with @a proto_any
+    Any(google::protobuf::Any proto_any) : storage_(std::move(proto_any)) {}
+
+    /// @brief Creates `Any` holding @a obj
+    /// @tparam TStruct proto struct type
+    /// @throws WriteError if conversion of @a obj to its compatible message has failed
+    /// @throws AnyPackError if compatible protobuf message can not be packed to `google.protobuf.Any`
+    template <typename TStruct>
+    requires(!std::is_same_v<std::remove_cvref_t<TStruct>, ::google::protobuf::Any>) &&
+            (!std::is_same_v<std::remove_cvref_t<TStruct>, Any>) && traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+    Any(TStruct&& obj) {
+        Pack(std::forward<TStruct>(obj));
+    }
+
+    /// @brief Packs @a obj in `Any`
+    /// @tparam TStruct proto struct type
+    /// @throws WriteError if conversion of @a obj to its compatible message has failed
+    /// @throws AnyPackError if compatible protobuf message can not be packed to `google.protobuf.Any`
+    template <typename TStruct>
+    requires(!std::is_same_v<std::remove_cvref_t<TStruct>, ::google::protobuf::Any>) &&
+            (!std::is_same_v<std::remove_cvref_t<TStruct>, Any>) && traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+    Any& operator=(TStruct&& obj) {
+        Pack(std::forward<TStruct>(obj));
+        return *this;
+    }
+
+    /// @brief Returns `true` if `Any` contains `TStruct`
+    /// @tparam TStruct proto struct type
+    template <traits::ProtoStruct TStruct>
+    bool Is() const noexcept {
+        using Message = traits::CompatibleMessageType<TStruct>;
+        return storage_.Is<Message>();
+    }
+
+    /// @brief Returns `true` if underlying `google.protobuf.Any` contains `TMessage`
+    /// @tparam TMessage protobuf message type
+    template <traits::ProtoMessage TMessage>
+    bool Is() const noexcept {
+        return storage_.Is<std::remove_cv_t<TMessage>>();
+    }
+
+    /// @brief Unpacks `Any` to `TStruct` struct
+    /// @tparam TStruct proto struct type
+    /// @throws AnyUnpackError if underlying `google.protobuf.Any` does not contain message compatible to `TStruct`
+    /// @throws ReadError if conversion of unpacked protobuf message to proto struct has failed
+    template <traits::ProtoStruct TStruct>
+    TStruct Unpack() {
+        using Message = traits::CompatibleMessageType<TStruct>;
+        return MessageToStruct<TStruct>(Unpack<Message>());
+    }
+
+    /// @brief Unpacks underlying `google.protobuf.Any` to `TMessage` message
+    /// @tparam TMessage protobuf message type
+    /// @throws AnyUnpackError if underlying `google.protobuf.Any` does not contain `TMessage` type message
+    template <traits::ProtoMessage TMessage>
+    TMessage Unpack() {
+        TMessage msg;
+
+        if (!storage_.UnpackTo(&msg)) {
+            throw AnyUnpackError(TMessage::descriptor()->full_name());
+        }
+
+        return msg;
+    }
+
+    /// @brief Packs @a obj to `Any`
+    /// @tparam TStruct proto struct type
+    /// @throws WriteError if conversion of @a obj to its compatible message has failed
+    /// @throws AnyPackError if packing of compatible protobuf message to `google.protobuf.Any` has failed
+    template <typename TStruct>
+    requires traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+    void Pack(TStruct&& obj) {
+        using Message = traits::CompatibleMessageType<std::remove_cvref_t<TStruct>>;
+        Pack<Message>(StructToMessage(std::forward<TStruct>(obj)));
+    }
+
+    /// @brief Packs @a message to underlying `google.protobuf.Any`
+    /// @tparam TMessage protobuf message type
+    /// @throws AnyPackError if packing of protobuf message to `google.protobuf.Any` has failed
+    template <traits::ProtoMessage TMessage>
+    void Pack(const TMessage& message) {
+        if (!storage_.PackFrom(message)) {
+            throw AnyUnpackError(TMessage::descriptor()->full_name());
+        }
+    }
+
+    /// @brief Returns underlying `google.protobuf.Any`
+    const ::google::protobuf::Any& GetProtobufAny() const& noexcept { return storage_; }
+
+    /// @brief Returns underlying `google.protobuf.Any`
+    ::google::protobuf::Any&& GetProtobufAny() && noexcept { return std::move(storage_); }
+
+private:
+    ::google::protobuf::Any storage_;
+};
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/convert.hpp b/libraries/proto-structs/include/userver/proto-structs/convert.hpp
new file mode 100644
index 000000000000..711f69c73a05
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/convert.hpp
@@ -0,0 +1,98 @@
+#pragma once
+
+/// @file userver/proto-structs/convert.hpp
+/// @brief Functions for protobuf message to/from struct conversion
+///
+/// Conversion functions rely on user-defined functions with the following signatures:
+/// 1. `StructType ReadProtoStruct(proto_structs::io::ReadContext&,
+///                                proto_structs::io::To<StructType>,
+///                                const MessageType&)`
+///
+/// 2. `void WriteProtoStruct(proto_structs::io::WriteContext&,
+///                           const StructType&,
+///                           MessageType&)`
+///
+/// This functions should be foundable by ADL lookup (just place them in the namespace where `StructType` is defined).
+///
+/// It is recommended to define `WriteProtoStruct` function as template with a `StructType` parameter and use universal
+/// reference `StructType&&` as a second parameter to enable perfect forwarding for conversions.
+
+#include <type_traits>
+#include <utility>
+
+#include <userver/proto-structs/io/context.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+/// @brief Converts protobuf message @a msg to proto struct @a obj
+/// @tparam TMessage protobuf message type
+/// @tparam TStruct proto struct type
+/// @throws ReadError if conversion has failed
+/// @warning If function throws an exception, @a obj is left in a valid but unspecified state
+template <traits::ProtoMessage TMessage, traits::ProtoStruct TStruct>
+void MessageToStruct(const TMessage& msg, TStruct& obj) {
+    io::ReadContext ctx(*msg.GetDescriptor());
+
+    try {
+        obj = ReadProtoStruct(ctx, io::To<std::remove_cv_t<TStruct>>{}, msg);
+    } catch (const ReadError&) {
+        // simply re-throw proper errors
+        throw;
+    } catch (const std::exception& e) {
+        // some user-defined `ReadProtoStruct` threw an exception instead of adding an error to context,
+        // adding it manually an re-throwing as a proper exception type
+        ctx.AddError(e.what());
+    }
+}
+
+/// @brief Converts protobuf message @a msg to specified proto struct type
+/// @tparam TStruct proto struct type
+/// @tparam TMessage protobuf message type
+/// @throws ReadError if conversion has failed
+template <traits::ProtoStruct TStruct, traits::ProtoMessage TMessage>
+[[nodiscard]] TStruct MessageToStruct(const TMessage& msg) {
+    TStruct obj;
+    MessageToStruct(msg, obj);
+    return obj;
+}
+
+/// @brief Converts proto struct @a obj to protobuf message @a msg
+/// @tparam TStruct proto struct type
+/// @tparam TMessage protobuf message type
+/// @throws WriteError if conversion has failed
+/// @warning If function throws an exception, @a msg is left in a valid but unspecified state
+template <typename TStruct, traits::ProtoMessage TMessage>
+requires traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+void StructToMessage(TStruct&& obj, TMessage& msg) {
+    io::WriteContext ctx(*msg.GetDescriptor());
+
+    try {
+        WriteProtoStruct(ctx, std::forward<TStruct>(obj), msg);
+    } catch (const WriteError&) {
+        // simply re-throw proper errors
+        throw;
+    } catch (const std::exception& e) {
+        // some user-defined `WriteProtoStruct` threw an exception instead of adding an error to context,
+        // adding it manually an re-throwing as a proper exception type
+        ctx.AddError(e.what());
+    }
+}
+
+/// @brief Converts proto struct @a obj to it's compatible protobuf message type
+/// @tparam TStruct proto struct type
+/// @throws WriteError if conversion has failed
+template <typename TStruct>
+requires traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+[[nodiscard]] traits::CompatibleMessageType<std::remove_cvref_t<TStruct>> StructToMessage(TStruct&& obj) {
+    using Message = traits::CompatibleMessageType<std::remove_cvref_t<TStruct>>;
+    Message msg;
+    StructToMessage(std::forward<TStruct>(obj), msg);
+    return msg;
+}
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/exceptions.hpp b/libraries/proto-structs/include/userver/proto-structs/exceptions.hpp
new file mode 100644
index 000000000000..8a18c373a1f3
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/exceptions.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+/// @file userver/proto-structs/exceptions.hpp
+/// @brief Exceptions thrown by the library
+
+#include <stdexcept>
+#include <string_view>
+
+USERVER_NAMESPACE_BEGIN
+
+/// @brief Top namespace for the proto-structs library
+namespace proto_structs {
+
+/// @brief Library basic exception type
+/// All other proto-structs exceptions are derived from this type.
+class Error : public std::runtime_error {
+public:
+    using std::runtime_error::runtime_error;
+};
+
+/// @brief Conversion error base class
+class ConversionError : public Error {
+protected:
+    using Error::Error;
+};
+
+/// @brief Error reading proto struct from protobuf message
+class ReadError final : public ConversionError {
+public:
+    /// @brief Creates error with information what protobuf message field was considered invalid
+    /// Parameter @a path contains dot-separated field names from the top-level message up to erroneous field, for
+    /// example, "msg.field.nested_field".
+    ReadError(std::string_view path, std::string_view reason);
+};
+
+/// @brief Error writing proto struct to protobuf message
+class WriteError final : public ConversionError {
+public:
+    /// @brief Creates error with information what protobuf message field was not correctly initialized
+    /// Parameter @a path contains dot-separated field names from the top-level message up to field that was not
+    /// initialized, for example, "msg.field.nested_field".
+    WriteError(std::string_view path, std::string_view reason);
+};
+
+/// @brief Invalid attempt to access unset @ref proto_structs::Oneof field
+class OneofAccessError : public Error {
+public:
+    /// @brief Creates error on invalid attempt to access @a field_idx field of `oneof`
+    explicit OneofAccessError(std::size_t field_idx);
+};
+
+/// @brief Error packing protobuf message to @ref proto_structs::Any underlying storage.
+class AnyPackError : public Error {
+public:
+    /// @brief Creates error with information what protobuf message was not packed
+    explicit AnyPackError(std::string_view message_name);
+};
+
+/// @brief Error unpacking protobuf message from @ref proto_structs::Any underlying storage.
+/// The main reason of this exception is the attempt to unpack message type different from the one stored in the
+/// @ref proto_structs::Any underlying storage
+class AnyUnpackError : public Error {
+public:
+    /// @brief Creates error with information what protobuf message was not unpacked
+    explicit AnyUnpackError(std::string_view message_name);
+};
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/hash_map.hpp b/libraries/proto-structs/include/userver/proto-structs/hash_map.hpp
new file mode 100644
index 000000000000..c5872d8cf08c
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/hash_map.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+/// @file userver/proto-structs/hash_map.hpp
+/// @brief @copybrief proto_structs::HashMap
+
+#include <string_view>
+#include <type_traits>
+#include <unordered_map>
+
+#include <userver/utils/str_icase.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+/// @brief The hash map container used in userver proto structs by default.
+///
+/// Currently implemented as just `std::unordered_map`. Please don't assume it! For example:
+///
+/// * Don't pass the field to functions as `std::unordered_map`, use `proto_structs::HashMap` instead;
+/// * Don't use node and bucket APIs of `std::unordered_map` with these fields.
+template <typename Key, typename Value>
+using HashMap = std::unordered_map<
+    Key,
+    Value,
+    std::conditional_t<std::is_convertible_v<Key, std::string_view>, utils::StrCaseHash, std::hash<Key>>>;
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_cpp.hpp b/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_cpp.hpp
new file mode 100644
index 000000000000..a7c0c25be62a
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_cpp.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <userver/proto-structs/io/impl/field_accessor.hpp>
+#include <userver/proto-structs/io/impl/read.hpp>
+#include <userver/proto-structs/io/impl/write.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+#include <userver/proto-structs/io/std/optional_conv.hpp>
+#include <userver/proto-structs/io/std/string_conv.hpp>
+#include <userver/proto-structs/io/std/vector_conv.hpp>
+
+#include <userver/proto-structs/io/std/int32_t_conv.hpp>
+#include <userver/proto-structs/io/std/int64_t_conv.hpp>
+#include <userver/proto-structs/io/std/size_t_conv.hpp>
+#include <userver/proto-structs/io/std/uint32_t_conv.hpp>
+#include <userver/proto-structs/io/std/uint64_t_conv.hpp>
+
+// For keyword types.
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_hpp.hpp b/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_hpp.hpp
new file mode 100644
index 000000000000..3d75041f0446
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/impl/bundles/structs_hpp.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <userver/proto-structs/impl/oneof_codegen.hpp>
+#include <userver/proto-structs/io/fwd.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/impl/oneof_codegen.hpp b/libraries/proto-structs/include/userver/proto-structs/impl/oneof_codegen.hpp
new file mode 100644
index 000000000000..47c6f856ff52
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/impl/oneof_codegen.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <cstddef>
+#include <utility>
+
+#include <userver/proto-structs/oneof.hpp>
+
+#define UPROTO_ONEOF_HEADER(oneof_type)                                                   \
+private:                                                                                  \
+    enum { kCounterStart = __COUNTER__ + 1 }; /* An inline constant would violate odr. */ \
+public:                                                                                   \
+    using Base::Base;
+
+#define UPROTO_ONEOF_FIELD(oneof_type, field_type, field_name)                     \
+private:                                                                           \
+    static constexpr std::size_t field_name##_index = __COUNTER__ - kCounterStart; \
+                                                                                   \
+public:                                                                            \
+    [[nodiscard]] constexpr bool has_##field_name() const noexcept;                \
+    [[nodiscard]] constexpr const field_type& field_name() const&;                 \
+    [[nodiscard]] constexpr field_type&& field_name()&&;                           \
+    constexpr void set_##field_name(const field_type& value);                      \
+    constexpr void set_##field_name(field_type&& value);                           \
+    constexpr field_type& mutable_##field_name();                                  \
+    [[nodiscard]] static oneof_type make_##field_name(const field_type& value);    \
+    [[nodiscard]] static oneof_type make_##field_name(field_type&& value);
+
+#define UPROTO_ONEOF_DEFINE_FIELD_FUNCTIONS(oneof_type, field_type, field_name)                                    \
+    [[nodiscard]] constexpr bool oneof_type::has_##field_name() const noexcept {                                   \
+        return Base::Contains(field_name##_index);                                                                 \
+    }                                                                                                              \
+    [[nodiscard]] constexpr const field_type& oneof_type::field_name() const& {                                    \
+        return Base::Get<field_name##_index>();                                                                    \
+    }                                                                                                              \
+    [[nodiscard]] constexpr field_type&& oneof_type::field_name()&& {                                              \
+        return std::move(*this).Base::Get<field_name##_index>();                                                   \
+    }                                                                                                              \
+    constexpr void oneof_type::set_##field_name(const field_type& value) { Base::Set<field_name##_index>(value); } \
+    constexpr void oneof_type::set_##field_name(field_type&& value) {                                              \
+        Base::Set<field_name##_index>(std::move(value));                                                           \
+    }                                                                                                              \
+    constexpr field_type& oneof_type::mutable_##field_name() { return Base::GetMutable<field_name##_index>(); }    \
+    [[nodiscard]] inline oneof_type oneof_type::make_##field_name(const field_type& value) {                       \
+        return oneof_type(std::in_place_index<field_name##_index>, value);                                         \
+    }                                                                                                              \
+    [[nodiscard]] inline oneof_type oneof_type::make_##field_name(field_type&& value) {                            \
+        return oneof_type(std::in_place_index<field_name##_index>, std::move(value));                              \
+    }
diff --git a/libraries/proto-structs/include/userver/proto-structs/impl/traits_light.hpp b/libraries/proto-structs/include/userver/proto-structs/impl/traits_light.hpp
new file mode 100644
index 000000000000..958177d4f6e8
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/impl/traits_light.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <type_traits>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::impl::traits {
+
+template <template <typename...> typename Template, typename... TArgs>
+void InheritsFromInstantiationImpl(const volatile Template<TArgs...>&) {}
+
+template <template <typename...> typename Template, typename T>
+inline constexpr bool InheritsFromInstantiation =
+    !std::is_reference_v<T> && requires(T derived) { traits::InheritsFromInstantiationImpl<Template>(derived); };
+
+}  // namespace proto_structs::impl::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/context.hpp b/libraries/proto-structs/include/userver/proto-structs/io/context.hpp
new file mode 100644
index 000000000000..56f47e1a1268
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/context.hpp
@@ -0,0 +1,253 @@
+#pragma once
+
+/// @file userver/proto-structs/io/context.hpp
+/// @brief Conversion context classes which provide methods for performing conversion
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#include <userver/proto-structs/io/context_base.hpp>
+#include <userver/proto-structs/io/fwd.hpp>
+#include <userver/proto-structs/io/std/scalar.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+template <traits::ProtoMessage TMessage, traits::ProtoStruct TStruct>
+void MessageToStruct(const TMessage&, TStruct&);
+
+template <typename TStruct, traits::ProtoMessage TMessage>
+requires traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+void StructToMessage(TStruct&&, TMessage&);
+
+}  // namespace proto_structs
+
+namespace proto_structs::io {
+
+/// @brief Read operation context passed to user-defined `ReadProtoStruct` global functions
+class ReadContext final : public ContextWithErrors<ReadError> {
+private:
+    using ContextWithErrors<ReadError>::ContextWithErrors;
+    using ContextWithErrors<ReadError>::PushToPath;
+    using ContextWithErrors<ReadError>::PopFromPath;
+
+    template <proto_structs::traits::ProtoMessage TMessage, proto_structs::traits::ProtoStruct TStruct>
+    friend void proto_structs::MessageToStruct(const TMessage&, TStruct&);
+
+public:
+    /// @brief Converts protobuf message field @a message_field with number @a field_number to a proto struct field
+    ///        with type `T`
+    /// @tparam T proto struct field type
+    /// @tparam U protobuf message type
+    template <typename T, typename U>
+    T ReadField(int field_number, const U& message_field) {
+        if constexpr (requires { ReadProtoField(*this, To<std::remove_cv_t<T>>{}, field_number, message_field); }) {
+            return ReadProtoField(*this, To<std::remove_cv_t<T>>{}, field_number, message_field);
+        } else {
+            static_assert(
+                sizeof(T) && false,
+                "There is no 'ReadProtoField(proto_structs::io::ReadContext&, proto_structs::io::To<T>, int, const U&) "
+                "in namespace 'proto_structs::io'. Did you forget to include 'conv'-header responsible for reading 'T' "
+                "from 'userver/proto-structs/io'?"
+            );
+            return {};
+        }
+    }
+
+    /// @brief Converts protobuf message field @a message_field with number @a field_number to a proto struct field
+    ///        with type `T`
+    /// @tparam T proto struct field type
+    /// @tparam U protobuf message type
+    template <proto_structs::traits::ProtoStruct TStruct, proto_structs::traits::ProtoMessage TMessage>
+    TStruct ReadField(int field_number, const TMessage& message_field) {
+        static_assert(
+            proto_structs::traits::CompatibleWith<TStruct, TMessage>,
+            "proto struct type is not compatible with protobuf message type"
+        );
+
+        if constexpr (requires { ReadProtoStruct(*this, To<std::remove_cv_t<TStruct>>{}, message_field); }) {
+            // Note, that not popping field_number in case of exception thrown from the `ReadProtoStruct` is
+            // intentional: this allows us later to catch this exception and convert it to `ReadError` with
+            // complete information about the field which was not converted.
+
+            PushToPath(field_number);
+            auto obj = ReadProtoStruct(*this, To<std::remove_cv_t<TStruct>>{}, message_field);
+            PopFromPath();
+            return obj;
+        } else {
+            static_assert(
+                sizeof(TStruct) && false,
+                "There is no 'ReadProtoStruct(proto_structs::io::ReadContext&, proto_structs::io::To<TStruct>, int, "
+                "const TMessage&) in namespace of 'TStruct' or 'proto_structs::io'. Probably you have not provided "
+                "'ReadProtoStruct' function overload or have not included 'conv'-header responsible for reading "
+                "well-known 'TStruct'."
+            );
+            return {};
+        }
+    }
+
+    /// @brief Converts protobuf message field @a message_field with number @a field_number to the proto struct field
+    ///        @a struct_field
+    /// @tparam T proto struct field type
+    /// @tparam U protobuf message type
+    template <typename T, typename U>
+    void ReadField(T& struct_field, int field_number, const U& message_field) {
+        struct_field = ReadContext::ReadField<T>(field_number, message_field);
+    }
+};
+
+/// @brief Write operation context passed to user-defined `WriteProtoStruct` global functions
+class WriteContext final : public ContextWithErrors<WriteError> {
+protected:
+    using ContextWithErrors<WriteError>::ContextWithErrors;
+    using ContextWithErrors<WriteError>::PushToPath;
+    using ContextWithErrors<WriteError>::PopFromPath;
+
+    template <typename TStruct, proto_structs::traits::ProtoMessage TMessage>
+    requires proto_structs::traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+    friend void proto_structs::StructToMessage(TStruct&&, TMessage&);
+
+public:
+    /// @brief Converts proto struct field @a struct_field to the protobuf message field @a message_field with number
+    ///        @a field_number
+    /// @tparam T proto struct field type
+    /// @tparam U protobuf message type
+    template <typename T, typename U>
+    void WriteField(T&& struct_field, int field_number, U& message_field) {
+        if constexpr (requires {
+                          WriteProtoField(*this, std::forward<T>(struct_field), field_number, message_field);
+                      }) {
+            WriteProtoField(*this, std::forward<T>(struct_field), field_number, message_field);
+        } else {
+            static_assert(
+                sizeof(T) && false,
+                "There is no 'WriteProtoField(proto_structs::io::WriteContext&, T&&, int, U&) in namespace "
+                "'proto_structs::io'. Did you forget to include 'conv'-header responsible for writing 'T' from "
+                "'userver/proto-structs/io'?"
+            );
+        }
+    }
+
+    /// @brief Converts proto struct field @a struct_field to the protobuf message field @a message_field with number
+    ///        @a field_number
+    /// @tparam T proto struct field type
+    /// @tparam U protobuf message type
+    template <typename TStruct, proto_structs::traits::ProtoMessage TMessage>
+    requires proto_structs::traits::ProtoStruct<std::remove_cvref_t<TStruct>>
+    void WriteField(TStruct&& struct_field, int field_number, TMessage& message_field) {
+        static_assert(
+            proto_structs::traits::CompatibleWith<std::remove_cvref_t<TStruct>, TMessage>,
+            "proto struct type is not compatible with protobuf message type"
+        );
+
+        if constexpr (requires { WriteProtoStruct(*this, std::forward<TStruct>(struct_field), message_field); }) {
+            // Note, that not popping field_number in case of exception thrown from the `WriteProtoStruct` is
+            // intentional: this allows us later to catch this exception and convert it to `WriteError` with
+            // complete information about the field which was not converted.
+
+            PushToPath(field_number);
+            WriteProtoStruct(*this, std::forward<TStruct>(struct_field), message_field);
+            PopFromPath();
+        } else {
+            static_assert(
+                sizeof(TStruct) && false,
+                "There is no 'WriteProtoStruct(proto_structs::io::WriteContext&, TStruct&&, TMessage&) in namespace of "
+                "'TStruct' or 'proto_structs::io'. Probably you have not provided 'WriteProtoStruct' function overload "
+                "or have not included 'conv'-header responsible for writing well-known 'TStruct'."
+            );
+        }
+    }
+};
+
+}  // namespace proto_structs::io
+
+namespace proto_structs::io::impl {
+
+// clang-format off
+
+template<typename TStdType, typename TProtobufType>
+concept SignCompatibleWith =
+    (std::is_signed_v<std::remove_cv_t<TStdType>> && std::is_signed_v<std::remove_cv_t<TProtobufType>>)
+    ||
+    (std::is_unsigned_v<std::remove_cv_t<TStdType>> && std::is_unsigned_v<std::remove_cv_t<TProtobufType>>);
+
+template<typename TStdType, typename TProtobufType>
+concept IntegerCompatibleWith =
+    (std::is_same_v<std::remove_cv_t<TStdType>, std::int32_t> ||
+     std::is_same_v<std::remove_cv_t<TStdType>, std::int64_t> ||
+     std::is_same_v<std::remove_cv_t<TStdType>, std::uint32_t> ||
+     std::is_same_v<std::remove_cv_t<TStdType>, std::uint64_t>)
+    &&
+    sizeof(TStdType) == sizeof(TProtobufType)
+    &&
+    SignCompatibleWith<TStdType, TProtobufType>;
+
+template<typename TStdType, typename TProtobufType>
+concept StringCompatibleWith =
+    std::is_same_v<std::remove_cv_t<TStdType>, std::string>
+    &&
+    std::is_constructible_v<std::string, TProtobufType>;
+
+template<typename TStdType, typename TProtobufType>
+concept EnumCompatibleWith =
+    std::is_enum_v<TStdType>
+    &&
+    (std::is_enum_v<TProtobufType> || std::is_integral_v<TProtobufType>);
+
+template<typename TStdType, typename TProtobufType>
+concept SizeTypeCompatibleWith =
+    std::is_same_v<std::remove_cv_t<TStdType>, std::size_t> && std::is_integral_v<TProtobufType>;
+
+// clang-format on
+
+}  // namespace proto_structs::io::impl
+
+namespace proto_structs::io {
+
+/// @brief Determines compatability between protobuf/std scalar types
+template <typename TStdType, typename TProtobufType>
+concept ScalarCompatibleWith = traits::ProtoScalar<TStdType> &&
+                               (std::is_same_v<std::remove_cv_t<TStdType>, std::remove_cv_t<TProtobufType>> ||
+                                impl::IntegerCompatibleWith<TStdType, TProtobufType> ||
+                                impl::StringCompatibleWith<TStdType, TProtobufType> ||
+                                impl::EnumCompatibleWith<TStdType, TProtobufType> ||
+                                impl::SizeTypeCompatibleWith<TStdType, TProtobufType>);
+
+template <typename TStructField, typename TMessageField>
+requires ScalarCompatibleWith<TStructField, TMessageField>
+TStructField ReadProtoField(ReadContext& ctx, To<TStructField>, int field_number, const TMessageField& message_field) {
+    if constexpr (std::is_same_v<std::size_t, TStructField>) {
+        if (message_field >= 0 &&
+            static_cast<std::uintmax_t>(message_field) <= std::numeric_limits<std::size_t>::max()) {
+            return static_cast<std::size_t>(message_field);
+        } else {
+            ctx.AddError(field_number, "value is out of range");
+            return {};
+        }
+    } else {
+        return static_cast<TStructField>(message_field);
+    }
+}
+
+template <typename TStructField, typename TMessageField>
+requires ScalarCompatibleWith<std::remove_cvref_t<TStructField>, TMessageField>
+void WriteProtoField(WriteContext& ctx, TStructField&& struct_field, int field_number, TMessageField& message_field) {
+    if constexpr (std::is_same_v<std::remove_cvref_t<TStructField>, std::size_t>) {
+        if (struct_field <= std::numeric_limits<TMessageField>::max()) {
+            message_field = static_cast<TMessageField>(struct_field);
+        } else {
+            ctx.AddError(field_number, "value is out of range");
+        }
+    } else if constexpr (std::is_enum_v<std::remove_cvref_t<TStructField>>) {
+        message_field = static_cast<std::remove_cv_t<TMessageField>>(struct_field);
+    } else {
+        message_field = std::forward<TStructField>(struct_field);
+    }
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/context_base.hpp b/libraries/proto-structs/include/userver/proto-structs/io/context_base.hpp
new file mode 100644
index 000000000000..f7e996d5133a
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/context_base.hpp
@@ -0,0 +1,90 @@
+#pragma once
+
+/// @file userver/proto-structs/io/context.hpp
+/// @brief Context base classes providing methods for conversion process management
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <boost/container/small_vector.hpp>
+
+#include <userver/proto-structs/exceptions.hpp>
+#include <userver/utils/impl/internal_tag_fwd.hpp>
+
+namespace google::protobuf {
+class Descriptor;
+class FieldDescriptor;
+}  // namespace google::protobuf
+
+USERVER_NAMESPACE_BEGIN
+
+/// @brief Namespace for conversion utlities and predefined proto-structs conversion hooks for well-known std/userver
+///        types
+namespace proto_structs::io {
+
+/// @brief Read/write operation context
+class Context {
+protected:
+    explicit Context(const ::google::protobuf::Descriptor& message_desc) noexcept : top_message_desc_(message_desc) {}
+
+    void PushToPath(int field_number) { path_.push_back(field_number); }
+    void PopFromPath() { path_.pop_back(); }
+
+    std::string GetCurrentPath(int current_field_number) const;
+    std::string GetCurrentPath(const ::google::protobuf::FieldDescriptor& current_field_desc) const;
+    std::string GetCurrentPath() const;
+
+private:
+    std::string GetCurrentPathImpl(const ::google::protobuf::Descriptor*& last_message_desc) const;
+
+    const ::google::protobuf::Descriptor& top_message_desc_;
+    ::boost::container::small_vector<int, 16> path_;
+};
+
+/// @brief Read/write operation context with error information
+/// @tparam TError error type
+template <typename TError>
+class ContextWithErrors : public Context {
+public:
+    using Error = TError;
+
+    /// @brief Returns `true` if context contains at least one error
+    bool HasErrors() const noexcept { return !errors_.empty(); }
+
+    /// @cond
+    const std::vector<Error>& GetErrors(utils::impl::InternalTag) const& noexcept;
+    std::vector<Error>&& GetErrors(utils::impl::InternalTag) && noexcept;
+    /// @endcond
+
+    /// @brief Adds conversion error
+    /// @throws Error exception
+    /// Parameter @a field_number contains protobuf message field number for which conversion has failed.
+    void AddError(int field_number, std::string_view reason);
+
+    /// @brief Adds conversion error
+    /// Parameter @a field_desc contains protobuf message field descriptor for which conversion has failed.
+    void AddError(const ::google::protobuf::FieldDescriptor& field_desc, std::string_view reason);
+
+    /// @brief Adds conversion error
+    /// Method is intended for cases when it is hard to associate error with concrete field of the protobuf message.
+    void AddError(std::string_view reason);
+
+protected:
+    using Context::Context;
+    using Context::GetCurrentPath;
+    using Context::PopFromPath;
+    using Context::PushToPath;
+
+private:
+    void AddError(std::string_view path, std::string_view reason);
+
+    std::vector<Error> errors_;
+};
+
+extern template class ContextWithErrors<ReadError>;
+extern template class ContextWithErrors<WriteError>;
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/fwd.hpp b/libraries/proto-structs/include/userver/proto-structs/io/fwd.hpp
new file mode 100644
index 000000000000..7219693cc3f0
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/fwd.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+/// @file userver/proto-structs/io/fwd.hpp
+/// @brief Forward declarations of utlity types for conversions
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+/// @brief An ADL helper which allows compiler to find functions to read proto structs from protobuf messages
+template <typename T>
+struct To {
+    using Type = T;
+};
+
+class ReadContext;
+class WriteContext;
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/impl/field_accessor.hpp b/libraries/proto-structs/include/userver/proto-structs/io/impl/field_accessor.hpp
new file mode 100644
index 000000000000..132a42f87f86
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/impl/field_accessor.hpp
@@ -0,0 +1,210 @@
+#pragma once
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <userver/proto-structs/impl/traits_light.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::protobuf {
+class FieldDescriptor;
+class Message;
+}  // namespace google::protobuf
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io::impl {
+
+class FieldAccessor {
+public:
+    FieldAccessor(const ::google::protobuf::Message& message, int field_number) noexcept
+        : message_(message), field_number_(field_number) {}
+
+    const ::google::protobuf::Message& GetMessage() const noexcept { return message_; }
+    int GetFieldNumber() const noexcept { return field_number_; }
+
+    const ::google::protobuf::FieldDescriptor& GetFieldDescriptor() const noexcept;
+
+private:
+    const ::google::protobuf::Message& message_;
+    int field_number_;
+    mutable const ::google::protobuf::FieldDescriptor* field_desc_ = nullptr;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+class FieldGetter : public FieldAccessor {
+public:
+    using Message = TMessage;
+    using ReturnType = TReturn;
+    using GetFunc = ReturnType (Message::*)() const;
+
+    FieldGetter(const Message& message, int field_number, GetFunc get_func) noexcept
+        : FieldAccessor(message, field_number), message_(message), get_func_(get_func) {}
+
+    const Message& GetMessage() const noexcept { return message_; }
+    ReturnType GetValue() const { return (message_.*get_func_)(); }
+
+private:
+    const Message& message_;
+    GetFunc get_func_;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+class FieldGetterWithPresence final : public FieldGetter<TMessage, TReturn> {
+public:
+    using Base = FieldGetter<TMessage, TReturn>;
+    using typename Base::GetFunc;
+    using typename Base::Message;
+    using HasFunc = bool (Message::*)() const;
+
+    FieldGetterWithPresence(const Message& message, int field_number, GetFunc get_func, HasFunc has_func) noexcept
+        : Base(message, field_number, get_func), has_func_(has_func) {}
+
+    bool HasValue() const { return (Base::GetMessage().*has_func_)(); }
+
+private:
+    HasFunc has_func_;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage>
+class FieldSetter : public FieldAccessor {
+public:
+    using Message = TMessage;
+    using ClearFunc = void (Message::*)();
+
+    FieldSetter(Message& message, int field_number, ClearFunc clear_func) noexcept
+        : FieldAccessor(message, field_number), message_(message), clear_func_(clear_func) {}
+
+    Message& GetMessage() const noexcept { return message_; }
+    void ClearValue() const { (message_.*clear_func_)(); }
+
+private:
+    Message& message_;
+    ClearFunc clear_func_;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TArg>
+class FieldSetterWithArg : public FieldSetter<TMessage> {
+public:
+    using Base = FieldSetter<TMessage>;
+    using typename Base::Message;
+    using ArgType = TArg;
+    using typename Base::ClearFunc;
+    using SetFunc = void (Message::*)(ArgType);
+
+    FieldSetterWithArg(Message& message, int field_number, SetFunc set_func, ClearFunc clear_func)
+        : Base(message, field_number, clear_func), set_func_(set_func) {}
+
+    void SetValue(ArgType value) const { (Base::GetMessage().*set_func_)(value); }
+
+private:
+    SetFunc set_func_;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage>
+class FieldSetterString : public FieldSetterWithArg<TMessage, const std::string&> {
+public:
+    using Base = FieldSetterWithArg<TMessage, const std::string&>;
+    using typename Base::ClearFunc;
+    using typename Base::Message;
+    using typename Base::SetFunc;
+    using ArgType = std::string&&;
+    using SetFuncForRvalue = void (Message::*)(std::string&&);
+
+    FieldSetterString(
+        Message& message,
+        int field_number,
+        SetFunc set_func,
+        SetFuncForRvalue set_func_for_rvalue,
+        ClearFunc clear_func
+    )
+        : Base(message, field_number, set_func, clear_func), set_func_for_rvalue_(set_func_for_rvalue) {}
+
+    void SetValue(std::string&& value) const { (Base::GetMessage().*set_func_for_rvalue_)(std::move(value)); }
+
+private:
+    SetFuncForRvalue set_func_for_rvalue_;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+class FieldSetterWithMutable : public FieldSetter<TMessage> {
+public:
+    using Base = FieldSetter<TMessage>;
+    using ReturnType = TReturn;
+    using typename Base::ClearFunc;
+    using typename Base::Message;
+    using GetMutableFunc = TReturn (Message::*)();
+
+    FieldSetterWithMutable(Message& message, int field_number, GetMutableFunc get_mutable_func, ClearFunc clear_func)
+        : Base(message, field_number, clear_func), get_mutable_func_(get_mutable_func) {}
+
+    ReturnType GetMutableValue() const { return (Base::GetMessage().*get_mutable_func_)(); }
+
+private:
+    GetMutableFunc get_mutable_func_;
+};
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+auto CreateFieldGetter(const TMessage& message, int field_number, TReturn (TMessage::*get_func)() const) noexcept {
+    return FieldGetter<TMessage, TReturn>(message, field_number, get_func);
+}
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+auto CreateFieldGetter(
+    const TMessage& message,
+    int field_number,
+    TReturn (TMessage::*get_func)() const,
+    bool (TMessage::*has_func)() const
+) {
+    return FieldGetterWithPresence<TMessage, TReturn>(message, field_number, get_func, has_func);
+}
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TArg>
+auto CreateFieldSetter(
+    TMessage& message,
+    int field_number,
+    void (TMessage::*set_func)(TArg),
+    void (TMessage::*clear_func)()
+) noexcept {
+    return FieldSetterWithArg<TMessage, TArg>(message, field_number, set_func, clear_func);
+}
+
+template <proto_structs::traits::ProtoMessage TMessage>
+auto CreateFieldSetter(
+    TMessage& message,
+    int field_number,
+    void (TMessage::*set_func)(const std::string&),
+    void (TMessage::*set_func_for_rvalue)(std::string&&),
+    void (TMessage::*clear_func)()
+) noexcept {
+    return FieldSetterString<TMessage>(message, field_number, set_func, set_func_for_rvalue, clear_func);
+}
+
+template <proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+auto CreateFieldSetter(
+    TMessage& message,
+    int field_number,
+    TReturn (TMessage::*get_mutable_func)(),
+    void (TMessage::*clear_func)()
+) noexcept {
+    return FieldSetterWithMutable<TMessage, TReturn>(message, field_number, get_mutable_func, clear_func);
+}
+
+namespace traits {
+
+template <typename T>
+concept FieldGetter = proto_structs::impl::traits::InheritsFromInstantiation<proto_structs::io::impl::FieldGetter, T>;
+
+template <typename T>
+concept FieldGetterWithPresence =
+    proto_structs::impl::traits::InheritsFromInstantiation<proto_structs::io::impl::FieldGetterWithPresence, T>;
+
+template <typename T>
+concept FieldSetter = proto_structs::impl::traits::InheritsFromInstantiation<proto_structs::io::impl::FieldSetter, T>;
+
+}  // namespace traits
+
+}  // namespace proto_structs::io::impl
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/impl/read.hpp b/libraries/proto-structs/include/userver/proto-structs/io/impl/read.hpp
new file mode 100644
index 000000000000..c19b92b8f516
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/impl/read.hpp
@@ -0,0 +1,87 @@
+#pragma once
+
+#include <cstddef>
+#include <optional>
+#include <utility>
+
+#include <userver/proto-structs/io/context.hpp>
+#include <userver/proto-structs/io/impl/field_accessor.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+#include <userver/utils/meta_light.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io::impl {
+
+template <typename TField, proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+TField ReadFieldWithGetter(
+    proto_structs::io::ReadContext& ctx,
+    proto_structs::io::To<TField>,
+    const FieldGetter<TMessage, TReturn>& getter
+) {
+    static_assert(
+        !meta::kIsCvInstantiationOf<std::optional, TField>,
+        "'FieldGetterWithPresence' should be used for optional field"
+    );
+    return ctx.ReadField<TField>(getter.GetFieldNumber(), getter.GetValue());
+}
+
+template <typename TField, proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+std::optional<TField> ReadFieldWithGetter(
+    proto_structs::io::ReadContext& ctx,
+    proto_structs::io::To<std::optional<TField>>,
+    const FieldGetterWithPresence<TMessage, TReturn>& getter
+) {
+    std::optional<TField> result;
+
+    if (getter.HasValue()) {
+        result = impl::ReadFieldWithGetter(
+            ctx, proto_structs::io::To<TField>{}, static_cast<const FieldGetter<TMessage, TReturn>&>(getter)
+        );
+    }
+
+    return result;
+}
+
+template <std::size_t Index, typename TOneof, typename TMessage, typename TReturn>
+bool ReadOneofFieldWithGetter(
+    proto_structs::io::ReadContext& ctx,
+    TOneof& oneof,
+    const FieldGetterWithPresence<TMessage, TReturn>& getter
+) {
+    if (getter.HasValue()) {
+        oneof.template Set<Index>(impl::ReadFieldWithGetter(
+            ctx,
+            To<proto_structs::OneofAlternativeType<Index, TOneof>>{},
+            static_cast<const FieldGetter<TMessage, TReturn>&>(getter)
+        ));
+        return true;
+    } else {
+        oneof.Clear(Index);
+        return false;
+    }
+}
+
+template <typename TOneof, std::size_t... Index, typename... TGetters>
+TOneof ReadOneof(proto_structs::io::ReadContext& ctx, std::index_sequence<Index...>, const TGetters&... getters) {
+    TOneof oneof;
+    (impl::ReadOneofFieldWithGetter<Index>(ctx, oneof, getters) || ...);
+    return oneof;
+}
+
+template <typename TField, typename TGetter>
+requires(!proto_structs::traits::Oneof<TField>) && traits::FieldGetter<TGetter>
+TField ReadField(proto_structs::io::ReadContext& ctx, const TGetter& getter) {
+    return impl::ReadFieldWithGetter(ctx, proto_structs::io::To<TField>{}, getter);
+}
+
+template <typename TField, typename... TGetters>
+requires proto_structs::traits::Oneof<TField> && (traits::FieldGetterWithPresence<TGetters> && ...)
+TField ReadField(proto_structs::io::ReadContext& ctx, const TGetters&... getters) {
+    static_assert(TField::kSize == sizeof...(TGetters), "Field getter is not provided for some 'Oneof' field(s)");
+    return impl::ReadOneof<TField>(ctx, std::make_index_sequence<sizeof...(TGetters)>{}, getters...);
+}
+
+}  // namespace proto_structs::io::impl
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/impl/std/any_map_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/impl/std/any_map_conv.hpp
new file mode 100644
index 000000000000..66cb7e9b4f87
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/impl/std/any_map_conv.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <type_traits>
+
+#include <google/protobuf/map.h>
+
+#include <userver/proto-structs/io/context.hpp>
+
+namespace proto_structs::io::impl {
+
+template <typename TMap, typename TKey, typename TValue>
+TMap ReadMap(ReadContext& ctx, int field_number, const ::google::protobuf::Map<TKey, TValue>& message_field) {
+    using Key = typename TMap::key_type;
+    using Value = typename TMap::mapped_type;
+    TMap result;
+
+    for (const auto& [key, val] : message_field) {
+        result.emplace(ctx.ReadField<Key>(field_number, key), ctx.ReadField<Value>(field_number, val));
+    }
+
+    return result;
+}
+
+template <typename TMap, typename TKey, typename TValue>
+void WriteMap(
+    WriteContext& ctx,
+    TMap&& struct_field,
+    int field_number,
+    ::google::protobuf::Map<TKey, TValue>& message_field
+) {
+    message_field.clear();
+
+    for (auto& [key, val] : struct_field) {
+        TKey msg_key;
+        ctx.WriteField(key, field_number, msg_key);
+
+        if constexpr (std::is_rvalue_reference_v<decltype(struct_field)>) {
+            ctx.WriteField(std::move(val), field_number, message_field[std::move(msg_key)]);
+        } else {
+            ctx.WriteField(val, field_number, message_field[std::move(msg_key)]);
+        }
+    }
+}
+
+}  // namespace proto_structs::io::impl
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/impl/write.hpp b/libraries/proto-structs/include/userver/proto-structs/io/impl/write.hpp
new file mode 100644
index 000000000000..68b055c5327e
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/impl/write.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#include <userver/proto-structs/io/context.hpp>
+#include <userver/proto-structs/io/impl/field_accessor.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+#include <userver/utils/meta_light.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io::impl {
+
+template <typename TField, proto_structs::traits::ProtoMessage TMessage, typename TArg>
+void WriteFieldWithSetter(
+    proto_structs::io::WriteContext& ctx,
+    TField&& value,
+    const FieldSetterWithArg<TMessage, TArg>& setter
+) {
+    using ProtobufType = std::remove_cvref_t<TArg>;
+    ProtobufType message_field{};
+    ctx.WriteField(std::forward<TField>(value), setter.GetFieldNumber(), message_field);
+    setter.SetValue(std::move(message_field));
+}
+
+template <typename TField, proto_structs::traits::ProtoMessage TMessage>
+void WriteFieldWithSetter(
+    proto_structs::io::WriteContext& ctx,
+    TField&& value,
+    const FieldSetterString<TMessage>& setter
+) {
+    std::string message_field{};
+    ctx.WriteField(std::forward<TField>(value), setter.GetFieldNumber(), message_field);
+    setter.SetValue(std::move(message_field));
+}
+
+template <typename TField, proto_structs::traits::ProtoMessage TMessage, typename TReturn>
+void WriteFieldWithSetter(
+    proto_structs::io::WriteContext& ctx,
+    TField&& value,
+    const FieldSetterWithMutable<TMessage, TReturn>& setter
+) {
+    ctx.WriteField(std::forward<TField>(value), setter.GetFieldNumber(), *setter.GetMutableValue());
+}
+
+template <std::size_t Index, typename TOneof, typename TSetter>
+bool WriteOneofFieldWithSetter(proto_structs::io::WriteContext& ctx, TOneof&& oneof, const TSetter& setter) {
+    if (oneof.Contains(Index)) {
+        WriteFieldWithSetter(ctx, std::forward<TOneof>(oneof).template Get<Index>(), setter);
+        return true;
+    } else {
+        setter.ClearValue();
+        return false;
+    }
+}
+
+template <typename TOneof, std::size_t... Index, typename... TSetters>
+void WriteOneof(
+    proto_structs::io::WriteContext& ctx,
+    TOneof&& oneof,
+    std::index_sequence<Index...>,
+    const TSetters&... setters
+) {
+    (impl::WriteOneofFieldWithSetter<Index>(ctx, std::forward<TOneof>(oneof), setters) || ...);
+}
+
+template <typename TField, typename TSetter>
+requires(!proto_structs::traits::Oneof<std::remove_cvref_t<TField>>) && traits::FieldSetter<TSetter>
+void WriteField(proto_structs::io::WriteContext& ctx, TField&& value, const TSetter& setter) {
+    using FieldType = std::remove_cvref_t<TField>;
+
+    if constexpr (meta::kIsCvInstantiationOf<std::optional, FieldType>) {
+        if (value) {
+            impl::WriteFieldWithSetter(ctx, std::forward<TField>(value).value(), setter);
+        } else {
+            setter.ClearValue();
+        }
+    } else {
+        impl::WriteFieldWithSetter(ctx, std::forward<TField>(value), setter);
+    }
+}
+
+template <typename TField, typename... TSetters>
+requires proto_structs::traits::Oneof<std::remove_cvref_t<TField>> && (traits::FieldSetter<TSetters> && ...)
+void WriteField(proto_structs::io::WriteContext& ctx, TField&& value, const TSetters&... setters) {
+    using OneofType = std::remove_cvref_t<TField>;
+    static_assert(OneofType::kSize == sizeof...(TSetters), "Field setter is not provided for some 'Oneof' field(s)");
+    impl::WriteOneof(ctx, std::forward<TField>(value), std::make_index_sequence<sizeof...(TSetters)>{}, setters...);
+}
+
+}  // namespace proto_structs::io::impl
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration.hpp
new file mode 100644
index 000000000000..eb9ba4e0c9af
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/duration.hpp
+/// @brief Provides `std::chrono::duration` proto struct field support
+
+#include <chrono>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::protobuf {
+class Duration;
+}  // namespace google::protobuf
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::traits {
+
+template <typename TRep, typename TPeriod>
+struct CompatibleMessageTrait<std::chrono::duration<TRep, TPeriod>> {
+    using Type = ::google::protobuf::Duration;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration_conv.hpp
new file mode 100644
index 000000000000..9f268cb7190c
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/duration_conv.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/duration_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::chrono::duration` conversion
+
+#include <userver/proto-structs/io/std/chrono/duration.hpp>
+
+#include <google/protobuf/duration.pb.h>
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/proto-structs/io/context.hpp>
+#include <userver/utils/assert.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+template <typename TRep, typename TPeriod>
+std::chrono::duration<TRep, TPeriod>
+ReadProtoStruct(ReadContext& ctx, To<std::chrono::duration<TRep, TPeriod>>, const ::google::protobuf::Duration& msg) {
+    using Duration = std::chrono::duration<TRep, TPeriod>;
+    constexpr std::int64_t kMaxSecondsInDuration =
+        std::chrono::duration_cast<std::chrono::seconds>(Duration::max()).count();
+    constexpr std::int64_t kMinSecondsInDuration =
+        std::chrono::duration_cast<std::chrono::seconds>(Duration::min()).count();
+
+    Duration result;
+
+    if (::google::protobuf::util::TimeUtil::IsDurationValid(msg)) {
+        if (msg.seconds() > kMaxSecondsInDuration - 1) {
+            result = Duration::max();
+        } else if (msg.seconds() < kMinSecondsInDuration + 1) {
+            result = Duration::min();
+        } else {
+            result = std::chrono::duration_cast<Duration>(
+                std::chrono::seconds(msg.seconds()) + std::chrono::nanoseconds(msg.nanos())
+            );
+        }
+    } else {
+        ctx.AddError("invalid 'google.protobuf.Duration' value");
+    }
+
+    return result;
+}
+
+template <typename TRep, typename TPeriod>
+void WriteProtoStruct(
+    WriteContext&,
+    const std::chrono::duration<TRep, TPeriod>& obj,
+    ::google::protobuf::Duration& msg
+) {
+    using TimeUtil = ::google::protobuf::util::TimeUtil;
+    const std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(obj);
+    const std::chrono::nanoseconds nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(obj - seconds);
+
+    if (seconds.count() > TimeUtil::kDurationMaxSeconds) {
+        msg.set_seconds(TimeUtil::kDurationMaxSeconds);
+        msg.set_nanos(0);
+    } else if (seconds.count() < TimeUtil::kDurationMinSeconds) {
+        msg.set_seconds(TimeUtil::kDurationMinSeconds);
+        msg.set_nanos(0);
+    } else {
+        msg.set_seconds(seconds.count());
+        msg.set_nanos(nanos.count());
+    }
+
+    UASSERT(TimeUtil::IsDurationValid(msg));
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss.hpp
new file mode 100644
index 000000000000..bb08f51b8110
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/hh_mm_ss.hpp
+/// @brief Provides `std::chrono::hh_mm_ss` proto struct field support
+
+#include <chrono>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::type {
+class TimeOfDay;
+}  // namespace google::type
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::traits {
+
+template <typename TDuration>
+struct CompatibleMessageTrait<std::chrono::hh_mm_ss<TDuration>> {
+    using Type = ::google::type::TimeOfDay;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp
new file mode 100644
index 000000000000..df61d3921340
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::chrono::hh_mm_ss` conversion
+
+#include <userver/proto-structs/io/std/chrono/hh_mm_ss.hpp>
+
+#include <cstdint>
+
+#include <fmt/format.h>
+#include <google/type/timeofday.pb.h>
+
+#include <userver/proto-structs/io/context.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+template <typename TDuration>
+std::chrono::hh_mm_ss<TDuration>
+ReadProtoStruct(ReadContext& ctx, To<std::chrono::hh_mm_ss<TDuration>>, const ::google::type::TimeOfDay& msg) {
+    using Duration = TDuration;
+    std::chrono::hh_mm_ss<Duration> result;
+
+    // note that `google.type.TimeOfDay` allows 24 for hours (for business closing time) and 60 for seconds (for
+    // leap-seconds) in most general case, however this will not be expected by most users, so we prefer to fail on
+    // such values
+    if ((msg.hours() < 0 || msg.hours() > 23) || (msg.minutes() < 0 || msg.minutes() > 59) ||
+        (msg.seconds() < 0 || msg.seconds() > 59) || (msg.nanos() < 0 || msg.nanos() > 999'999'999)) {
+        ctx.AddError(fmt::format(
+            "{}:{}:{}.{} does not represent a valid time of a day",
+            msg.hours(),
+            msg.minutes(),
+            msg.seconds(),
+            msg.nanos()
+        ));
+        return result;
+    }
+
+    Duration duration = std::chrono::duration_cast<Duration>(
+        std::chrono::hours(msg.hours()) + std::chrono::minutes(msg.minutes()) + std::chrono::seconds(msg.seconds()) +
+        std::chrono::nanoseconds(msg.nanos())
+    );
+    result = std::chrono::hh_mm_ss<Duration>{duration};
+    return result;
+}
+
+template <typename TDuration>
+void WriteProtoStruct(WriteContext& ctx, const std::chrono::hh_mm_ss<TDuration>& obj, ::google::type::TimeOfDay& msg) {
+    if (obj.is_negative() || obj.hours().count() > 23) {
+        ctx.AddError(fmt::format(
+            "{}:{}:{}.{} does not represent a valid time of a day",
+            obj.hours().count(),
+            obj.minutes().count(),
+            obj.seconds().count(),
+            obj.subseconds().count()
+        ));
+    }
+
+    msg.set_hours(static_cast<int32_t>(obj.hours().count()));
+    msg.set_minutes(static_cast<int32_t>(obj.minutes().count()));
+    msg.set_seconds(static_cast<int32_t>(obj.seconds().count()));
+    msg.set_nanos(static_cast<int32_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(obj.subseconds()).count()));
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point.hpp
new file mode 100644
index 000000000000..e646845652c8
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/time_point_fwd.hpp
+/// @brief Provides `std::chrono::time_point` proto struct field support
+
+#include <chrono>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::protobuf {
+class Timestamp;
+}  // namespace google::protobuf
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::traits {
+
+template <>
+struct CompatibleMessageTrait<std::chrono::time_point<std::chrono::system_clock>> {
+    using Type = ::google::protobuf::Timestamp;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point_conv.hpp
new file mode 100644
index 000000000000..2771a8f1a184
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/time_point_conv.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/time_point_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::chrono::time_point` conversion
+
+#include <userver/proto-structs/io/std/chrono/time_point.hpp>
+
+#include <userver/proto-structs/io/fwd.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+std::chrono::time_point<std::chrono::system_clock>
+ReadProtoStruct(ReadContext&, To<std::chrono::time_point<std::chrono::system_clock>>, const ::google::protobuf::Timestamp&);
+
+void WriteProtoStruct(WriteContext&, const std::chrono::time_point<std::chrono::system_clock>&, ::google::protobuf::Timestamp&);
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day.hpp
new file mode 100644
index 000000000000..ecc6f762b6a9
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/year_month_day.hpp
+/// @brief Provides `std::chrono::year_month_day` proto struct field support
+
+#include <chrono>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::type {
+class Date;
+}  // namespace google::type
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::traits {
+
+template <>
+struct CompatibleMessageTrait<std::chrono::year_month_day> {
+    using Type = ::google::type::Date;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day_conv.hpp
new file mode 100644
index 000000000000..9cf219b41784
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/chrono/year_month_day_conv.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/chrono/year_month_day_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::chrono::year_month_day` conversion
+
+#include <userver/proto-structs/io/std/chrono/year_month_day.hpp>
+
+#include <userver/proto-structs/io/fwd.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+std::chrono::year_month_day ReadProtoStruct(ReadContext&, To<std::chrono::year_month_day>, const ::google::type::Date&);
+
+void WriteProtoStruct(WriteContext&, const std::chrono::year_month_day&, ::google::type::Date&);
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t.hpp
new file mode 100644
index 000000000000..b911eb634d45
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/int32_t.hpp
+/// @brief Provides `std::int32_t` proto struct field support
+
+#include <cstdint>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t_conv.hpp
new file mode 100644
index 000000000000..1e0367f851b3
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/int32_t_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/int32_t_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::int32_t` conversion
+
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t.hpp
new file mode 100644
index 000000000000..f3ba7d78223d
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/int64_t.hpp
+/// @brief Provides `std::int64_t` proto struct field support
+
+#include <cstdint>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t_conv.hpp
new file mode 100644
index 000000000000..293bf04bdf4a
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/int64_t_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/int64_t_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::int64_t` conversion
+
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/map.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/map.hpp
new file mode 100644
index 000000000000..c90a2d3d70b8
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/map.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/map.hpp
+/// @brief Provides `std::map` proto struct field support
+
+#include <map>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/map_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/map_conv.hpp
new file mode 100644
index 000000000000..3cee7419a910
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/map_conv.hpp
@@ -0,0 +1,62 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/map_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::map` conversion
+
+#include <userver/proto-structs/io/std/map.hpp>
+
+#include <google/protobuf/map.h>
+
+#include <userver/proto-structs/io/impl/std/any_map_conv.hpp>
+
+namespace proto_structs::io {
+
+template <
+    typename TKey,
+    typename TValue,
+    typename TCompare,
+    typename TAllocator,
+    typename TProtoKey,
+    typename TProtoValue>
+std::map<TKey, TValue, TCompare, TAllocator> ReadProtoField(
+    ReadContext& ctx,
+    To<std::map<TKey, TValue, TCompare, TAllocator>>,
+    int field_number,
+    const ::google::protobuf::Map<TProtoKey, TProtoValue>& message_field
+) {
+    return impl::ReadMap<std::map<TKey, TValue, TCompare, TAllocator>>(ctx, field_number, message_field);
+}
+
+template <
+    typename TKey,
+    typename TValue,
+    typename TCompare,
+    typename TAllocator,
+    typename TProtoKey,
+    typename TProtoValue>
+void WriteProtoField(
+    WriteContext& ctx,
+    const std::map<TKey, TValue, TCompare, TAllocator>& struct_field,
+    int field_number,
+    ::google::protobuf::Map<TProtoKey, TProtoValue>& message_field
+) {
+    impl::WriteMap(ctx, struct_field, field_number, message_field);
+}
+
+template <
+    typename TKey,
+    typename TValue,
+    typename TCompare,
+    typename TAllocator,
+    typename TProtoKey,
+    typename TProtoValue>
+void WriteProtoField(
+    WriteContext& ctx,
+    std::map<TKey, TValue, TCompare, TAllocator>&& struct_field,
+    int field_number,
+    ::google::protobuf::Map<TProtoKey, TProtoValue>& message_field
+) {
+    impl::WriteMap(ctx, std::move(struct_field), field_number, message_field);
+}
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/optional.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/optional.hpp
new file mode 100644
index 000000000000..58c9b5ead014
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/optional.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/optional.hpp
+/// @brief Provides `std::optional` proto struct field support
+
+#include <optional>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/optional_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/optional_conv.hpp
new file mode 100644
index 000000000000..6bad3db3e56c
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/optional_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/optional_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::optional` conversion
+
+#include <userver/proto-structs/io/std/optional.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/scalar.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/scalar.hpp
new file mode 100644
index 000000000000..4f0f146ab42f
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/scalar.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/scalar.hpp
+/// @brief Provides scalar type proto struct field support
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/scalar_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/scalar_conv.hpp
new file mode 100644
index 000000000000..864e0fc4f811
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/scalar_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/scalar_conv.hpp
+/// @brief Provides read/write context class with the ability to handle all scalar conversions
+
+#include <userver/proto-structs/io/context.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/size_t.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/size_t.hpp
new file mode 100644
index 000000000000..1b89b59a1ffd
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/size_t.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/size_t.hpp
+/// @brief Provides `std::size_t` proto struct field support
+
+#include <cstddef>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/size_t_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/size_t_conv.hpp
new file mode 100644
index 000000000000..9e2d2e78d1d0
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/size_t_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/size_t_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::size_t` conversion
+
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/string.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/string.hpp
new file mode 100644
index 000000000000..dddda7aa5c80
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/string.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/string.hpp
+/// @brief Provides `std::string` proto struct field support
+
+#include <string>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/string_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/string_conv.hpp
new file mode 100644
index 000000000000..99f2b9c0c3cb
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/string_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/string_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::string` conversion
+
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t.hpp
new file mode 100644
index 000000000000..3950fce4cca7
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/uint32_t.hpp
+/// @brief Provides `std::uint32_t` proto struct field support
+
+#include <cstdint>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t_conv.hpp
new file mode 100644
index 000000000000..b9321dd3aba2
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/uint32_t_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/uint32_t_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::uint32_t` conversion
+
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t.hpp
new file mode 100644
index 000000000000..bcd1591b66e7
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/uint64_t.hpp
+/// @brief Provides `std::uint64_t` proto struct field support
+
+#include <cstdint>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t_conv.hpp
new file mode 100644
index 000000000000..681e06a11858
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/uint64_t_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/uint64_t_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::uint64_t` conversion
+
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map.hpp
new file mode 100644
index 000000000000..02d6e6b0728b
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/unordered_map.hpp
+/// @brief Provides `std::unordered_map` proto struct field support
+
+#include <unordered_map>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map_conv.hpp
new file mode 100644
index 000000000000..bcbcd96b15bf
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/unordered_map_conv.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/unordered_map_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::unordered_map` conversion
+
+#include <userver/proto-structs/io/std/unordered_map.hpp>
+
+#include <google/protobuf/map.h>
+
+#include <userver/proto-structs/io/impl/std/any_map_conv.hpp>
+
+namespace proto_structs::io {
+
+template <
+    typename TKey,
+    typename TValue,
+    typename THash,
+    typename TKeyEqual,
+    typename TAllocator,
+    typename TProtoKey,
+    typename TProtoValue>
+std::unordered_map<TKey, TValue, THash, TKeyEqual, TAllocator> ReadProtoField(
+    ReadContext& ctx,
+    To<std::unordered_map<TKey, TValue, THash, TKeyEqual, TAllocator>>,
+    int field_number,
+    const ::google::protobuf::Map<TProtoKey, TProtoValue>& message_field
+) {
+    return impl::ReadMap<std::unordered_map<TKey, TValue, THash, TKeyEqual, TAllocator>>(
+        ctx, field_number, message_field
+    );
+}
+
+template <
+    typename TKey,
+    typename TValue,
+    typename THash,
+    typename TKeyEqual,
+    typename TAllocator,
+    typename TProtoKey,
+    typename TProtoValue>
+void WriteProtoField(
+    WriteContext& ctx,
+    const std::unordered_map<TKey, TValue, THash, TKeyEqual, TAllocator>& struct_field,
+    int field_number,
+    ::google::protobuf::Map<TProtoKey, TProtoValue>& message_field
+) {
+    impl::WriteMap(ctx, struct_field, field_number, message_field);
+}
+
+template <
+    typename TKey,
+    typename TValue,
+    typename THash,
+    typename TKeyEqual,
+    typename TAllocator,
+    typename TProtoKey,
+    typename TProtoValue>
+void WriteProtoField(
+    WriteContext& ctx,
+    std::unordered_map<TKey, TValue, THash, TKeyEqual, TAllocator>&& struct_field,
+    int field_number,
+    ::google::protobuf::Map<TProtoKey, TProtoValue>& message_field
+) {
+    impl::WriteMap(ctx, std::move(struct_field), field_number, message_field);
+}
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/vector.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/vector.hpp
new file mode 100644
index 000000000000..125c32698868
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/vector.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/vector.hpp
+/// @brief Provides `std::vector` proto struct field support
+
+#include <vector>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/std/vector_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/std/vector_conv.hpp
new file mode 100644
index 000000000000..e1f323c16c6a
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/std/vector_conv.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+/// @file userver/proto-structs/io/std/vector_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `std::vector` conversion
+
+#include <userver/proto-structs/io/std/vector.hpp>
+
+#include <type_traits>
+
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/repeated_ptr_field.h>
+
+#include <userver/proto-structs/io/context.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace proto_structs::io {
+
+namespace impl {
+
+template <typename TVector, proto_structs::traits::ProtoRepeated TRepeated>
+void WriteVector(WriteContext& ctx, TVector&& struct_field, int field_number, TRepeated& message_field) {
+    message_field.Clear();
+    message_field.Reserve(static_cast<int>(struct_field.size()));
+
+    for (auto& item : struct_field) {
+        if constexpr (std::is_rvalue_reference_v<decltype(struct_field)>) {
+            ctx.WriteField(std::move(item), field_number, *message_field.Add());
+        } else {
+            ctx.WriteField(item, field_number, *message_field.Add());
+        }
+    }
+}
+
+}  // namespace impl
+
+template <typename TItem, typename TAllocator, proto_structs::traits::ProtoRepeated TRepeated>
+std::vector<TItem, TAllocator>
+ReadProtoField(ReadContext& ctx, To<std::vector<TItem, TAllocator>>, int field_number, const TRepeated& message_field) {
+    std::vector<TItem, TAllocator> result;
+    result.reserve(message_field.size());
+
+    for (const auto& item : message_field) {
+        result.push_back(ctx.ReadField<TItem>(field_number, item));
+    }
+
+    return result;
+}
+
+template <typename TItem, typename TAllocator, proto_structs::traits::ProtoRepeated TRepeated>
+void WriteProtoField(
+    WriteContext& ctx,
+    const std::vector<TItem, TAllocator>& struct_field,
+    int field_number,
+    TRepeated& message_field
+) {
+    impl::WriteVector(ctx, struct_field, field_number, message_field);
+}
+
+template <typename TItem, typename TAllocator, proto_structs::traits::ProtoRepeated TRepeated>
+void WriteProtoField(
+    WriteContext& ctx,
+    std::vector<TItem, TAllocator>&& struct_field,
+    int field_number,
+    TRepeated& message_field
+) {
+    impl::WriteVector(ctx, std::move(struct_field), field_number, message_field);
+}
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/supported_types.hpp b/libraries/proto-structs/include/userver/proto-structs/io/supported_types.hpp
new file mode 100644
index 000000000000..1a5991f41e48
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/supported_types.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+/// @file userver/proto-structs/io/supported_types.hpp
+/// @brief Bundle for all `proto-structs/io` headers which provide well-known types support to proto structs
+
+#include <userver/proto-structs/io/std/chrono/duration.hpp>
+#include <userver/proto-structs/io/std/chrono/hh_mm_ss.hpp>
+#include <userver/proto-structs/io/std/chrono/time_point.hpp>
+#include <userver/proto-structs/io/std/chrono/year_month_day.hpp>
+#include <userver/proto-structs/io/std/map.hpp>
+#include <userver/proto-structs/io/std/optional.hpp>
+#include <userver/proto-structs/io/std/scalar.hpp>
+#include <userver/proto-structs/io/std/unordered_map.hpp>
+#include <userver/proto-structs/io/std/vector.hpp>
+
+#include <userver/proto-structs/io/userver/decimal64/decimal.hpp>
+#include <userver/proto-structs/io/userver/proto_structs/any.hpp>
+#include <userver/proto-structs/io/userver/proto_structs/hash_map.hpp>
+#include <userver/proto-structs/io/userver/proto_structs/oneof.hpp>
+#include <userver/proto-structs/io/userver/utils/box.hpp>
+#include <userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp>
+#include <userver/proto-structs/io/userver/utils/strong_typedef.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/supported_types_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/supported_types_conv.hpp
new file mode 100644
index 000000000000..a4d9a0084087
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/supported_types_conv.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+/// @file userver/proto-structs/io/supported_types_conv.hpp
+/// @brief Bundle for all `proto-structs/io` *conv*-headers which provide read/write context class with the ability
+///        to handle well-known types conversion
+
+#include <userver/proto-structs/io/std/chrono/duration_conv.hpp>
+#include <userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp>
+#include <userver/proto-structs/io/std/chrono/time_point_conv.hpp>
+#include <userver/proto-structs/io/std/chrono/year_month_day_conv.hpp>
+#include <userver/proto-structs/io/std/map_conv.hpp>
+#include <userver/proto-structs/io/std/optional_conv.hpp>
+#include <userver/proto-structs/io/std/scalar_conv.hpp>
+#include <userver/proto-structs/io/std/unordered_map_conv.hpp>
+#include <userver/proto-structs/io/std/vector_conv.hpp>
+
+#include <userver/proto-structs/io/userver/decimal64/decimal_conv.hpp>
+#include <userver/proto-structs/io/userver/proto_structs/any_conv.hpp>
+#include <userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp>
+#include <userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp>
+#include <userver/proto-structs/io/userver/utils/box_conv.hpp>
+#include <userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp>
+#include <userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal.hpp
new file mode 100644
index 000000000000..61f92fcd53d7
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/decimal64/decimal64.hpp
+/// @brief Provides `userver::decimal64::Decimal` proto struct field support
+
+#include <userver/decimal64/decimal64.hpp>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::type {
+class Decimal;
+}  // namespace google::type
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::traits {
+
+template <int Prec, typename TRoundPolicy>
+struct CompatibleMessageTrait<decimal64::Decimal<Prec, TRoundPolicy>> {
+    using Type = ::google::type::Decimal;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal_conv.hpp
new file mode 100644
index 000000000000..f376bd212282
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/decimal64/decimal_conv.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/decimal64/decimal64_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::decimal64::Decimal` conversion
+
+#include <userver/proto-structs/io/userver/decimal64/decimal.hpp>
+
+#include <google/type/decimal.pb.h>
+
+#include <userver/proto-structs/io/context.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+template <int Prec, typename TRoundPolicy>
+decimal64::Decimal<Prec, TRoundPolicy>
+ReadProtoStruct(ReadContext& ctx, To<decimal64::Decimal<Prec, TRoundPolicy>>, const ::google::type::Decimal& msg) {
+    using Decimal = decimal64::Decimal<Prec, TRoundPolicy>;
+    Decimal result = {};
+
+    try {
+        result = Decimal(msg.value());
+    } catch (const decimal64::ParseError& e) {
+        ctx.AddError(fmt::format(
+            "'{}' does not represent a valid value for decimal with {} precision, parse error '{}'",
+            msg.value(),
+            Prec,
+            e.what()
+        ));
+    }
+
+    return result;
+}
+
+template <int Prec, typename TRoundPolicy>
+void WriteProtoStruct(WriteContext&, const decimal64::Decimal<Prec, TRoundPolicy>& obj, ::google::type::Decimal& msg) {
+    msg.set_value(ToString(obj));
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any.hpp
new file mode 100644
index 000000000000..bac0c4a33b9e
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/any.hpp
+/// @brief Provides `userver::proto_structs::Any` proto struct field support
+
+#include <userver/proto-structs/any.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any_conv.hpp
new file mode 100644
index 000000000000..e5a3f69572c2
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/any_conv.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/any_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::proto_structs::Any` conversion
+
+#include <userver/proto-structs/io/userver/proto_structs/any.hpp>
+
+#include <userver/proto-structs/io/fwd.hpp>
+
+namespace google::protobuf {
+class Any;
+}  // namespace google::protobuf
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+proto_structs::Any ReadProtoStruct(ReadContext&, To<proto_structs::Any>, const ::google::protobuf::Any&);
+
+void WriteProtoStruct(WriteContext&, const proto_structs::Any&, ::google::protobuf::Any&);
+
+void WriteProtoStruct(WriteContext&, proto_structs::Any&&, ::google::protobuf::Any&);
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map.hpp
new file mode 100644
index 000000000000..ee7ebbb13fef
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/oneof.hpp
+/// @brief Provides `userver::proto_structs::HashMap` proto struct field support
+
+#include <userver/proto-structs/hash_map.hpp>
+#include <userver/proto-structs/io/std/unordered_map.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp
new file mode 100644
index 000000000000..36aecb9ddf2a
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/hash_map_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::proto_structs::HashMap` conversion
+
+#include <userver/proto-structs/io/userver/proto_structs/hash_map.hpp>
+
+#include <userver/proto-structs/io/std/unordered_map_conv.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof.hpp
new file mode 100644
index 000000000000..6a0b8e3a0ae5
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/oneof.hpp
+/// @brief Provides `userver::proto_structs::Oneof` proto struct field support
+
+#include <userver/proto-structs/oneof.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp
new file mode 100644
index 000000000000..c0d3d733af55
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/oneof_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::proto_structs::Oneof` conversion
+
+#include <userver/proto-structs/io/userver/proto_structs/oneof.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp
new file mode 100644
index 000000000000..5cb0f7414c93
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp
+/// @brief Provides @ref userver::proto_structs::UnbreakableDependencyCycle proto struct field support
+
+#include <userver/proto-structs/unbreakable_dependency_cycle.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle_conv.hpp
new file mode 100644
index 000000000000..c780cc70a026
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle_conv.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle_conv.hpp
+/// @brief Provides read/write context class with the ability to handle
+/// @ref proto_structs::UnbreakableDependecyCycle conversion
+
+#include <userver/proto-structs/io/userver/proto_structs/unbreakable_dependency_cycle.hpp>
+
+#include <userver/proto-structs/io/fwd.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+template <typename TField>
+UnbreakableDependencyCycle ReadProtoField(
+    ReadContext&,
+    To<UnbreakableDependencyCycle>,
+    int /*field_number*/,
+    const TField& /*message_field*/
+) {
+    return {};
+}
+
+template <typename TField>
+void WriteProtoField(
+    WriteContext&,
+    const UnbreakableDependencyCycle& /*struct_field*/,
+    int /*field_number*/,
+    TField& /*message_field*/
+) {}
+
+template <typename TField>
+void WriteProtoField(
+    WriteContext&,
+    UnbreakableDependencyCycle&& /*struct_field*/,
+    int /*field_number*/,
+    TField& /*message_field*/
+) {}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box.hpp
new file mode 100644
index 000000000000..6d842d1ddd22
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/utils/box.hpp
+/// @brief Provides `userver::utils::Box` proto struct field support
+
+#include <userver/utils/box.hpp>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::traits {
+
+template <typename T>
+struct CompatibleMessageTrait<utils::Box<T>> {
+    using Type = CompatibleMessageType<T>;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box_conv.hpp
new file mode 100644
index 000000000000..9c691c5736ba
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/box_conv.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/utils/box_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::utils::Box` conversion
+
+#include <userver/proto-structs/io/userver/utils/box.hpp>
+
+#include <userver/proto-structs/io/fwd.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+template <typename T, proto_structs::traits::ProtoMessage TMessage>
+utils::Box<T> ReadProtoStruct(ReadContext& ctx, To<utils::Box<T>>, const TMessage& msg) {
+    return {ReadProtoStruct(ctx, To<T>{}, msg)};
+}
+
+template <typename T, proto_structs::traits::ProtoMessage TMessage>
+void WriteProtoStruct(WriteContext& ctx, const utils::Box<T>& obj, TMessage& msg) {
+    WriteProtoStruct(ctx, *obj, msg);
+}
+
+template <typename T, proto_structs::traits::ProtoMessage TMessage>
+void WriteProtoStruct(WriteContext& ctx, utils::Box<T>&& obj, TMessage& msg) {
+    WriteProtoStruct(ctx, std::move(*obj), msg);
+}
+
+template <typename TStructField, typename TMessageField>
+utils::Box<TStructField>
+ReadProtoField(ReadContext& ctx, To<utils::Box<TStructField>>, int field_number, const TMessageField& message_field) {
+    return {ctx.ReadField<TStructField>(field_number, message_field)};
+}
+
+template <typename TStructField, typename TMessageField>
+void WriteProtoField(
+    WriteContext& ctx,
+    const utils::Box<TStructField>& struct_field,
+    int field_number,
+    TMessageField& message_field
+) {
+    ctx.WriteField(*struct_field, field_number, message_field);
+}
+
+template <typename TStructField, typename TMessageField>
+void WriteProtoField(
+    WriteContext& ctx,
+    utils::Box<TStructField>&& struct_field,
+    int field_number,
+    TMessageField& message_field
+) {
+    ctx.WriteField(std::move(*struct_field), field_number, message_field);
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp
new file mode 100644
index 000000000000..c5b5b580af20
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp
+/// @brief Provides `userver::utils::datetime::TimeOfDay` proto struct field support
+
+#include <userver/utils/time_of_day.hpp>
+
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace google::type {
+class TimeOfDay;
+}  // namespace google::type
+
+namespace proto_structs::traits {
+
+template <typename TDuration>
+struct CompatibleMessageTrait<utils::datetime::TimeOfDay<TDuration>> {
+    using Type = ::google::type::TimeOfDay;
+};
+
+}  // namespace proto_structs::traits
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp
new file mode 100644
index 000000000000..b0cd69ba759c
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/utils/datetime/time_of_day_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::utils::datetime::TimeOfDay` conversion
+
+#include <userver/proto-structs/io/userver/utils/datetime/time_of_day.hpp>
+
+#include <userver/proto-structs/io/std/chrono/hh_mm_ss_conv.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+template <typename TDuration>
+utils::datetime::TimeOfDay<TDuration>
+ReadProtoStruct(ReadContext& ctx, To<utils::datetime::TimeOfDay<TDuration>>, const ::google::type::TimeOfDay& msg) {
+    auto hms = ReadProtoStruct(ctx, To<std::chrono::hh_mm_ss<TDuration>>{}, msg);
+    return utils::datetime::TimeOfDay<TDuration>{hms.to_duration()};
+}
+
+template <typename TDuration>
+void WriteProtoStruct(
+    WriteContext& ctx,
+    const utils::datetime::TimeOfDay<TDuration>& obj,
+    ::google::type::TimeOfDay& msg
+) {
+    std::chrono::hh_mm_ss<TDuration> hms{obj.SinceMidnight()};
+    WriteProtoStruct(ctx, hms, msg);
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef.hpp
new file mode 100644
index 000000000000..c06d39129f87
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/utils/strong_typedef.hpp
+/// @brief Provides `userver::utils::StrongTypedef` proto struct field support
+
+#include <userver/utils/strong_typedef.hpp>
diff --git a/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp
new file mode 100644
index 000000000000..3d7bdde7cd4e
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+/// @file userver/proto-structs/io/userver/utils/strong_typedef_conv.hpp
+/// @brief Provides read/write context class with the ability to handle `userver::utils::StrongTypedef` conversion
+
+#include <userver/proto-structs/io/userver/utils/strong_typedef.hpp>
+
+#include <userver/proto-structs/io/context.hpp>
+
+namespace proto_structs::io {
+
+template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TEnable, typename TMessageField>
+utils::StrongTypedef<TTag, TStructField, Ops, TEnable> ReadProtoField(
+    ReadContext& ctx,
+    To<utils::StrongTypedef<TTag, TStructField, Ops, TEnable>>,
+    int field_number,
+    const TMessageField& message_field
+) {
+    using Type = utils::StrongTypedef<TTag, TStructField, Ops, TEnable>;
+    return Type{ctx.ReadField<TStructField>(field_number, message_field)};
+}
+
+template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TEnable, typename TMessageField>
+void WriteProtoField(
+    WriteContext& ctx,
+    const utils::StrongTypedef<TTag, TStructField, Ops, TEnable>& struct_field,
+    int field_number,
+    TMessageField& message_field
+) {
+    ctx.WriteField(struct_field.GetUnderlying(), field_number, message_field);
+}
+
+template <typename TTag, typename TStructField, utils::StrongTypedefOps Ops, typename TEnable, typename TMessageField>
+void WriteProtoField(
+    WriteContext& ctx,
+    utils::StrongTypedef<TTag, TStructField, Ops, TEnable>&& struct_field,
+    int field_number,
+    TMessageField& message_field
+) {
+    ctx.WriteField(std::move(struct_field).GetUnderlying(), field_number, message_field);
+}
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/include/userver/proto-structs/oneof.hpp b/libraries/proto-structs/include/userver/proto-structs/oneof.hpp
new file mode 100644
index 000000000000..7822dcf65ad0
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/oneof.hpp
@@ -0,0 +1,130 @@
+#pragma once
+
+/// @file userver/proto-structs/oneof.hpp
+/// @brief Contains type to represent `oneof` protobuf message fields in a proto struct
+
+#include <optional>
+#include <utility>
+#include <variant>
+
+#include <userver/proto-structs/exceptions.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+/// @brief Wrapper for `oneof` protobuf message fields
+/// @tparam TFields `oneof` field types
+template <typename... TFields>
+class Oneof {
+public:
+    /// @brief Type of this `Oneof`
+    using Base = Oneof;
+
+    /// @brief Number of fields in the oneof
+    static constexpr std::size_t kSize = sizeof...(TFields);
+
+    static_assert(kSize > 0, "Oneof should contain at least one field");
+
+    /// @brief Creates oneof without any field set
+    constexpr Oneof() = default;
+
+    /// @brief Creates oneof wrapper initializing @a index field
+    template <std::size_t Index, typename... TArgs>
+    constexpr Oneof(std::in_place_index_t<Index> index, TArgs&&... args)
+        : storage_(std::variant<TFields...>(index, std::forward<TArgs>(args)...)) {}
+
+    /// @brief Returns zero-based index of the alternative held by the oneof.
+    /// If oneof does not contain any field, returns @ref proto_structs::kOneofNpos .
+    [[nodiscard]] constexpr std::size_t GetIndex() const noexcept { return storage_ ? storage_->index() : kOneofNpos; }
+
+    /// @brief Returns `true` of oneof contains @a index field
+    [[nodiscard]] constexpr bool Contains(std::size_t index) const noexcept {
+        return storage_ && storage_->index() == index;
+    }
+
+    /// @brief Returns `true` of oneof contains some field
+    [[nodiscard]] constexpr bool ContainsAny() const noexcept { return storage_.has_value(); }
+
+    /// @brief Returns `Index` field
+    /// @throws OneofAccessError if `Index` field is not set
+    template <std::size_t Index>
+    [[nodiscard]] constexpr const OneofAlternativeType<Index, Oneof>& Get() const& {
+        if (!Contains(Index)) {
+            throw OneofAccessError(Index);
+        }
+
+        return std::get<Index>(*storage_);
+    }
+
+    /// @brief Returns `Index` field
+    /// @throws OneofAccessError if `Index` field is not set
+    template <std::size_t Index>
+    [[nodiscard]] constexpr OneofAlternativeType<Index, Oneof>& Get() & {
+        if (!Contains(Index)) {
+            throw OneofAccessError(Index);
+        }
+
+        return std::get<Index>(*storage_);
+    }
+
+    /// @brief Returns `Index` field
+    /// @throws OneofAccessError if `Index` field is not set
+    template <std::size_t Index>
+    [[nodiscard]] constexpr OneofAlternativeType<Index, Oneof>&& Get() && {
+        if (!Contains(Index)) {
+            throw OneofAccessError(Index);
+        }
+
+        return std::get<Index>(*std::move(storage_));
+    }
+
+    /// @brief Initializes `Index` field in-place and returns it
+    /// @tparam TArgs arguments to pass to `Index` field constructor
+    template <std::size_t Index, typename... TArgs>
+    constexpr OneofAlternativeType<Index, Oneof>& Emplace(TArgs&&... args) {
+        storage_.emplace(std::in_place_index<Index>, std::forward<TArgs>(args)...);
+        return std::get<Index>(*storage_);
+    }
+
+    template <std::size_t Index>
+    constexpr void Set(const OneofAlternativeType<Index, Oneof>& value) {
+        Emplace<Index>(value);
+    }
+
+    template <std::size_t Index>
+    constexpr void Set(OneofAlternativeType<Index, Oneof>&& value) {
+        Emplace<Index>(std::move(value));
+    }
+
+    /// @brief If field at `Index` is not set, sets it. Returns a mutable reference to the field.
+    template <std::size_t Index>
+    constexpr OneofAlternativeType<Index, Oneof>& GetMutable() {
+        if (!Contains(Index)) {
+            Emplace<Index>();
+        }
+
+        return std::get<Index>(*storage_);
+    }
+
+    /// @brief Clear field `Index` if it is set
+    void Clear(std::size_t index) noexcept {
+        if (Contains(index)) {
+            ClearOneof();
+        }
+    }
+
+    /// @brief Clears oneof
+    void ClearOneof() noexcept { storage_.reset(); }
+
+    /// @brief Returns `true` if oneof contains some field
+    constexpr explicit operator bool() const noexcept { return ContainsAny(); }
+
+private:
+    std::optional<std::variant<TFields...>> storage_;
+};
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/type_mapping.hpp b/libraries/proto-structs/include/userver/proto-structs/type_mapping.hpp
new file mode 100644
index 000000000000..9b983eafe95f
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/type_mapping.hpp
@@ -0,0 +1,139 @@
+#pragma once
+
+/// @file userver/proto-structs/type_mapping.hpp
+/// @brief Concepts and traits for checking proto struct and protobuf message compatability
+
+#include <cstdint>
+#include <iosfwd>
+#include <type_traits>
+
+#include <userver/proto-structs/impl/traits_light.hpp>
+#include <userver/utils/meta_light.hpp>
+#include <userver/utils/strong_typedef_fwd.hpp>
+
+namespace google::protobuf {
+
+class Message;
+
+template <typename T>
+class RepeatedField;
+
+template <typename T>
+class RepeatedPtrField;
+
+}  // namespace google::protobuf
+
+USERVER_NAMESPACE_BEGIN
+
+/// @brief Namespace contains types for obtaining meta information (traits, concepts, etc.)
+namespace proto_structs::traits {
+
+/// @brief Concept representing protobuf scalar type
+template <typename T>
+concept ProtoScalar =
+    std::is_same_v<std::remove_cv_t<T>, bool> || std::is_same_v<std::remove_cv_t<T>, std::int32_t> ||
+    std::is_same_v<std::remove_cv_t<T>, std::int64_t> || std::is_same_v<std::remove_cv_t<T>, std::uint32_t> ||
+    std::is_same_v<std::remove_cv_t<T>, std::uint64_t> || std::is_same_v<std::remove_cv_t<T>, std::size_t> ||
+    std::is_same_v<std::remove_cv_t<T>, float> || std::is_same_v<std::remove_cv_t<T>, double> ||
+    std::is_same_v<std::remove_cv_t<T>, std::string> || std::is_enum_v<T>;
+
+/// @brief Protobuf type representing `repeated` fields in the `protoc`-generated code
+template <typename T>
+concept ProtoRepeated = meta::kIsCvInstantiationOf<::google::protobuf::RepeatedField, T> ||
+                        meta::kIsCvInstantiationOf<::google::protobuf::RepeatedPtrField, T>;
+
+/// @brief Protobuf message type generated by `protoc`
+template <typename T>
+concept ProtoMessage = std::is_base_of_v<::google::protobuf::Message, T> && !
+std::is_same_v<::google::protobuf::Message, std::remove_cv_t<T>>;
+
+/// @brief Trait that marks struct/class type as compatible to some protobuf message
+/// By default, trait uses `T::ProtobufMessage` as its nested `Type` definition. User can also specialize
+/// `CompatibleMessageTrait` for any type in the `proto_structs::traits` namespace if he can not modify the
+/// code which contains `T` definition:
+/// ```cpp
+/// namespace proto_structs::traits {
+///   template<>
+///   struct CompatibleMessageTrait<ExternalStruct> {
+///     using Type = SomeProtoMessage;
+///   }
+/// }
+/// ```
+template <typename T>
+struct CompatibleMessageTrait {
+    using Type = void;
+};
+
+template <typename T>
+requires requires { typename T::ProtobufMessage; }
+struct CompatibleMessageTrait<T> {
+    using Type = typename T::ProtobufMessage;
+};
+
+template <typename T>
+using CompatibleMessageType = typename CompatibleMessageTrait<std::remove_cv_t<T>>::Type;
+
+/// @brief Proto struct intended for conversion to/from protobuf message type
+template <typename T>
+concept ProtoStruct = std::is_class_v<T> && !
+std::is_same_v<CompatibleMessageType<T>, void>;
+
+/// @brief Specifies that proto struct `T` is compatible with message `U`
+/// @tparam T proto struct type
+/// @tparam U protobuf message type
+template <typename T, typename U>
+concept CompatibleWith = ProtoStruct<T> && std::is_same_v<CompatibleMessageType<T>, std::remove_cv_t<U>>;
+
+}  // namespace proto_structs::traits
+
+namespace proto_structs {
+
+template <typename... TFields>
+class Oneof;
+
+namespace traits {
+
+/// @brief Concept of the @ref proto_structs::Oneof
+template <typename T>
+concept Oneof = impl::traits::InheritsFromInstantiation<proto_structs::Oneof, T>;
+
+}  // namespace traits
+
+namespace impl {
+
+template <std::size_t N, typename T, typename... TTail>
+struct GetOneofNthType {
+    using Type = typename GetOneofNthType<N - 1, TTail...>::Type;
+};
+
+template <typename T, typename... TTail>
+struct GetOneofNthType<0, T, TTail...> {
+    using Type = T;
+};
+
+template <std::size_t Index, typename T>
+struct OneofAlternativeTrait {
+    static_assert(sizeof(T) && false, "Trait should be applied to 'Oneof'");
+};
+
+template <std::size_t Index, typename... TFields>
+struct OneofAlternativeTrait<Index, Oneof<TFields...>> {
+    static_assert(Index < sizeof...(TFields));
+    using Type = GetOneofNthType<Index, TFields...>::Type;
+};
+
+}  // namespace impl
+
+/// @brief Special index value used to indicate `oneof` without any field set
+inline constexpr std::size_t kOneofNpos = -1;
+
+/// @brief Provides information about @ref proto_structs::Oneof field type at position `Index`
+template <std::size_t Index, traits::Oneof TOneof>
+using OneofAlternativeTrait = impl::OneofAlternativeTrait<Index, typename TOneof::Base>;
+
+template <std::size_t Index, typename TOneof>
+using OneofAlternativeType = OneofAlternativeTrait<Index, TOneof>::Type;
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/include/userver/proto-structs/unbreakable_dependency_cycle.hpp b/libraries/proto-structs/include/userver/proto-structs/unbreakable_dependency_cycle.hpp
new file mode 100644
index 000000000000..c2efaee38f1e
--- /dev/null
+++ b/libraries/proto-structs/include/userver/proto-structs/unbreakable_dependency_cycle.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+/// @file userver/proto-structs/unbreakable_dependency_cycle.hpp
+/// @brief @copybrief proto_structs::UnbreakableDependencyCycle
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+/// @brief A type that is generated for a field that participates in an unbreakable dependency cycle.
+///
+/// For example:
+///
+/// @code
+/// struct A {
+///     struct Inner {
+///         B::Inner field;
+///     };
+/// };
+///
+/// struct B {
+///     struct Inner {
+///         A::Inner field;
+///     };
+/// };
+/// @endcode
+///
+/// Nested types cannot be forwarded and wrapped in @ref utils::Box, so we give up.
+/// At least we generate something valid for other fields and types in the file,
+/// so that if the current field is not actually needed, then proto structs are usable.
+struct UnbreakableDependencyCycle final {
+    /// We cannot actually compare the contents of such field, because they are not parsed into proto structs.
+    /// Transitively, any data structure containing such field is not comparable.
+    bool operator==(const UnbreakableDependencyCycle& other) const = delete;
+};
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/proto/userver/structs/annotations.proto b/libraries/proto-structs/proto/userver/structs/annotations.proto
new file mode 100644
index 000000000000..ada4d88cd4e9
--- /dev/null
+++ b/libraries/proto-structs/proto/userver/structs/annotations.proto
@@ -0,0 +1,144 @@
+syntax = "proto2";
+package userver.structs;
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/proto/userver/structs;protostructs";
+
+import "google/protobuf/descriptor.proto";
+
+extend google.protobuf.FileOptions {
+  optional FileAnnotations file = 1241;
+}
+
+extend google.protobuf.MessageOptions {
+  optional MessageAnnotations message = 1241;
+}
+
+extend google.protobuf.OneofOptions {
+  optional OneofAnnotations oneof = 1241;
+}
+
+extend google.protobuf.FieldOptions {
+  optional FieldAnnotations field = 1241;
+}
+
+// Time resolution.
+enum TimeRes {
+  TIME_RES_UNSPECIFIED = 0; // default, nanonseconds
+  TIME_RES_NANOS = 1;
+  TIME_RES_MICROS = 2;
+  TIME_RES_MILLIS = 3;
+  TIME_RES_SECONDS = 4;
+}
+
+// File-level code generation annotations.
+message FileAnnotations {
+  // Always emit exact struct types.
+  //
+  // If set, codegen will not emit std or userver types for some well-known
+  // protobuf message types (for example, `std::chrono::time_point` for
+  // `google.protobuf.Timestamp`) and will generate compatible struct types
+  // for them instead.
+  optional bool exact = 1;
+}
+
+// Message-level code generation annotations.
+message MessageAnnotations {
+  // Always emit exact struct types.
+  //
+  // If set, codegen will not emit std or userver types for some well-known
+  // protobuf message types (for example, `std::chrono::time_point` for
+  // `google.protobuf.Timestamp`) and will generate compatible struct types
+  // for them instead.
+  optional bool exact = 1;
+
+  // Wrap generated struct type in `userver::utils::Box` in all occurances of
+  // the message type.
+  //
+  // Using generated struct type indirectly is necessary in cases when two
+  // or more message types form circular dependency. Without `indirect` this
+  // will lead to circular dependency in the generated C++ code which will
+  // fail to compile.
+  //
+  // Also `indirect` may be useful for large message types with plenty of
+  // fields, because it will trigger compatible struct allocation in the
+  // heap instead of a stack.
+  optional bool indirect = 2;
+}
+
+// Oneof-level code generation annotations
+message OneofAnnotations {
+    // Name of the C++ class generated to represent `oneof`
+    //
+    // By default, codegen uses oneof's name converted to CamelCase as a name
+    // for the generated C++ type. This annotations allows override this
+    // behavior.
+    optional string generated_type_name = 1;
+}
+
+// Field-level code generation annotations.
+message FieldAnnotations {
+  // Always emit exact struct types.
+  //
+  // If set, codegen will not emit std or userver types for some well-known
+  // protobuf message types (for example, `std::chrono::time_point` for
+  // `google.protobuf.Timestamp`) and will generate compatible struct types
+  // for them instead.
+  //
+  // Only meaningful for fields having protobuf message type, otherwise ignored.
+  optional bool exact = 1;
+
+  // Wrap generated struct type in `userver::utils::Box` in all occurances of
+  // the message type.
+  //
+  // Using generated struct type indirectly is necessary in cases when two
+  // or more message types form circular dependency. Without `indirect` this
+  // will lead to circular dependency in the generated C++ code which will
+  // fail to compile.
+  //
+  // Also `indirect` may be useful for large message types with plenty of
+  // fields, because it will trigger compatible struct allocation in the
+  // heap instead of a stack.
+  //
+  // Only meaningful for fields having protobuf message type, otherwise ignored.
+  optional bool indirect = 2;
+
+  // Duration resolution.
+  //
+  // Determines resolution which will be used for `std::chrono::duration`
+  // generated for `google.protobuf.Duration`. During conversion values
+  // of `google.protobuf.Duration` which do not fit inside
+  // `std::chrono::duration` are capped to its max/min.
+  //
+  // Only meaningful for fields having `google.protobuf.Duration` type.
+  optional TimeRes resolution = 3;
+
+  // Decimal precision.
+  //
+  // Determines precision which will be used for `userver::decimal64::Decimal`
+  // generated for `google.type.Decimal`. If protobuf's `Decimal` value has
+  // unsupported format or its precision is greater than value specified in
+  // the annotation, conversion will fail.
+  //
+  // Also note, that codegen will not emit `userver::decimal64::Decimal` unless
+  // precision is explicitly specified with this annotation. Instead, struct
+  // compatible to `google.type.Decimal` will be emitted.
+  //
+  // Only meaningful for fields having `google.type.Decimal` type.
+  optional int32 precision = 4;
+
+  // Emit ordered map.
+  //
+  // Tells codegen to emit ordered map (i.e. `std::map`) instead of unordered
+  // (i.e. `std::unordered_map`).
+  //
+  // Only meaningful for fields having protobuf map type.
+  optional bool ordered = 5;
+
+  // Use unsafe hash function in the emitted unordered map.
+  //
+  // By default, codegen uses hash function which is sustainable to HashDOS
+  // attack.
+  //
+  // Only meaningful for fields having protobuf map type.
+  optional bool use_unsafe_hash = 6;
+}
diff --git a/libraries/proto-structs/src/proto-structs/exceptions.cpp b/libraries/proto-structs/src/proto-structs/exceptions.cpp
new file mode 100644
index 000000000000..2bbe65c1a586
--- /dev/null
+++ b/libraries/proto-structs/src/proto-structs/exceptions.cpp
@@ -0,0 +1,26 @@
+#include <userver/proto-structs/exceptions.hpp>
+
+#include <fmt/format.h>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs {
+
+ReadError::ReadError(const std::string_view path, const std::string_view reason)
+    : ConversionError(fmt::format("Failed to read protobuf message field '{}' ({})", path, reason)) {}
+
+WriteError::WriteError(const std::string_view path, const std::string_view reason)
+    : ConversionError(fmt::format("Failed to write protobuf message field '{}' ({})", path, reason)) {}
+
+OneofAccessError::OneofAccessError(const std::size_t field_idx)
+    : Error(fmt::format("Oneof field is not set (index = {})", field_idx)) {}
+
+AnyPackError::AnyPackError(const std::string_view message_name)
+    : Error(fmt::format("Failed to pack message '{}' to 'google.protobuf.Any'", message_name)) {}
+
+AnyUnpackError::AnyUnpackError(const std::string_view message_name)
+    : Error(fmt::format("Failed to unpack message '{}' from 'google.protobuf.Any'", message_name)) {}
+
+}  // namespace proto_structs
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/src/proto-structs/io/context_base.cpp b/libraries/proto-structs/src/proto-structs/io/context_base.cpp
new file mode 100644
index 000000000000..b46de8b61101
--- /dev/null
+++ b/libraries/proto-structs/src/proto-structs/io/context_base.cpp
@@ -0,0 +1,108 @@
+#include <userver/proto-structs/io/context.hpp>
+
+#include <fmt/format.h>
+#include <google/protobuf/descriptor.h>
+
+#include <userver/utils/impl/internal_tag.hpp>
+
+namespace proto_structs::io {
+
+std::string Context::GetCurrentPath(int current_field_number) const {
+    const ::google::protobuf::Descriptor* last_message_desc = nullptr;
+    auto result = GetCurrentPathImpl(last_message_desc);
+
+    if (last_message_desc) {
+        auto field_desc = last_message_desc->FindFieldByNumber(current_field_number);
+
+        if (field_desc) {
+            result.append(fmt::format(".{}", field_desc->name()));
+        } else {
+            result.append(fmt::format(".<unknown_{}>", current_field_number));
+        }
+    }
+
+    return result;
+}
+
+std::string Context::GetCurrentPath(const ::google::protobuf::FieldDescriptor& current_field_desc) const {
+    const ::google::protobuf::Descriptor* last_message_desc = nullptr;
+    auto result = GetCurrentPathImpl(last_message_desc);
+
+    if (last_message_desc) {
+        if (current_field_desc.containing_type() == last_message_desc) {
+            result.append(fmt::format(".{}", current_field_desc.name()));
+        } else {
+            result.append(fmt::format(".<unknown_{}>", current_field_desc.number()));
+        }
+    }
+
+    return result;
+}
+
+std::string Context::GetCurrentPath() const {
+    const ::google::protobuf::Descriptor* last_message_desc = nullptr;
+    return GetCurrentPathImpl(last_message_desc);
+}
+
+std::string Context::GetCurrentPathImpl(const ::google::protobuf::Descriptor*& last_message_desc) const {
+    auto current_ptr = &top_message_desc_;
+
+    std::string result;
+    result.reserve(128);
+    result = current_ptr->full_name();
+
+    for (const auto& field_number : path_) {
+        auto field_desc = current_ptr->FindFieldByNumber(field_number);
+
+        if (field_desc && field_desc->type() == ::google::protobuf::FieldDescriptor::TYPE_MESSAGE) {
+            result.append(fmt::format(".{}", field_desc->name()));
+            current_ptr = field_desc->message_type();
+        } else {
+            result.append(fmt::format(".<unknown_{}>", field_number));
+            current_ptr = nullptr;
+            break;
+        }
+    }
+
+    last_message_desc = current_ptr;
+    return result;
+}
+
+template <typename TError>
+const std::vector<TError>& ContextWithErrors<TError>::GetErrors(utils::impl::InternalTag) const& noexcept {
+    return errors_;
+}
+
+template <typename TError>
+std::vector<TError>&& ContextWithErrors<TError>::GetErrors(utils::impl::InternalTag) && noexcept {
+    return std::move(errors_);
+}
+
+template <typename TError>
+void ContextWithErrors<TError>::AddError(int field_number, std::string_view reason) {
+    AddError(GetCurrentPath(field_number), reason);
+}
+
+template <typename TError>
+void ContextWithErrors<TError>::AddError(
+    const ::google::protobuf::FieldDescriptor& field_desc,
+    std::string_view reason
+) {
+    AddError(GetCurrentPath(field_desc), reason);
+}
+
+template <typename TError>
+void ContextWithErrors<TError>::AddError(std::string_view reason) {
+    AddError(GetCurrentPath(), reason);
+}
+
+template <typename TError>
+void ContextWithErrors<TError>::AddError(std::string_view path, std::string_view reason) {
+    errors_.emplace_back(path, reason);
+    throw Error{errors_.back()};
+}
+
+template class ContextWithErrors<ReadError>;
+template class ContextWithErrors<WriteError>;
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/src/proto-structs/io/impl/field_accessor.cpp b/libraries/proto-structs/src/proto-structs/io/impl/field_accessor.cpp
new file mode 100644
index 000000000000..6662c714fe61
--- /dev/null
+++ b/libraries/proto-structs/src/proto-structs/io/impl/field_accessor.cpp
@@ -0,0 +1,19 @@
+#include <userver/proto-structs/io/impl/field_accessor.hpp>
+
+#include <google/protobuf/message.h>
+
+#include <userver/utils/assert.hpp>
+
+namespace proto_structs::io::impl {
+
+const ::google::protobuf::FieldDescriptor& FieldAccessor::GetFieldDescriptor() const noexcept {
+    if (field_desc_) {
+        return *field_desc_;
+    }
+
+    field_desc_ = message_.GetDescriptor()->FindFieldByNumber(field_number_);
+    UASSERT(field_desc_);
+    return *field_desc_;
+}
+
+}  // namespace proto_structs::io::impl
diff --git a/libraries/proto-structs/src/proto-structs/io/std/chrono/time_point.cpp b/libraries/proto-structs/src/proto-structs/io/std/chrono/time_point.cpp
new file mode 100644
index 000000000000..67f22970fe27
--- /dev/null
+++ b/libraries/proto-structs/src/proto-structs/io/std/chrono/time_point.cpp
@@ -0,0 +1,68 @@
+#include <userver/proto-structs/io/std/chrono/time_point.hpp>
+
+#include <google/protobuf/timestamp.pb.h>
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/proto-structs/io/context.hpp>
+#include <userver/utils/assert.hpp>
+
+namespace proto_structs::io {
+
+std::chrono::time_point<std::chrono::system_clock> ReadProtoStruct(
+    ReadContext& ctx,
+    To<std::chrono::time_point<std::chrono::system_clock>>,
+    const ::google::protobuf::Timestamp& msg
+) {
+    using TimePoint = std::chrono::time_point<std::chrono::system_clock>;
+    constexpr std::int64_t kMaxSecondsInTimePoint =
+        std::chrono::duration_cast<std::chrono::seconds>(TimePoint::duration::max()).count();
+    constexpr std::int64_t kMinSecondsInTimePoint =
+        std::chrono::duration_cast<std::chrono::seconds>(TimePoint::duration::min()).count();
+
+    TimePoint result;
+
+    if (::google::protobuf::util::TimeUtil::IsTimestampValid(msg)) {
+        if (msg.seconds() > kMaxSecondsInTimePoint - 1) {
+            result = TimePoint::max();
+        } else if (msg.seconds() < kMinSecondsInTimePoint) {
+            result = TimePoint::min();
+        } else {
+            result = TimePoint{std::chrono::duration_cast<TimePoint::duration>(
+                std::chrono::seconds(msg.seconds()) + std::chrono::nanoseconds(msg.nanos())
+            )};
+        }
+    } else {
+        ctx.AddError("invalid 'google.protobuf.Timestamp' value");
+    }
+
+    return result;
+}
+
+void WriteProtoStruct(
+    WriteContext&,
+    const std::chrono::time_point<std::chrono::system_clock>& obj,
+    ::google::protobuf::Timestamp& msg
+) {
+    using TimeUtil = ::google::protobuf::util::TimeUtil;
+    const auto seconds = std::chrono::duration_cast<std::chrono::seconds>(obj.time_since_epoch());
+    const std::chrono::nanoseconds nanos = obj.time_since_epoch() - seconds;
+
+    if (seconds.count() > TimeUtil::kTimestampMaxSeconds) {
+        msg.set_seconds(TimeUtil::kTimestampMaxSeconds);
+        msg.set_nanos(0);
+    } else if (seconds.count() < TimeUtil::kTimestampMinSeconds) {
+        msg.set_seconds(TimeUtil::kTimestampMinSeconds);
+        msg.set_nanos(0);
+    } else if (nanos.count() >= 0) {
+        msg.set_seconds(seconds.count());
+        msg.set_nanos(nanos.count());
+    } else {
+        // Timestamp.nanos should be from [0, 999'999'999]
+        msg.set_seconds(seconds.count() - 1);
+        msg.set_nanos(nanos.count() + 1'000'000'000);
+    }
+
+    UASSERT(TimeUtil::IsTimestampValid(msg));
+}
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/src/proto-structs/io/std/chrono/year_month_day.cpp b/libraries/proto-structs/src/proto-structs/io/std/chrono/year_month_day.cpp
new file mode 100644
index 000000000000..d30e27cac658
--- /dev/null
+++ b/libraries/proto-structs/src/proto-structs/io/std/chrono/year_month_day.cpp
@@ -0,0 +1,69 @@
+#include <userver/proto-structs/io/std/chrono/year_month_day.hpp>
+
+#include <cstdint>
+
+#include <fmt/format.h>
+#include <google/type/date.pb.h>
+
+#include <userver/proto-structs/io/context.hpp>
+
+namespace proto_structs::io {
+
+constexpr int kMaxYearInGoogleDate = 9999;
+constexpr int kMinYearInGoogleDate = 1;
+
+std::chrono::year_month_day
+ReadProtoStruct(ReadContext& ctx, To<std::chrono::year_month_day>, const ::google::type::Date& msg) {
+    std::chrono::year_month_day result = {};
+
+    if (msg.year() < kMinYearInGoogleDate || msg.year() > kMaxYearInGoogleDate) {
+        ctx.AddError(fmt::format(
+            "'year' component value {} is not in a valid range [{}, {}]",
+            msg.year(),
+            kMinYearInGoogleDate,
+            kMaxYearInGoogleDate
+        ));
+        return result;
+    }
+
+    result = {
+        std::chrono::year{msg.year()},
+        std::chrono::month{static_cast<unsigned>(msg.month())},
+        std::chrono::day{static_cast<unsigned>(msg.day())}};
+
+    if (!result.ok()) {
+        ctx.AddError(fmt::format("{}/{}/{} (y/m/d) does not represent a valid date", msg.year(), msg.month(), msg.day())
+        );
+        return result;
+    }
+
+    return result;
+}
+
+void WriteProtoStruct(WriteContext& ctx, const std::chrono::year_month_day& obj, ::google::type::Date& msg) {
+    if (!obj.ok()) {
+        ctx.AddError(fmt::format(
+            "{}/{}/{} (y/m/d) does not represent a valid date",
+            static_cast<int>(obj.year()),
+            static_cast<unsigned>(obj.month()),
+            static_cast<unsigned>(obj.day())
+        ));
+        return;
+    }
+
+    if (static_cast<int>(obj.year()) < kMinYearInGoogleDate || static_cast<int>(obj.year()) > kMaxYearInGoogleDate) {
+        ctx.AddError(fmt::format(
+            "'year' component value {} is not in a valid range [{}, {}]",
+            static_cast<int>(obj.year()),
+            kMinYearInGoogleDate,
+            kMaxYearInGoogleDate
+        ));
+        return;
+    }
+
+    msg.set_year(static_cast<int32_t>(obj.year()));
+    msg.set_month(static_cast<int32_t>(static_cast<unsigned>(obj.month())));
+    msg.set_day(static_cast<int32_t>(static_cast<unsigned>(obj.day())));
+}
+
+}  // namespace proto_structs::io
diff --git a/libraries/proto-structs/src/proto-structs/io/userver/proto_structs/any.cpp b/libraries/proto-structs/src/proto-structs/io/userver/proto_structs/any.cpp
new file mode 100644
index 000000000000..62bb509255de
--- /dev/null
+++ b/libraries/proto-structs/src/proto-structs/io/userver/proto_structs/any.cpp
@@ -0,0 +1,23 @@
+#include <userver/proto-structs/io/userver/proto_structs/any.hpp>
+
+#include <userver/proto-structs/any.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::io {
+
+proto_structs::Any ReadProtoStruct(ReadContext&, To<proto_structs::Any>, const ::google::protobuf::Any& msg) {
+    return proto_structs::Any{msg};
+}
+
+void WriteProtoStruct(WriteContext&, const proto_structs::Any& obj, ::google::protobuf::Any& msg) {
+    msg = obj.GetProtobufAny();
+}
+
+void WriteProtoStruct(WriteContext&, proto_structs::Any&& obj, ::google::protobuf::Any& msg) {
+    msg = std::move(obj).GetProtobufAny();
+}
+
+}  // namespace proto_structs::io
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/tests/any_test.cpp b/libraries/proto-structs/tests/any_test.cpp
new file mode 100644
index 000000000000..0afb0112f0d9
--- /dev/null
+++ b/libraries/proto-structs/tests/any_test.cpp
@@ -0,0 +1,158 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <chrono>
+
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/proto-structs/any.hpp>
+#include <userver/proto-structs/io/std/chrono/duration_conv.hpp>
+
+#include "messages.pb.h"
+#include "struct_simple.hpp"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::tests {
+
+TEST(AnyTest, Ctor) {
+    Any any_default;
+    google::protobuf::Any pbuf_any;
+
+    messages::Simple original;
+    original.set_f1(1001);
+
+    ASSERT_TRUE(pbuf_any.PackFrom(original));
+    EXPECT_TRUE(any_default.GetProtobufAny().type_url().empty());
+    EXPECT_TRUE(std::move(any_default).GetProtobufAny().value().empty());
+
+    Any any = Any{pbuf_any};
+    messages::Simple msg;
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(msg.f1(), original.f1());
+
+    msg.clear_f1();
+
+    Any any_copy(any);
+
+    ASSERT_TRUE(std::move(any_copy).GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(msg.f1(), original.f1());
+
+    any_copy = Any{};
+    any_copy = any;
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(msg.f1(), original.f1());
+
+    Any any_move(std::move(any_copy));
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(msg.f1(), original.f1());
+
+    any_copy = Any{};
+    any_copy = std::move(any_move);
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(msg.f1(), original.f1());
+}
+
+TEST(AnyTest, Pack) {
+    structs::Simple obj{.f1 = 1001};
+    Any any(obj);
+
+    EXPECT_TRUE(any.Is<structs::Simple>());
+    EXPECT_TRUE(any.Is<messages::Simple>());
+
+    messages::Simple msg;
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(obj.f1, msg.f1());
+
+    any = {};
+    obj.f1 = 1002;
+    msg.clear_f1();
+
+    EXPECT_FALSE(any.Is<structs::Simple>());
+    EXPECT_FALSE(any.Is<messages::Simple>());
+    ASSERT_NO_THROW(any = obj);
+    EXPECT_TRUE(any.Is<structs::Simple>());
+    EXPECT_TRUE(any.Is<messages::Simple>());
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(obj.f1, msg.f1());
+
+    any = {};
+    obj.f1 = 1003;
+    msg.clear_f1();
+
+    EXPECT_FALSE(any.Is<structs::Simple>());
+    EXPECT_FALSE(any.Is<messages::Simple>());
+    ASSERT_NO_THROW(any.Pack(structs::Simple{obj}));
+    EXPECT_TRUE(any.Is<structs::Simple>());
+    EXPECT_TRUE(any.Is<messages::Simple>());
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(obj.f1, msg.f1());
+
+    any = {};
+    obj.f1 = 1004;
+    msg.set_f1(obj.f1);
+
+    EXPECT_FALSE(any.Is<structs::Simple>());
+    EXPECT_FALSE(any.Is<messages::Simple>());
+    ASSERT_NO_THROW(any.Pack(msg));
+    EXPECT_TRUE(any.Is<structs::Simple>());
+    EXPECT_TRUE(any.Is<messages::Simple>());
+
+    msg.clear_f1();
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&msg));
+    EXPECT_EQ(obj.f1, msg.f1());
+
+    ASSERT_NO_THROW(any.Pack(std::chrono::nanoseconds(-123'456'789'987'654'321LL)));
+    EXPECT_TRUE(any.Is<std::chrono::milliseconds>());  // any duration suits
+    EXPECT_TRUE(any.Is<::google::protobuf::Duration>());
+
+    ::google::protobuf::Duration duration;
+
+    ASSERT_TRUE(any.GetProtobufAny().UnpackTo(&duration));
+    EXPECT_EQ(::google::protobuf::util::TimeUtil::DurationToNanoseconds(duration), -123'456'789'987'654'321LL);
+}
+
+TEST(AnyTest, Unpack) {
+    structs::Simple obj{.f1 = 1001};
+    Any any;
+
+    ASSERT_NO_THROW(any.Pack(obj));
+    ASSERT_TRUE(any.Is<structs::Simple>());
+    EXPECT_EQ(any.Unpack<structs::Simple>().f1, obj.f1);
+    ASSERT_TRUE(any.Is<messages::Simple>());
+    EXPECT_EQ(any.Unpack<messages::Simple>().f1(), obj.f1);
+    EXPECT_THAT(
+        [&any]() { static_cast<void>(any.Unpack<structs::Empty>()); },
+        ::testing::ThrowsMessage<AnyUnpackError>(::testing::HasSubstr("'messages.Empty'"))
+    );
+
+    any = {};
+    messages::Simple msg;
+    msg.set_f1(1002);
+
+    EXPECT_FALSE(any.Is<structs::Simple>());
+    EXPECT_FALSE(any.Is<messages::Simple>());
+    ASSERT_NO_THROW(any.Pack(msg));
+    ASSERT_TRUE(any.Is<structs::Simple>());
+    EXPECT_EQ(any.Unpack<structs::Simple>().f1, msg.f1());
+    ASSERT_TRUE(any.Is<messages::Simple>());
+    EXPECT_EQ(any.Unpack<messages::Simple>().f1(), msg.f1());
+
+    auto duration = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(123'456'789'987'654'321LL);
+
+    ASSERT_NO_THROW(any.Pack(std::chrono::nanoseconds(123'456'789'987'654'321LL)));
+    ASSERT_TRUE(any.Is<std::chrono::seconds>());  // any duration suits
+    EXPECT_EQ(any.Unpack<std::chrono::nanoseconds>(), std::chrono::nanoseconds(123'456'789'987'654'321LL));
+    ASSERT_TRUE(any.Is<::google::protobuf::Duration>());
+    EXPECT_EQ(any.Unpack<::google::protobuf::Duration>(), duration);
+}
+
+}  // namespace proto_structs::tests
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/tests/exceptions_test.cpp b/libraries/proto-structs/tests/exceptions_test.cpp
new file mode 100644
index 000000000000..aaa80fb1cfec
--- /dev/null
+++ b/libraries/proto-structs/tests/exceptions_test.cpp
@@ -0,0 +1,41 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <userver/proto-structs/exceptions.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::tests {
+
+TEST(ExceptionsTest, What) {
+    {
+        proto_structs::ReadError error("msg.field.nested_field", "oops");
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("msg.field.nested_field"));
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("oops"));
+    }
+
+    {
+        proto_structs::WriteError error("msg.field.nested_field", "oops");
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("msg.field.nested_field"));
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("oops"));
+    }
+
+    {
+        proto_structs::OneofAccessError error(42);
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("index = 42"));
+    }
+
+    {
+        proto_structs::AnyPackError error("some message");
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("some message"));
+    }
+
+    {
+        proto_structs::AnyUnpackError error("some message");
+        EXPECT_THAT(error.what(), ::testing::HasSubstr("some message"));
+    }
+}
+
+}  // namespace proto_structs::tests
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/tests/message_to_struct_test.cpp b/libraries/proto-structs/tests/message_to_struct_test.cpp
new file mode 100644
index 000000000000..4339c3b2445e
--- /dev/null
+++ b/libraries/proto-structs/tests/message_to_struct_test.cpp
@@ -0,0 +1,643 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <limits>
+
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/proto-structs/convert.hpp>
+
+#include "messages.pb.h"
+#include "structs.hpp"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::tests {
+
+TEST(MessageToStruct, Empty) {
+    messages::Empty msg;
+    structs::Empty obj;
+
+    ASSERT_NO_THROW(MessageToStruct(msg, obj));
+    ASSERT_NO_THROW((obj = MessageToStruct<structs::Empty>(msg)));
+}
+
+TEST(MessageToStruct, Scalar) {
+    {
+        messages::Scalar msg;
+        msg.set_f1(true);
+        msg.set_f2(std::numeric_limits<int32_t>::min());
+        msg.set_f3(std::numeric_limits<uint32_t>::max());
+        msg.set_f4(std::numeric_limits<int64_t>::min());
+        msg.set_f5(std::numeric_limits<uint64_t>::max());
+        msg.set_f6(static_cast<float>(1.5));
+        msg.set_f7(-2.5);
+        msg.set_f8("test1");
+        msg.set_f9("test2");
+        msg.set_f10(messages::TestEnum::TEST_ENUM_VALUE1);
+        msg.set_f11(123);
+
+        auto obj = MessageToStruct<structs::Scalar>(msg);
+
+        CheckScalarEqual(obj, msg);
+    }
+
+    {
+        messages::Scalar msg;
+        structs::Scalar obj;
+
+        CheckScalarEqual(obj, msg);
+
+        msg.set_f2(1001);
+        obj.f2 = 1;
+        obj.f3 = 2;
+        obj.f8 = "test";
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckScalarEqual(obj, msg);
+
+        msg.set_f8("hello");
+        msg.set_f9("world");
+        msg.set_f11(456);
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckScalarEqual(obj, msg);
+    }
+
+    {
+        messages::Scalar msg;
+        msg.set_f11(-1);
+
+        try {
+            auto result = MessageToStruct<structs::Scalar>(msg);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::ReadError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Scalar.f11'"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+}
+
+TEST(MessageToStruct, WellKnown) {
+    auto CreateValid = []() {
+        messages::WellKnown msg;
+        msg.mutable_f4()->set_year(1);
+        msg.mutable_f4()->set_month(1);
+        msg.mutable_f4()->set_day(1);
+        msg.mutable_f7()->set_value("0.000");
+        return msg;
+    };
+
+    ASSERT_NO_THROW(static_cast<void>(MessageToStruct<structs::WellKnown>(CreateValid())));
+
+    {
+        messages::WellKnown msg;
+        messages::Simple any_payload;
+
+        any_payload.set_f1(100);
+
+        ASSERT_TRUE(msg.mutable_f1()->PackFrom(any_payload));
+        *msg.mutable_f2() = ::google::protobuf::util::TimeUtil::NanosecondsToTimestamp(123'456'789'987'654'321LL);
+        *msg.mutable_f3() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(987'654'321'123'456'789LL);
+        msg.mutable_f4()->set_year(2025);
+        msg.mutable_f4()->set_month(8);
+        msg.mutable_f4()->set_day(27);
+        msg.mutable_f5()->set_hours(19);
+        msg.mutable_f5()->set_minutes(30);
+        msg.mutable_f5()->set_seconds(50);
+        msg.mutable_f5()->set_nanos(123'456'789);
+        msg.mutable_f6()->set_hours(2);
+        msg.mutable_f6()->set_minutes(10);
+        msg.mutable_f6()->set_seconds(11);
+        msg.mutable_f6()->set_nanos(987'654'321);
+        msg.mutable_f7()->set_value("1.123");
+
+        auto obj = MessageToStruct<structs::WellKnown>(msg);
+
+        CheckWellKnownEqual(obj, msg);
+        CheckSimpleEqual(obj.f1.Unpack<structs::Simple>(), any_payload);
+    }
+
+    {
+        messages::WellKnown msg = CreateValid();
+        structs::WellKnown obj;
+        messages::Simple any_payload;
+
+        *msg.mutable_f2() = ::google::protobuf::util::TimeUtil::NanosecondsToTimestamp(-987'654'321'123'456'789LL);
+        msg.mutable_f7()->set_value("1001.001");
+        obj.f1.Pack<structs::Scalar>({.f10 = structs::TestEnum::kValue1});
+        obj.f2 = std::chrono::system_clock::now();
+        obj.f3 = std::chrono::milliseconds(1001);
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckWellKnownEqual(obj, msg);
+
+        any_payload.set_f1(5);
+        ASSERT_TRUE(msg.mutable_f1()->PackFrom(any_payload));
+
+        *msg.mutable_f3() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(-123'456'789'987'654'321LL);
+        msg.mutable_f5()->set_minutes(10);
+        msg.mutable_f7()->set_value("-1001.001");
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckWellKnownEqual(obj, msg);
+        CheckSimpleEqual(obj.f1.Unpack<structs::Simple>(), any_payload);
+    }
+
+    {
+        messages::WellKnown msg = CreateValid();
+        msg.mutable_f2()->set_nanos(1'999'999'999);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f2'"))
+        );
+    }
+
+    {
+        messages::WellKnown msg = CreateValid();
+        msg.mutable_f3()->set_nanos(-1'999'999'999);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f3'"))
+        );
+    }
+
+    {
+        messages::WellKnown msg = CreateValid();
+        msg.mutable_f4()->set_year(0);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_year(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_year(10'000);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_month(0);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_month(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_month(13);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_day(0);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_day(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_day(32);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f4()->set_year(2025);
+        msg.mutable_f4()->set_month(2);
+        msg.mutable_f4()->set_day(290);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+    }
+
+    {
+        messages::WellKnown msg = CreateValid();
+        msg.mutable_f5()->set_hours(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_hours(24);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_minutes(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_minutes(60);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_seconds(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_seconds(60);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_nanos(-1);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f5()->set_nanos(1'000'000'000);
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+    }
+
+    {
+        messages::WellKnown msg = CreateValid();
+        msg.mutable_f7()->set_value("");
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f7'"))
+        );
+
+        msg = CreateValid();
+        msg.mutable_f7()->set_value("1.1234");
+
+        EXPECT_THAT(
+            [&msg]() { static_cast<void>(MessageToStruct<structs::WellKnown>(msg)); },
+            ::testing::ThrowsMessage<ReadError>(::testing::HasSubstr("'messages.WellKnown.f7'"))
+        );
+    }
+}
+
+TEST(MessageToStruct, Optional) {
+    {
+        messages::Optional msg;
+        msg.set_f1(1001);
+        msg.set_f2("test");
+        msg.set_f3(messages::TestEnum::TEST_ENUM_VALUE1);
+        msg.mutable_f4()->set_f1(10);
+
+        auto obj = MessageToStruct<structs::Optional>(msg);
+
+        CheckOptionalEqual(obj, msg);
+    }
+
+    {
+        messages::Optional msg;
+        structs::Optional obj;
+
+        CheckOptionalEqual(obj, msg);
+
+        msg.set_f1(1001);
+        msg.mutable_f4()->set_f1(13);
+        obj.f2 = "test2";
+        obj.f3 = structs::TestEnum::kValue2;
+        obj.f4 = {.f1 = 5};
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckOptionalEqual(obj, msg);
+
+        msg.set_f2("test3");
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckOptionalEqual(obj, msg);
+    }
+}
+
+TEST(MessageToStruct, Repeated) {
+    {
+        messages::Repeated msg;
+        msg.add_f1(10);
+        msg.add_f1(11);
+        msg.add_f1(12);
+        msg.add_f2("test1");
+        msg.add_f2("test2");
+        msg.add_f3(messages::TestEnum::TEST_ENUM_VALUE1);
+        msg.add_f3(messages::TestEnum::TEST_ENUM_UNSPECIFIED);
+        msg.add_f3(messages::TestEnum::TEST_ENUM_VALUE2);
+        msg.add_f3(static_cast<messages::TestEnum>(1001));
+        msg.mutable_f4()->Add()->set_f1(1000);
+        msg.mutable_f4()->Add()->set_f1(1001);
+
+        auto obj = MessageToStruct<structs::Repeated>(msg);
+
+        CheckRepeatedEqual(obj, msg);
+    }
+
+    {
+        messages::Repeated msg;
+        structs::Repeated obj;
+
+        CheckRepeatedEqual(obj, msg);
+
+        msg.add_f1(1);
+        msg.mutable_f4()->Add()->set_f1(13);
+        obj.f1 = {1, 2, 3};
+        obj.f2 = {"test2"};
+        obj.f4 = {{.f1 = 5}};
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckRepeatedEqual(obj, msg);
+
+        msg.add_f2("hello");
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckRepeatedEqual(obj, msg);
+    }
+}
+
+TEST(MessageToStruct, Map) {
+    {
+        messages::Map msg;
+        (*msg.mutable_f1())[5] = 15;
+        (*msg.mutable_f1())[6] = 16;
+        (*msg.mutable_f1())[7] = 17;
+        (*msg.mutable_f2())["key1"] = "value1";
+        (*msg.mutable_f2())["key2"] = "value2";
+        (*msg.mutable_f3())[false] = messages::TestEnum::TEST_ENUM_UNSPECIFIED;
+        (*msg.mutable_f3())[true] = messages::TestEnum::TEST_ENUM_VALUE2;
+        (*msg.mutable_f4())["simple1"].set_f1(1001);
+        (*msg.mutable_f4())["simple2"].set_f1(1002);
+
+        auto obj = MessageToStruct<structs::Map>(msg);
+
+        CheckMapEqual(obj, msg);
+    }
+
+    {
+        messages::Map msg;
+        structs::Map obj;
+
+        CheckMapEqual(obj, msg);
+
+        (*msg.mutable_f1())[5] = 15;
+        (*msg.mutable_f4())["simple1"].set_f1(1001);
+        obj.f1 = {{1, 1}, {2, 2}, {3, 3}};
+        obj.f2 = {{"key1", "value1"}};
+        obj.f4 = {{"simple1", {.f1 = 5}}};
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckMapEqual(obj, msg);
+
+        (*msg.mutable_f2())["key2"] = "value2";
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckMapEqual(obj, msg);
+    }
+}
+
+TEST(MessageToStruct, Oneof) {
+    {
+        messages::Oneof msg;
+        msg.set_f1(1001);
+
+        auto obj = MessageToStruct<structs::Oneof>(msg);
+
+        CheckOneofEqual(obj, msg);
+    }
+
+    {
+        messages::Oneof msg;
+        structs::Oneof obj;
+
+        CheckOneofEqual(obj, msg);
+
+        msg.set_f2("test");
+        obj.test_oneof.Set<0>(1);
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckOneofEqual(obj, msg);
+
+        msg.set_f3(messages::TestEnum::TEST_ENUM_UNSPECIFIED);
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckOneofEqual(obj, msg);
+
+        msg.mutable_f4()->set_f1(1001);
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckOneofEqual(obj, msg);
+    }
+}
+
+TEST(MessageToStruct, Indirect) {
+    {
+        messages::Indirect msg;
+        msg.mutable_f1()->set_f1(1);
+        *msg.mutable_f2() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(123'456'789'987'654'321LL);
+        msg.mutable_f3()->Add()->set_f1(3);
+        msg.mutable_f3()->Add()->set_f1(4);
+        (*msg.mutable_f4())[1].set_f1(5);
+        (*msg.mutable_f4())[2].set_f1(6);
+        msg.mutable_f5()->set_f1(7);
+        msg.set_f7(1001);
+        msg.add_f8(messages::TEST_ENUM_UNSPECIFIED);
+        (*msg.mutable_f9())["3"].set_f1(8);
+
+        auto obj = MessageToStruct<structs::Indirect>(msg);
+
+        CheckIndirectEqual(obj, msg);
+    }
+
+    {
+        messages::Indirect msg;
+        structs::Indirect obj;
+
+        CheckIndirectEqual(obj, msg);
+
+        msg.mutable_f1()->set_f1(10);
+        msg.mutable_f3()->Add()->set_f1(11);
+        msg.set_f6("hello");
+        obj.f1 = {.f1 = 1001};
+        obj.f4 = {{10, structs::Simple{.f1 = 1002}}};
+        obj.test_oneof.Set<0>(structs::Simple{.f1 = 30});
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckIndirectEqual(obj, msg);
+
+        msg.mutable_f5()->set_f1(12);
+        msg.add_f8(messages::TEST_ENUM_VALUE2);
+        msg.add_f8(messages::TEST_ENUM_VALUE1);
+        obj.test_oneof.Set<0>(structs::Simple{.f1 = 1003});
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckIndirectEqual(obj, msg);
+    }
+}
+
+TEST(MessageToStruct, Strong) {
+    {
+        messages::Strong msg;
+        msg.set_f1(1001);
+        msg.set_f2("hello");
+        msg.add_f3(messages::TestEnum::TEST_ENUM_VALUE1);
+        msg.add_f3(messages::TestEnum::TEST_ENUM_VALUE2);
+        (*msg.mutable_f4())[1].set_f1(1002);
+        (*msg.mutable_f4())[2].set_f1(1003);
+        *msg.mutable_f5() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(123'456'789'987'654'321LL);
+
+        auto obj = MessageToStruct<structs::Strong>(msg);
+
+        CheckStrongEqual(obj, msg);
+    }
+
+    {
+        messages::Strong msg;
+        structs::Strong obj;
+
+        CheckStrongEqual(obj, msg);
+
+        msg.set_f1(10);
+        *msg.mutable_f5() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(-123'456'789'987'654'321LL);
+        obj.f1 = structs::Strong::F1Strong{5};
+        obj.f4[100] = structs::Strong::F4Strong{structs::Simple{.f1 = 6}};
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckStrongEqual(obj, msg);
+
+        msg.set_f2("test");
+        obj.test_oneof.Set<0>(structs::Strong::F5Strong{std::chrono::nanoseconds{123'456'789'987'654'321}});
+
+        ASSERT_NO_THROW(MessageToStruct(msg, obj));
+        CheckStrongEqual(obj, msg);
+    }
+}
+
+TEST(MessageToStruct, Erroneous) {
+    {
+        messages::Erroneous msg;
+        structs::Erroneous obj;
+
+        EXPECT_NO_THROW(obj = MessageToStruct<structs::Erroneous>(msg));
+    }
+
+    {
+        messages::Erroneous msg;
+        msg.mutable_f1()->set_error_type(messages::ConversionFailure::TYPE_EXCEPTION);
+
+        try {
+            auto result = MessageToStruct<structs::Erroneous>(msg);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::ReadError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f1'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_exception"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+
+    {
+        messages::Erroneous msg;
+        msg.mutable_f2()->Add()->set_error_type(messages::ConversionFailure::TYPE_ERROR);
+
+        try {
+            auto result = MessageToStruct<structs::Erroneous>(msg);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::ReadError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f2.error_field'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_error"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+
+    {
+        messages::Erroneous msg;
+        (*msg.mutable_f3())[10].set_error_type(messages::ConversionFailure::TYPE_ERROR_WITH_UNKNOWN_FIELD);
+
+        try {
+            auto result = MessageToStruct<structs::Erroneous>(msg);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::ReadError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f3.<unknown_1001>'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_error_with_unknown_field"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+
+    {
+        messages::Erroneous msg;
+        msg.mutable_f4()->set_error_type(messages::ConversionFailure::TYPE_ERROR_WITH_UNKNOWN_FIELD);
+
+        try {
+            auto result = MessageToStruct<structs::Erroneous>(msg);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::ReadError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f4.<unknown_1001>'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_error_with_unknown_field"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+}
+
+}  // namespace proto_structs::tests
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/tests/oneof_test.cpp b/libraries/proto-structs/tests/oneof_test.cpp
new file mode 100644
index 000000000000..c3d599a03014
--- /dev/null
+++ b/libraries/proto-structs/tests/oneof_test.cpp
@@ -0,0 +1,196 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+#include <userver/proto-structs/any.hpp>
+#include <userver/proto-structs/io/std/chrono/duration.hpp>
+#include <userver/proto-structs/io/userver/utils/box.hpp>
+#include <userver/proto-structs/io/userver/utils/strong_typedef.hpp>
+#include <userver/proto-structs/oneof.hpp>
+#include <userver/utils/box.hpp>
+#include <userver/utils/strong_typedef.hpp>
+
+#include "messages.pb.h"
+#include "struct_simple.hpp"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::tests {
+
+enum TestEnum { kValue0 = 0, kValue1 = 1, kValue2 = 2 };
+
+using RawOneof = proto_structs::Oneof<int32_t, int32_t, std::string, TestEnum, structs::Simple>;
+
+struct CustomOneof : RawOneof {};
+
+void CheckAlternativeSet(const RawOneof& oneof, std::size_t set_index) {
+    ASSERT_EQ(oneof.GetIndex(), set_index);
+
+    bool found = false;
+
+    for (std::size_t i = 0; i < RawOneof::kSize; ++i) {
+        if (i != set_index) {
+            ASSERT_FALSE(oneof.Contains(i));
+        } else {
+            ASSERT_TRUE(oneof.Contains(i));
+            found = true;
+        }
+    }
+
+    ASSERT_EQ(oneof.ContainsAny(), found);
+
+    if (found) {
+        ASSERT_TRUE(oneof);
+    } else {
+        ASSERT_FALSE(oneof);
+    }
+}
+
+TEST(OneofTest, Traits) {
+    struct Tag {};
+
+    static_assert(traits::Oneof<RawOneof>);
+    static_assert(traits::Oneof<const volatile RawOneof>);
+    static_assert(traits::Oneof<CustomOneof>);
+    static_assert(traits::Oneof<const volatile CustomOneof>);
+
+    static_assert(RawOneof::kSize == 5);
+    static_assert(CustomOneof::kSize == 5);
+
+    static_assert(!traits::Oneof<RawOneof&>);
+    static_assert(!traits::Oneof<CustomOneof&>);
+    static_assert(!traits::Oneof<int32_t>);
+    static_assert(!traits::Oneof<std::pair<int32_t, int32_t>>);
+
+    static_assert(std::is_same_v<int32_t, OneofAlternativeType<0, RawOneof>>);
+    static_assert(std::is_same_v<int32_t, OneofAlternativeType<1, RawOneof>>);
+    static_assert(std::is_same_v<std::string, OneofAlternativeType<2, RawOneof>>);
+    static_assert(std::is_same_v<TestEnum, OneofAlternativeType<3, RawOneof>>);
+    static_assert(std::is_same_v<structs::Simple, OneofAlternativeType<4, RawOneof>>);
+
+    static_assert(std::is_same_v<int32_t, OneofAlternativeType<0, CustomOneof>>);
+    static_assert(std::is_same_v<int32_t, OneofAlternativeType<1, CustomOneof>>);
+    static_assert(std::is_same_v<std::string, OneofAlternativeType<2, CustomOneof>>);
+    static_assert(std::is_same_v<TestEnum, OneofAlternativeType<3, CustomOneof>>);
+    static_assert(std::is_same_v<structs::Simple, OneofAlternativeType<4, CustomOneof>>);
+}
+
+TEST(OneofTest, Ctor) {
+    RawOneof default_oneof;
+
+    CheckAlternativeSet(default_oneof, kOneofNpos);
+
+    RawOneof oneof(std::in_place_index<2>, "hello world");
+
+    CheckAlternativeSet(oneof, 2);
+    EXPECT_EQ(oneof.Get<2>(), "hello world");
+
+    RawOneof oneof_copy(oneof);
+
+    CheckAlternativeSet(oneof_copy, 2);
+    EXPECT_EQ(oneof_copy.Get<2>(), "hello world");
+
+    oneof.Get<2>() = "test1";
+    oneof_copy = oneof;
+
+    CheckAlternativeSet(oneof_copy, 2);
+    EXPECT_EQ(oneof_copy.Get<2>(), "test1");
+
+    oneof.Get<2>() = "test2";
+    RawOneof oneof_move(std::move(oneof));
+
+    CheckAlternativeSet(oneof_move, 2);
+    EXPECT_EQ(oneof_move.Get<2>(), "test2");
+
+    oneof_copy = std::move(oneof_move);
+
+    CheckAlternativeSet(oneof_copy, 2);
+    EXPECT_EQ(oneof_copy.Get<2>(), "test2");
+}
+
+TEST(OneofTest, GetSetEmplace) {
+    RawOneof oneof;
+
+    oneof.Set<0>(0);
+
+    CheckAlternativeSet(oneof, 0);
+    EXPECT_EQ(oneof.Get<0>(), 0);
+    EXPECT_THAT(
+        [&oneof]() { static_cast<void>(oneof.Get<1>()); },
+        ::testing::ThrowsMessage<OneofAccessError>(::testing::HasSubstr("index = 1"))
+    );
+
+    oneof.Set<0>(42);
+
+    CheckAlternativeSet(oneof, 0);
+    EXPECT_EQ(oneof.Get<0>(), 42);
+
+    EXPECT_EQ(oneof.Emplace<1>(1001), 1001);
+    CheckAlternativeSet(oneof, 1);
+    EXPECT_EQ(oneof.Get<1>(), 1001);
+
+    ++oneof.Get<1>();
+
+    CheckAlternativeSet(oneof, 1);
+    EXPECT_EQ(oneof.Get<1>(), 1002);
+
+    oneof.Set<2>("hello world");
+
+    CheckAlternativeSet(oneof, 2);
+    EXPECT_EQ(oneof.Get<2>(), "hello world");
+
+    std::string str = "some string";
+
+    EXPECT_EQ(oneof.Emplace<2>(str.begin() + 5, str.end()), "string");
+    CheckAlternativeSet(oneof, 2);
+
+    str += "!";
+    oneof.Set<2>(std::move(str));
+
+    CheckAlternativeSet(oneof, 2);
+    EXPECT_EQ(oneof.Get<2>(), "some string!");
+
+    oneof.Set<3>(kValue1);
+
+    CheckAlternativeSet(oneof, 3);
+    EXPECT_EQ(oneof.Get<3>(), kValue1);
+
+    oneof.Set<4>({.f1 = 11});
+
+    CheckAlternativeSet(oneof, 4);
+    EXPECT_EQ(std::move(oneof).Get<4>().f1, 11);
+
+    oneof.GetMutable<0>() = 6;
+
+    CheckAlternativeSet(oneof, 0);
+    EXPECT_EQ(oneof.Get<0>(), 6);
+}
+
+TEST(OneofTest, Clear) {
+    RawOneof oneof;
+
+    EXPECT_NO_THROW(oneof.ClearOneof());
+    CheckAlternativeSet(oneof, kOneofNpos);
+
+    oneof.Set<0>(1);
+
+    EXPECT_NO_THROW(oneof.Clear(1));
+    CheckAlternativeSet(oneof, 0);
+    EXPECT_EQ(oneof.Get<0>(), 1);
+
+    EXPECT_NO_THROW(oneof.Clear(0));
+    CheckAlternativeSet(oneof, kOneofNpos);
+
+    oneof.Set<1>(2);
+
+    EXPECT_NO_THROW(oneof.ClearOneof());
+    CheckAlternativeSet(oneof, kOneofNpos);
+}
+
+}  // namespace proto_structs::tests
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/tests/proto/messages.proto b/libraries/proto-structs/tests/proto/messages.proto
new file mode 100644
index 000000000000..6c742d228c38
--- /dev/null
+++ b/libraries/proto-structs/tests/proto/messages.proto
@@ -0,0 +1,126 @@
+syntax = "proto3";
+package messages;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/type/date.proto";
+import "google/type/decimal.proto";
+import "google/type/timeofday.proto";
+
+option go_package = "a.yandex-team.ru/taxi/uservices/userver/libraries/proto-structs/tests/proto;testmessages";
+
+enum TestEnum {
+  TEST_ENUM_UNSPECIFIED = 0;
+  TEST_ENUM_VALUE1 = 1;
+  TEST_ENUM_VALUE2 = 2;
+}
+
+message Empty {}
+
+message Simple {
+  int32 f1 = 1;
+}
+
+message ConversionFailure {
+  enum Type {
+    TYPE_UNSPECIFIED = 0;
+    TYPE_EXCEPTION = 1;
+    TYPE_ERROR = 2;
+    TYPE_ERROR_WITH_UNKNOWN_FIELD = 3;
+  }
+
+  Type error_type = 1;
+  int32 error_field = 2;
+}
+
+message Scalar {
+  bool f1 = 1;
+  int32 f2 = 2;
+  uint32 f3 = 3;
+  int64 f4 = 4;
+  uint64 f5 = 5;
+  float f6 = 6;
+  double f7 = 7;
+  string f8 = 8;
+  bytes f9 = 9;
+  TestEnum f10 = 10;
+  int32 f11 = 11; // std::size_t
+}
+
+message WellKnown {
+  google.protobuf.Any f1 = 1;
+  google.protobuf.Timestamp f2 = 2; // std::chrono::time_point
+  google.protobuf.Duration f3 = 3;  // std::chrono::duration
+  google.type.Date f4 = 4;          // std::chrono::year_month_day
+  google.type.TimeOfDay f5 = 5;     // std::chrono::hh_mm_ss
+  google.type.TimeOfDay f6 = 6;     // userver::utils::datetime::TimeOfDay
+  google.type.Decimal f7 = 7;       // userver::decimal64::Decimal
+}
+
+message Optional {
+  optional int32 f1 = 1;
+  optional string f2 = 2;
+  optional TestEnum f3 = 3;
+  optional Simple f4 = 4;
+}
+
+message Repeated {
+  repeated int32 f1 = 1;
+  repeated string f2 = 2;
+  repeated TestEnum f3 = 3;
+  repeated Simple f4 = 4;
+}
+
+message Map {
+  map<int32, int32> f1 = 1;
+  map<string, string> f2 = 2;
+  map<bool, TestEnum> f3 = 3;
+  map<string, Simple> f4 = 4;
+}
+
+message Oneof {
+  oneof test_oneof {
+    int32 f1 = 1;
+    string f2 = 2;
+    TestEnum f3 = 3;
+    Simple f4 = 4;
+  }
+}
+
+message Indirect {
+  Simple f1 = 1;
+  optional google.protobuf.Duration f2 = 2;
+  repeated Simple f3 = 3;
+  map<int32, Simple> f4 = 4;
+
+  oneof test_oneof {
+    Simple f5 = 5;
+    string f6 = 6;
+  }
+
+  int32 f7 = 7;
+  repeated TestEnum f8 = 8;
+  map<string, Simple> f9 = 9;
+}
+
+message Strong {
+  int32 f1 = 1;
+  optional string f2 = 2;
+  repeated TestEnum f3 = 3;
+  map<int32, Simple> f4 = 4;
+
+  oneof test_oneof {
+    google.protobuf.Duration f5 = 5;
+  }
+}
+
+message Erroneous {
+  optional ConversionFailure f1 = 1;
+  repeated ConversionFailure f2 = 2;
+  map<int32, ConversionFailure> f3 = 3;
+
+  oneof test_oneof {
+    ConversionFailure f4 = 4;
+  }
+}
diff --git a/libraries/proto-structs/tests/struct_simple.cpp b/libraries/proto-structs/tests/struct_simple.cpp
new file mode 100644
index 000000000000..9d62b5bd6fb8
--- /dev/null
+++ b/libraries/proto-structs/tests/struct_simple.cpp
@@ -0,0 +1,36 @@
+#include "struct_simple.hpp"
+
+#include <gtest/gtest.h>
+
+#include <userver/proto-structs/io/impl/read.hpp>
+#include <userver/proto-structs/io/impl/write.hpp>
+#include <userver/proto-structs/io/std/int32_t_conv.hpp>
+
+#include "messages.pb.h"
+
+namespace structs {
+
+Empty ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Empty>, const messages::Empty&) { return {}; }
+
+void WriteProtoStruct(ups::io::WriteContext&, const Empty&, messages::Empty&) {}
+
+Simple ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Simple>, const messages::Simple& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<std::int32_t>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Simple::kF1FieldNumber, &messages::Simple::f1)
+        )};
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Simple& obj, messages::Simple& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        obj.f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Simple::kF1FieldNumber, &messages::Simple::set_f1, &messages::Simple::clear_f1
+        )
+    );
+}
+
+void CheckSimpleEqual(const Simple& obj, const messages::Simple& msg) { EXPECT_EQ(obj.f1, msg.f1()); }
+
+}  // namespace structs
diff --git a/libraries/proto-structs/tests/struct_simple.hpp b/libraries/proto-structs/tests/struct_simple.hpp
new file mode 100644
index 000000000000..e552a908579c
--- /dev/null
+++ b/libraries/proto-structs/tests/struct_simple.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <userver/proto-structs/io/fwd.hpp>
+#include <userver/proto-structs/io/std/int32_t.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+namespace ups = USERVER_NAMESPACE::proto_structs;
+
+namespace messages {
+class Empty;
+class Simple;
+}  // namespace messages
+
+namespace structs {
+
+struct Empty {
+    using ProtobufMessage = messages::Empty;
+};
+
+struct Simple {
+    using ProtobufMessage = int;  // non-sense
+    int32_t f1 = {};
+};
+
+Empty ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Empty>, const messages::Empty&);
+void WriteProtoStruct(ups::io::WriteContext&, const Empty&, messages::Empty&);
+
+Simple ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Simple>, const messages::Simple&);
+void WriteProtoStruct(ups::io::WriteContext&, const Simple&, messages::Simple&);
+
+void CheckSimpleEqual(const Simple&, const messages::Simple&);
+
+}  // namespace structs
+
+namespace proto_structs::traits {
+
+template <>
+struct CompatibleMessageTrait<::structs::Simple> {
+    using Type = ::messages::Simple;
+};
+
+}  // namespace proto_structs::traits
diff --git a/libraries/proto-structs/tests/struct_to_message_test.cpp b/libraries/proto-structs/tests/struct_to_message_test.cpp
new file mode 100644
index 000000000000..ad314d55af62
--- /dev/null
+++ b/libraries/proto-structs/tests/struct_to_message_test.cpp
@@ -0,0 +1,533 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <chrono>
+#include <limits>
+
+#include <google/protobuf/util/time_util.h>
+
+#include <userver/proto-structs/convert.hpp>
+
+#include "messages.pb.h"
+#include "structs.hpp"
+#include "taxi/uservices/userver/libraries/proto-structs/tests/struct_simple.hpp"
+
+USERVER_NAMESPACE_BEGIN
+
+namespace proto_structs::tests {
+
+TEST(StructToMessage, Empty) {
+    structs::Empty obj;
+    messages::Empty msg;
+
+    ASSERT_NO_THROW(StructToMessage(obj, msg));
+    ASSERT_NO_THROW((msg = StructToMessage(obj)));
+    ASSERT_NO_THROW((msg = StructToMessage(structs::Empty{obj})));
+}
+
+TEST(StructToMessage, Scalar) {
+    {
+        structs::Scalar obj{
+            .f1 = true,
+            .f2 = std::numeric_limits<int32_t>::min(),
+            .f3 = std::numeric_limits<uint32_t>::max(),
+            .f4 = std::numeric_limits<int64_t>::min(),
+            .f5 = std::numeric_limits<uint64_t>::max(),
+            .f6 = static_cast<float>(1.5),
+            .f7 = -2.5,
+            .f8 = "test1",
+            .f9 = "test2",
+            .f10 = structs::TestEnum::kValue1,
+            .f11 = 987};
+
+        auto msg = StructToMessage(obj);
+        CheckScalarEqual(obj, msg);
+
+        msg = StructToMessage(structs::Scalar{obj});
+        CheckScalarEqual(obj, msg);
+    }
+
+    {
+        structs::Scalar obj;
+        messages::Scalar msg;
+
+        obj.f2 = 1001;
+        msg.set_f2(1);
+        msg.set_f3(2);
+        msg.set_f8("test");
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckScalarEqual(obj, msg);
+
+        obj.f8 = "hello";
+        obj.f9 = "world";
+        obj.f11 = 654;
+
+        ASSERT_NO_THROW(StructToMessage(structs::Scalar{obj}, msg));
+        CheckScalarEqual(obj, msg);
+    }
+
+    if (std::numeric_limits<std::size_t>::max() > std::numeric_limits<std::int32_t>::max()) {
+        structs::Scalar obj;
+        obj.f11 = std::numeric_limits<std::size_t>::max();
+
+        try {
+            auto result = StructToMessage(obj);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::WriteError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Scalar.f11'"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+}
+
+TEST(StructToMessage, WellKnown) {
+    using TimePoint = std::chrono::time_point<std::chrono::system_clock>;
+    auto CreateValid = []() {
+        return structs::WellKnown{.f4 = {std::chrono::year{1}, std::chrono::month{1}, std::chrono::day{1}}};
+    };
+
+    {
+        structs::WellKnown obj{
+            .f1 = structs::Simple{.f1 = 100},
+            .f2 = TimePoint{std::chrono::milliseconds{123'456'789}},
+            .f3 = std::chrono::milliseconds{987'654'321},
+            .f4 = {std::chrono::year{2025}, std::chrono::month{8}, std::chrono::day{27}},
+            .f5 =
+                std::chrono::hh_mm_ss<std::chrono::microseconds>{
+                    std::chrono::minutes(65) + std::chrono::seconds{13} + std::chrono::microseconds{123'456}},
+            .f6 =
+                utils::datetime::TimeOfDay<std::chrono::microseconds>{
+                    std::chrono::hours{23} + std::chrono::minutes{59} + std::chrono::seconds{59} +
+                    std::chrono::microseconds{999'999}},
+            .f7 = decimal64::Decimal<3>{"123.456"}};
+        messages::Simple any_payload;
+
+        auto msg = StructToMessage(obj);
+
+        CheckWellKnownEqual(obj, msg);
+        ASSERT_TRUE(msg.f1().UnpackTo(&any_payload));
+        CheckSimpleEqual(obj.f1.Unpack<structs::Simple>(), any_payload);
+
+        msg = StructToMessage(structs::WellKnown{obj});
+
+        CheckWellKnownEqual(obj, msg);
+        ASSERT_TRUE(msg.f1().UnpackTo(&any_payload));
+        CheckSimpleEqual(obj.f1.Unpack<structs::Simple>(), any_payload);
+    }
+
+    {
+        structs::WellKnown obj = CreateValid();
+        messages::WellKnown msg;
+
+        obj.f2 = TimePoint{std::chrono::milliseconds{-987'654'321}};
+        obj.f7 = decimal64::Decimal<3>("1001.001");
+
+        messages::Scalar any_payload;
+        any_payload.set_f10(messages::TestEnum::TEST_ENUM_VALUE1);
+
+        ASSERT_TRUE(msg.mutable_f1()->PackFrom(any_payload));
+        *msg.mutable_f2() = ::google::protobuf::util::TimeUtil::NanosecondsToTimestamp(123'456'789'987'654'321LL);
+        *msg.mutable_f3() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(1001);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckWellKnownEqual(obj, msg);
+
+        ASSERT_NO_THROW((obj.f1 = structs::Scalar{.f2 = 5}));
+        obj.f3 = std::chrono::milliseconds{-987'654'321};
+        obj.f7 = decimal64::Decimal<3>("-1001.001");
+        *msg.mutable_f3() = ::google::protobuf::util::TimeUtil::NanosecondsToDuration(123'456'789'987'654'321LL);
+
+        ASSERT_NO_THROW(StructToMessage(structs::WellKnown{obj}, msg));
+        CheckWellKnownEqual(obj, msg);
+        ASSERT_TRUE(msg.f1().UnpackTo(&any_payload));
+        CheckScalarEqual(obj.f1.Unpack<structs::Scalar>(), any_payload);
+    }
+
+    constexpr auto kMaxSecondsInStdTimePoint =
+        (TimePoint::duration::max().count() / TimePoint::duration::period::den) * TimePoint::duration::period::num;
+    constexpr auto kMinSecondsInStdTimePoint =
+        (TimePoint::duration::min().count() / TimePoint::duration::period::den) * TimePoint::duration::period::num;
+
+    if (kMaxSecondsInStdTimePoint > ::google::protobuf::util::TimeUtil::kTimestampMaxSeconds) {
+        structs::WellKnown obj = CreateValid();
+        messages::WellKnown msg;
+
+        obj.f2 = TimePoint{std::chrono::seconds{kMaxSecondsInStdTimePoint}};
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        EXPECT_EQ(msg.f2().seconds(), ::google::protobuf::util::TimeUtil::kTimestampMaxSeconds);
+    }
+
+    if (kMinSecondsInStdTimePoint < ::google::protobuf::util::TimeUtil::kTimestampMinSeconds) {
+        structs::WellKnown obj = CreateValid();
+        messages::WellKnown msg;
+
+        obj.f2 = TimePoint{std::chrono::seconds{kMinSecondsInStdTimePoint}};
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        EXPECT_EQ(msg.f2().seconds(), ::google::protobuf::util::TimeUtil::kTimestampMinSeconds);
+    }
+
+    if ((std::chrono::milliseconds::max().count() / 1000) > ::google::protobuf::util::TimeUtil::kDurationMaxSeconds) {
+        structs::WellKnown obj = CreateValid();
+        messages::WellKnown msg;
+
+        obj.f3 = std::chrono::milliseconds::max();
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        EXPECT_EQ(msg.f3().seconds(), ::google::protobuf::util::TimeUtil::kDurationMaxSeconds);
+    }
+
+    if ((std::chrono::milliseconds::min().count() / 1000) < ::google::protobuf::util::TimeUtil::kDurationMinSeconds) {
+        structs::WellKnown obj = CreateValid();
+        messages::WellKnown msg;
+
+        obj.f3 = std::chrono::milliseconds::min();
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        EXPECT_EQ(msg.f3().seconds(), ::google::protobuf::util::TimeUtil::kDurationMinSeconds);
+    }
+
+    {
+        structs::WellKnown obj = CreateValid();
+        obj.f4 = std::chrono::year_month_day{};
+
+        EXPECT_THAT(
+            [&obj]() { static_cast<void>(StructToMessage(obj)); },
+            ::testing::ThrowsMessage<WriteError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        obj.f4 = {std::chrono::year{0}, std::chrono::month{5}, std::chrono::day{5}};
+
+        EXPECT_THAT(
+            [&obj]() { static_cast<void>(StructToMessage(obj)); },
+            ::testing::ThrowsMessage<WriteError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+
+        obj.f4 = {std::chrono::year{2025}, std::chrono::month{2}, std::chrono::day{29}};
+
+        EXPECT_THAT(
+            [&obj]() { static_cast<void>(StructToMessage(obj)); },
+            ::testing::ThrowsMessage<WriteError>(::testing::HasSubstr("'messages.WellKnown.f4'"))
+        );
+    }
+
+    {
+        structs::WellKnown obj = CreateValid();
+        obj.f5 = std::chrono::hh_mm_ss<std::chrono::microseconds>{std::chrono::hours{25}};
+
+        EXPECT_THAT(
+            [&obj]() { static_cast<void>(StructToMessage(obj)); },
+            ::testing::ThrowsMessage<WriteError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+
+        obj = CreateValid();
+        obj.f5 = std::chrono::hh_mm_ss<std::chrono::microseconds>{std::chrono::microseconds{-1}};
+
+        EXPECT_THAT(
+            [&obj]() { static_cast<void>(StructToMessage(obj)); },
+            ::testing::ThrowsMessage<WriteError>(::testing::HasSubstr("'messages.WellKnown.f5'"))
+        );
+    }
+}
+
+TEST(StructToMessage, Optional) {
+    {
+        structs::Optional obj = {
+            .f1 = 1001, .f2 = "test", .f3 = structs::TestEnum::kValue1, .f4 = structs::Simple{.f1 = 10}};
+
+        auto msg = StructToMessage(obj);
+        CheckOptionalEqual(obj, msg);
+
+        msg = StructToMessage(structs::Optional{obj});
+        CheckOptionalEqual(obj, msg);
+    }
+
+    {
+        structs::Optional obj;
+        messages::Optional msg;
+
+        obj.f1 = 1001;
+        obj.f4 = {.f1 = 13};
+        msg.set_f2("test2");
+        msg.set_f3(messages::TestEnum::TEST_ENUM_VALUE2);
+        msg.mutable_f4()->set_f1(5);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckOptionalEqual(obj, msg);
+
+        obj.f2 = "test3";
+
+        ASSERT_NO_THROW(StructToMessage(structs::Optional{obj}, msg));
+        CheckOptionalEqual(obj, msg);
+    }
+}
+
+TEST(StructToMessage, Repeated) {
+    {
+        structs::Repeated obj;
+        obj.f1 = {10, 11, 12};
+        obj.f2 = {"test1", "test2"};
+        obj.f3 = {
+            structs::TestEnum::kValue1,
+            structs::TestEnum::kUnspecified,
+            structs::TestEnum::kValue2,
+            static_cast<structs::TestEnum>(1001)};
+        obj.f4 = {{.f1 = 1000}, {.f1 = 1001}};
+
+        auto msg = StructToMessage(obj);
+        CheckRepeatedEqual(obj, msg);
+
+        msg = StructToMessage(structs::Repeated{obj});
+        CheckRepeatedEqual(obj, msg);
+    }
+
+    {
+        structs::Repeated obj;
+        messages::Repeated msg;
+
+        obj.f1 = {1};
+        obj.f4 = {{.f1 = 13}};
+        msg.add_f1(1);
+        msg.add_f1(2);
+        msg.add_f1(3);
+        msg.add_f2("test2");
+        msg.mutable_f4()->Add()->set_f1(5);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckRepeatedEqual(obj, msg);
+
+        obj.f2.push_back("hello");
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckRepeatedEqual(obj, msg);
+    }
+}
+
+TEST(StructToMessage, Map) {
+    {
+        structs::Map obj;
+        obj.f1 = {{5, 15}, {6, 16}, {7, 17}};
+        obj.f2 = {{"key1", "value1"}, {"key2", "value2"}};
+        obj.f3 = {{true, structs::TestEnum::kUnspecified}, {false, structs::TestEnum::kValue2}};
+        obj.f4 = {{"simple1", {.f1 = 1001}}, {"simple2", {.f1 = 1002}}};
+
+        auto msg = StructToMessage(obj);
+        CheckMapEqual(obj, msg);
+
+        msg = StructToMessage(structs::Map{obj});
+        CheckMapEqual(obj, msg);
+    }
+
+    {
+        structs::Map obj;
+        messages::Map msg;
+
+        obj.f1 = {{5, 15}};
+        obj.f4 = {{"simple1", {.f1 = 1001}}};
+        (*msg.mutable_f1())[1] = 1;
+        (*msg.mutable_f1())[2] = 2;
+        (*msg.mutable_f1())[3] = 3;
+        (*msg.mutable_f2())["key1"] = "value1";
+        (*msg.mutable_f4())["simple1"].set_f1(1001);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckMapEqual(obj, msg);
+
+        obj.f2.emplace("key2", "value2");
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckMapEqual(obj, msg);
+    }
+}
+
+TEST(StructToMessage, Oneof) {
+    {
+        structs::Oneof obj;
+        obj.test_oneof.Set<0>(1001);
+
+        auto msg = StructToMessage(obj);
+        CheckOneofEqual(obj, msg);
+
+        msg = StructToMessage(structs::Oneof{obj});
+        CheckOneofEqual(obj, msg);
+    }
+
+    {
+        structs::Oneof obj;
+        messages::Oneof msg;
+
+        obj.test_oneof.Set<1>("test");
+        msg.set_f1(1);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckOneofEqual(obj, msg);
+
+        obj.test_oneof.Set<2>(structs::TestEnum::kUnspecified);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckOneofEqual(obj, msg);
+
+        obj.test_oneof.Set<3>({.f1 = 1001});
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckOneofEqual(obj, msg);
+    }
+}
+
+TEST(StructToMessage, Indirect) {
+    {
+        structs::Indirect obj;
+        obj.f1 = {.f1 = 1};
+        obj.f2 = std::chrono::nanoseconds{987'654'321'123'456'789LL};
+        obj.f3 = {structs::Simple{.f1 = 3}, structs::Simple{.f1 = 4}};
+        obj.f4 = {{1, structs::Simple{.f1 = 5}}, {2, structs::Simple{.f1 = 6}}};
+        obj.test_oneof.Set<0>(structs::Simple{.f1 = 7});
+        obj.f7 = 8;
+        obj.f8 = {structs::TestEnum::kValue1, structs::TestEnum::kValue2};
+        obj.f9 = {{"hello", structs::Simple{.f1 = 9}}, {"", structs::Simple{.f1 = 10}}};
+
+        auto msg = StructToMessage(obj);
+        CheckIndirectEqual(obj, msg);
+
+        msg = StructToMessage(structs::Indirect{obj});
+        CheckIndirectEqual(obj, msg);
+    }
+
+    {
+        structs::Indirect obj;
+        messages::Indirect msg;
+
+        obj.f1 = {.f1 = 1};
+        obj.f4 = {{1, structs::Simple{.f1 = 10}}};
+        obj.test_oneof.Set<1>("test");
+        msg.mutable_f1()->set_f1(1001);
+        msg.mutable_f3()->Add()->set_f1(1002);
+        msg.mutable_f5()->set_f1(1003);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckIndirectEqual(obj, msg);
+
+        obj.test_oneof.Set<0>(structs::Simple{.f1 = 11});
+        msg.add_f8(messages::TEST_ENUM_VALUE1);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckIndirectEqual(obj, msg);
+    }
+}
+
+TEST(StructToMessage, Strong) {
+    {
+        structs::Strong obj;
+        obj.f1 = structs::Strong::F1Strong{1};
+        obj.f2 = structs::Strong::F2Strong{"hello"};
+        obj.f3 = {
+            structs::Strong::F3Strong{structs::TestEnum::kValue1},
+            structs::Strong::F3Strong{structs::TestEnum::kValue2}};
+        obj.f4 = {
+            {1, structs::Strong::F4Strong(structs::Simple{.f1 = 3})},
+            {2, structs::Strong::F4Strong(structs::Simple{.f1 = 4})}};
+        obj.test_oneof.Set<0>(structs::Strong::F5Strong{std::chrono::nanoseconds{-123'456'789'987'654'321}});
+
+        auto msg = StructToMessage(obj);
+        CheckStrongEqual(obj, msg);
+
+        msg = StructToMessage(structs::Strong{obj});
+        CheckStrongEqual(obj, msg);
+    }
+
+    {
+        structs::Strong obj;
+        messages::Strong msg;
+
+        obj.f1 = structs::Strong::F1Strong{1};
+        obj.f4 = {
+            {100, structs::Strong::F4Strong(structs::Simple{.f1 = 2})},
+            {200, structs::Strong::F4Strong(structs::Simple{.f1 = 3})}};
+        msg.set_f1(1001);
+        msg.add_f3(messages::TestEnum::TEST_ENUM_VALUE2);
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckStrongEqual(obj, msg);
+
+        obj.test_oneof.Set<0>(structs::Strong::F5Strong{std::chrono::nanoseconds{123'456'789'987'654'321}});
+
+        ASSERT_NO_THROW(StructToMessage(obj, msg));
+        CheckStrongEqual(obj, msg);
+    }
+}
+
+TEST(StructToMessage, Erroneous) {
+    {
+        structs::Erroneous obj;
+        messages::Erroneous msg;
+
+        EXPECT_NO_THROW(msg = StructToMessage(obj));
+    }
+
+    {
+        structs::Erroneous obj;
+        obj.f1 = {.error_type = structs::ConversionFailureType::kException};
+
+        try {
+            auto result = StructToMessage(obj);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::WriteError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f1'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_exception"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+
+    {
+        structs::Erroneous obj;
+        obj.f2 = {{.error_type = structs::ConversionFailureType::kError}};
+
+        try {
+            auto result = StructToMessage(std::move(obj));
+            FAIL() << "exception should be thrown";
+        } catch (const ups::WriteError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f2.error_field'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_error"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+
+    {
+        structs::Erroneous obj;
+        obj.f3 = {{10, {.error_type = structs::ConversionFailureType::kErrorWithUnknownField}}};
+
+        try {
+            auto result = StructToMessage(obj);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::WriteError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f3.<unknown_1001>'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_error_with_unknown_field"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+
+    {
+        structs::Erroneous obj;
+        obj.test_oneof.Set<0>({.error_type = structs::ConversionFailureType::kErrorWithUnknownField});
+
+        try {
+            auto result = StructToMessage(obj);
+            FAIL() << "exception should be thrown";
+        } catch (const ups::WriteError& e) {
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("'messages.Erroneous.f4.<unknown_1001>'"));
+            EXPECT_THAT(e.what(), ::testing::HasSubstr("conversion_failure_error_with_unknown_field"));
+        } catch (...) {
+            FAIL() << "unexpected exception type";
+        }
+    }
+}
+
+}  // namespace proto_structs::tests
+
+USERVER_NAMESPACE_END
diff --git a/libraries/proto-structs/tests/structs.cpp b/libraries/proto-structs/tests/structs.cpp
new file mode 100644
index 000000000000..5937bb181dbb
--- /dev/null
+++ b/libraries/proto-structs/tests/structs.cpp
@@ -0,0 +1,1004 @@
+#include "structs.hpp"
+
+#include <gtest/gtest.h>
+
+#include <google/protobuf/util/time_util.h>
+
+#include <cstdint>
+#include <userver/proto-structs/io/impl/read.hpp>
+#include <userver/proto-structs/io/impl/write.hpp>
+#include <userver/proto-structs/io/supported_types_conv.hpp>
+
+#include "messages.pb.h"
+
+namespace structs {
+
+ConversionFailure
+ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<ConversionFailure>, const messages::ConversionFailure& msg) {
+    if (msg.error_type() == messages::ConversionFailure::TYPE_EXCEPTION) {
+        throw std::runtime_error("conversion_failure_exception");
+    } else if (msg.error_type() == messages::ConversionFailure::TYPE_ERROR) {
+        ctx.AddError(messages::ConversionFailure::kErrorFieldFieldNumber, "conversion_failure_error");
+    } else {
+        ctx.AddError(1001, "conversion_failure_error_with_unknown_field");
+    }
+
+    return {};
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const ConversionFailure& obj, messages::ConversionFailure&) {
+    if (obj.error_type == ConversionFailureType::kException) {
+        throw std::runtime_error("conversion_failure_exception");
+    } else if (obj.error_type == ConversionFailureType::kError) {
+        ctx.AddError(messages::ConversionFailure::kErrorFieldFieldNumber, "conversion_failure_error");
+    } else {
+        ctx.AddError(1001, "conversion_failure_error_with_unknown_field");
+    }
+}
+
+Scalar ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Scalar>, const messages::Scalar& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<bool>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF1FieldNumber, &messages::Scalar::f1)
+        ),
+        .f2 = ups::io::impl::ReadField<int32_t>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF2FieldNumber, &messages::Scalar::f2)
+        ),
+        .f3 = ups::io::impl::ReadField<uint32_t>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF3FieldNumber, &messages::Scalar::f3)
+        ),
+        .f4 = ups::io::impl::ReadField<int64_t>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF4FieldNumber, &messages::Scalar::f4)
+        ),
+        .f5 = ups::io::impl::ReadField<uint64_t>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF5FieldNumber, &messages::Scalar::f5)
+        ),
+        .f6 = ups::io::impl::ReadField<float>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF6FieldNumber, &messages::Scalar::f6)
+        ),
+        .f7 = ups::io::impl::ReadField<double>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF7FieldNumber, &messages::Scalar::f7)
+        ),
+        .f8 = ups::io::impl::ReadField<std::string>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF8FieldNumber, &messages::Scalar::f8)
+        ),
+        .f9 = ups::io::impl::ReadField<std::string>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF9FieldNumber, &messages::Scalar::f9)
+        ),
+        .f10 = ups::io::impl::ReadField<TestEnum>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF10FieldNumber, &messages::Scalar::f10)
+        ),
+        .f11 = ups::io::impl::ReadField<std::size_t>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Scalar::kF11FieldNumber, &messages::Scalar::f11)
+        )};
+}
+
+template <typename T>
+void WriteScalarStruct(ups::io::WriteContext& ctx, T&& obj, messages::Scalar& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF1FieldNumber, &messages::Scalar::set_f1, &messages::Scalar::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF2FieldNumber, &messages::Scalar::set_f2, &messages::Scalar::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF3FieldNumber, &messages::Scalar::set_f3, &messages::Scalar::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF4FieldNumber, &messages::Scalar::set_f4, &messages::Scalar::clear_f4
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f5,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF5FieldNumber, &messages::Scalar::set_f5, &messages::Scalar::clear_f5
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f6,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF6FieldNumber, &messages::Scalar::set_f6, &messages::Scalar::clear_f6
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f7,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF7FieldNumber, &messages::Scalar::set_f7, &messages::Scalar::clear_f7
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f8,
+        ups::io::impl::CreateFieldSetter(
+            msg,
+            messages::Scalar::kF8FieldNumber,
+            &messages::Scalar::set_f8<const std::string&>,
+            &messages::Scalar::set_f8<std::string>,
+            &messages::Scalar::clear_f8
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f9,
+        ups::io::impl::CreateFieldSetter(
+            msg,
+            messages::Scalar::kF9FieldNumber,
+            &messages::Scalar::set_f9<const std::string&>,
+            &messages::Scalar::set_f9<std::string>,
+            &messages::Scalar::clear_f9
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f10,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF10FieldNumber, &messages::Scalar::set_f10, &messages::Scalar::clear_f10
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f11,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Scalar::kF11FieldNumber, &messages::Scalar::set_f11, &messages::Scalar::clear_f11
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Scalar& obj, messages::Scalar& msg) {
+    WriteScalarStruct(ctx, obj, msg);
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, Scalar&& obj, messages::Scalar& msg) {
+    WriteScalarStruct(ctx, std::move(obj), msg);
+}
+
+WellKnown ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<WellKnown>, const messages::WellKnown& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<ups::Any>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF1FieldNumber, &messages::WellKnown::f1)
+        ),
+        .f2 = ups::io::impl::ReadField<std::chrono::time_point<std::chrono::system_clock>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF2FieldNumber, &messages::WellKnown::f2)
+        ),
+        .f3 = ups::io::impl::ReadField<std::chrono::milliseconds>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF3FieldNumber, &messages::WellKnown::f3)
+        ),
+        .f4 = ups::io::impl::ReadField<std::chrono::year_month_day>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF4FieldNumber, &messages::WellKnown::f4)
+        ),
+        .f5 = ups::io::impl::ReadField<std::chrono::hh_mm_ss<std::chrono::microseconds>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF5FieldNumber, &messages::WellKnown::f5)
+        ),
+        .f6 = ups::io::impl::ReadField<USERVER_NAMESPACE::utils::datetime::TimeOfDay<std::chrono::microseconds>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF6FieldNumber, &messages::WellKnown::f6)
+        ),
+        .f7 = ups::io::impl::ReadField<USERVER_NAMESPACE::decimal64::Decimal<3>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::WellKnown::kF7FieldNumber, &messages::WellKnown::f7)
+        )};
+}
+
+template <typename T>
+void WriteWellKnownStruct(ups::io::WriteContext& ctx, T&& obj, messages::WellKnown& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF1FieldNumber, &messages::WellKnown::mutable_f1, &messages::WellKnown::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF2FieldNumber, &messages::WellKnown::mutable_f2, &messages::WellKnown::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF3FieldNumber, &messages::WellKnown::mutable_f3, &messages::WellKnown::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF4FieldNumber, &messages::WellKnown::mutable_f4, &messages::WellKnown::clear_f4
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f5,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF5FieldNumber, &messages::WellKnown::mutable_f5, &messages::WellKnown::clear_f5
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f6,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF6FieldNumber, &messages::WellKnown::mutable_f6, &messages::WellKnown::clear_f6
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f7,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::WellKnown::kF7FieldNumber, &messages::WellKnown::mutable_f7, &messages::WellKnown::clear_f7
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const WellKnown& obj, messages::WellKnown& msg) {
+    WriteWellKnownStruct(ctx, obj, msg);
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, WellKnown&& obj, messages::WellKnown& msg) {
+    WriteWellKnownStruct(ctx, std::move(obj), msg);
+}
+
+Optional ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Optional>, const messages::Optional& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<std::optional<int32_t>>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Optional::kF1FieldNumber, &messages::Optional::f1, &messages::Optional::has_f1
+            )
+        ),
+        .f2 = ups::io::impl::ReadField<std::optional<std::string>>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Optional::kF2FieldNumber, &messages::Optional::f2, &messages::Optional::has_f2
+            )
+        ),
+        .f3 = ups::io::impl::ReadField<std::optional<TestEnum>>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Optional::kF3FieldNumber, &messages::Optional::f3, &messages::Optional::has_f3
+            )
+        ),
+        .f4 = ups::io::impl::ReadField<std::optional<Simple>>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Optional::kF4FieldNumber, &messages::Optional::f4, &messages::Optional::has_f4
+            )
+        )};
+}
+
+template <typename T>
+void WriteOptionalStruct(ups::io::WriteContext& ctx, T&& obj, messages::Optional& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Optional::kF1FieldNumber, &messages::Optional::set_f1, &messages::Optional::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg,
+            messages::Optional::kF2FieldNumber,
+            &messages::Optional::set_f2<const std::string&>,
+            &messages::Optional::set_f2<std::string>,
+            &messages::Optional::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Optional::kF3FieldNumber, &messages::Optional::set_f3, &messages::Optional::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Optional::kF4FieldNumber, &messages::Optional::mutable_f4, &messages::Optional::clear_f4
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Optional& obj, messages::Optional& msg) {
+    WriteOptionalStruct(ctx, obj, msg);
+}
+void WriteProtoStruct(ups::io::WriteContext& ctx, Optional&& obj, messages::Optional& msg) {
+    WriteOptionalStruct(ctx, std::move(obj), msg);
+}
+
+Repeated ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Repeated>, const messages::Repeated& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<std::vector<int32_t>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Repeated::kF1FieldNumber, &messages::Repeated::f1)
+        ),
+        .f2 = ups::io::impl::ReadField<std::vector<std::string>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Repeated::kF2FieldNumber, &messages::Repeated::f2)
+        ),
+        .f3 = ups::io::impl::ReadField<std::vector<TestEnum>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Repeated::kF3FieldNumber, &messages::Repeated::f3)
+        ),
+        .f4 = ups::io::impl::ReadField<std::vector<Simple>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Repeated::kF4FieldNumber, &messages::Repeated::f4)
+        )};
+}
+
+template <typename T>
+void WriteRepeatedStruct(ups::io::WriteContext& ctx, T&& obj, messages::Repeated& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Repeated::kF1FieldNumber, &messages::Repeated::mutable_f1, &messages::Repeated::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Repeated::kF2FieldNumber, &messages::Repeated::mutable_f2, &messages::Repeated::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Repeated::kF3FieldNumber, &messages::Repeated::mutable_f3, &messages::Repeated::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Repeated::kF4FieldNumber, &messages::Repeated::mutable_f4, &messages::Repeated::clear_f4
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Repeated& obj, messages::Repeated& msg) {
+    WriteRepeatedStruct(ctx, obj, msg);
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, Repeated&& obj, messages::Repeated& msg) {
+    WriteRepeatedStruct(ctx, std::move(obj), msg);
+}
+
+Map ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Map>, const messages::Map& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<std::map<int32_t, int32_t>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Map::kF1FieldNumber, &messages::Map::f1)
+        ),
+        .f2 = ups::io::impl::ReadField<std::unordered_map<std::string, std::string>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Map::kF2FieldNumber, &messages::Map::f2)
+        ),
+        .f3 = ups::io::impl::ReadField<std::map<bool, TestEnum>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Map::kF3FieldNumber, &messages::Map::f3)
+        ),
+        .f4 = ups::io::impl::ReadField<std::unordered_map<std::string, Simple, USERVER_NAMESPACE::utils::StrCaseHash>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Map::kF4FieldNumber, &messages::Map::f4)
+        )};
+}
+
+template <typename T>
+void WriteMapStruct(ups::io::WriteContext& ctx, T&& obj, messages::Map& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Map::kF1FieldNumber, &messages::Map::mutable_f1, &messages::Map::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Map::kF2FieldNumber, &messages::Map::mutable_f2, &messages::Map::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Map::kF3FieldNumber, &messages::Map::mutable_f3, &messages::Map::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Map::kF4FieldNumber, &messages::Map::mutable_f4, &messages::Map::clear_f4
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Map& obj, messages::Map& msg) { WriteMapStruct(ctx, obj, msg); }
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, Map&& obj, messages::Map& msg) {
+    WriteMapStruct(ctx, std::move(obj), msg);
+}
+
+Oneof ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Oneof>, const messages::Oneof& msg) {
+    return {
+        .test_oneof = ups::io::impl::ReadField<Oneof::Type>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Oneof::kF1FieldNumber, &messages::Oneof::f1, &messages::Oneof::has_f1
+            ),
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Oneof::kF2FieldNumber, &messages::Oneof::f2, &messages::Oneof::has_f2
+            ),
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Oneof::kF3FieldNumber, &messages::Oneof::f3, &messages::Oneof::has_f3
+            ),
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Oneof::kF4FieldNumber, &messages::Oneof::f4, &messages::Oneof::has_f4
+            )
+        )};
+}
+
+template <typename T>
+void WriteOneofStruct(ups::io::WriteContext& ctx, T&& obj, messages::Oneof& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).test_oneof,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Oneof::kF1FieldNumber, &messages::Oneof::set_f1, &messages::Oneof::clear_f1
+        ),
+        ups::io::impl::CreateFieldSetter(
+            msg,
+            messages::Oneof::kF2FieldNumber,
+            &messages::Oneof::set_f2<const std::string&>,
+            &messages::Oneof::set_f2<std::string>,
+            &messages::Oneof::clear_f2
+        ),
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Oneof::kF3FieldNumber, &messages::Oneof::set_f3, &messages::Oneof::clear_f3
+        ),
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Oneof::kF4FieldNumber, &messages::Oneof::mutable_f4, &messages::Oneof::clear_f4
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Oneof& obj, messages::Oneof& msg) {
+    WriteOneofStruct(ctx, obj, msg);
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, Oneof&& obj, messages::Oneof& msg) {
+    WriteOneofStruct(ctx, std::move(obj), msg);
+}
+
+Indirect ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Indirect>, const messages::Indirect& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<Indirect::Box<Simple>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Indirect::kF1FieldNumber, &messages::Indirect::f1)
+        ),
+        .f2 = ups::io::impl::ReadField<std::optional<Indirect::Box<std::chrono::nanoseconds>>>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Indirect::kF2FieldNumber, &messages::Indirect::f2, &messages::Indirect::has_f2
+            )
+        ),
+        .f3 = ups::io::impl::ReadField<std::vector<Indirect::Box<Simple>>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Indirect::kF3FieldNumber, &messages::Indirect::f3)
+        ),
+        .f4 = ups::io::impl::ReadField<std::map<int32_t, Indirect::Box<Simple>>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Indirect::kF4FieldNumber, &messages::Indirect::f4)
+        ),
+        .test_oneof = ups::io::impl::ReadField<Indirect::OneofType>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Indirect::kF5FieldNumber, &messages::Indirect::f5, &messages::Indirect::has_f5
+            ),
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Indirect::kF6FieldNumber, &messages::Indirect::f6, &messages::Indirect::has_f6
+            )
+        ),
+        .f7 = ups::io::impl::ReadField<Indirect::Box<int32_t>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Indirect::kF7FieldNumber, &messages::Indirect::f7)
+        ),
+        .f8 = ups::io::impl::ReadField<Indirect::Box<std::vector<Indirect::Box<TestEnum>>>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Indirect::kF8FieldNumber, &messages::Indirect::f8)
+        ),
+        .f9 = ups::io::impl::ReadField<Indirect::Box<std::map<std::string, Indirect::Box<Simple>>>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Indirect::kF9FieldNumber, &messages::Indirect::f9)
+        )};
+}
+
+template <typename T>
+void WriteIndirectStruct(ups::io::WriteContext& ctx, T&& obj, messages::Indirect& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF1FieldNumber, &messages::Indirect::mutable_f1, &messages::Indirect::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF2FieldNumber, &messages::Indirect::mutable_f2, &messages::Indirect::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF3FieldNumber, &messages::Indirect::mutable_f3, &messages::Indirect::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF4FieldNumber, &messages::Indirect::mutable_f4, &messages::Indirect::clear_f4
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).test_oneof,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF5FieldNumber, &messages::Indirect::mutable_f5, &messages::Indirect::clear_f5
+        ),
+        ups::io::impl::CreateFieldSetter(
+            msg,
+            messages::Indirect::kF6FieldNumber,
+            &messages::Indirect::set_f6<const std::string&>,
+            &messages::Indirect::set_f6<std::string>,
+            &messages::Indirect::clear_f6
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f7,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF7FieldNumber, &messages::Indirect::set_f7, &messages::Indirect::clear_f7
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f8,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF8FieldNumber, &messages::Indirect::mutable_f8, &messages::Indirect::clear_f8
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f9,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Indirect::kF9FieldNumber, &messages::Indirect::mutable_f9, &messages::Indirect::clear_f9
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Indirect& obj, messages::Indirect& msg) {
+    WriteIndirectStruct(ctx, obj, msg);
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, Indirect&& obj, messages::Indirect& msg) {
+    WriteIndirectStruct(ctx, std::move(obj), msg);
+}
+
+Strong ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Strong>, const messages::Strong& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<USERVER_NAMESPACE::utils::StrongTypedef<Strong::Tag, int32_t>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Strong::kF1FieldNumber, &messages::Strong::f1)
+        ),
+        .f2 =
+            ups::io::impl::ReadField<std::optional<USERVER_NAMESPACE::utils::StrongTypedef<Strong::Tag, std::string>>>(
+                ctx,
+                ups::io::impl::CreateFieldGetter(
+                    msg, messages::Strong::kF2FieldNumber, &messages::Strong::f2, &messages::Strong::has_f2
+                )
+            ),
+        .f3 = ups::io::impl::ReadField<std::vector<USERVER_NAMESPACE::utils::StrongTypedef<Strong::Tag, TestEnum>>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Strong::kF3FieldNumber, &messages::Strong::f3)
+        ),
+        .f4 = ups::io::impl::ReadField<std::map<int32_t, USERVER_NAMESPACE::utils::StrongTypedef<Strong::Tag, Simple>>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Strong::kF4FieldNumber, &messages::Strong::f4)
+        ),
+        .test_oneof = ups::io::impl::ReadField<Strong::OneofType>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Strong::kF5FieldNumber, &messages::Strong::f5, &messages::Strong::has_f5
+            )
+        )};
+}
+
+template <typename T>
+void WriteStrongStruct(ups::io::WriteContext& ctx, T&& obj, messages::Strong& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Strong::kF1FieldNumber, &messages::Strong::set_f1, &messages::Strong::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f2,
+        ups::io::impl::CreateFieldSetter(
+            msg,
+            messages::Strong::kF2FieldNumber,
+            &messages::Strong::set_f2<const std::string&>,
+            &messages::Strong::set_f2<std::string>,
+            &messages::Strong::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Strong::kF3FieldNumber, &messages::Strong::mutable_f3, &messages::Strong::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).f4,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Strong::kF4FieldNumber, &messages::Strong::mutable_f4, &messages::Strong::clear_f4
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        std::forward<T>(obj).test_oneof,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Strong::kF1FieldNumber, &messages::Strong::mutable_f5, &messages::Strong::clear_f5
+        )
+    );
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Strong& obj, messages::Strong& msg) {
+    WriteStrongStruct(ctx, obj, msg);
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, Strong&& obj, messages::Strong& msg) {
+    WriteStrongStruct(ctx, std::move(obj), msg);
+}
+
+Erroneous ReadProtoStruct(ups::io::ReadContext& ctx, ups::io::To<Erroneous>, const messages::Erroneous& msg) {
+    return {
+        .f1 = ups::io::impl::ReadField<std::optional<ConversionFailure>>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Erroneous::kF1FieldNumber, &messages::Erroneous::f1, &messages::Erroneous::has_f1
+            )
+        ),
+        .f2 = ups::io::impl::ReadField<std::vector<ConversionFailure>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Erroneous::kF2FieldNumber, &messages::Erroneous::f2)
+        ),
+        .f3 = ups::io::impl::ReadField<std::unordered_map<int32_t, ConversionFailure>>(
+            ctx, ups::io::impl::CreateFieldGetter(msg, messages::Erroneous::kF3FieldNumber, &messages::Erroneous::f3)
+        ),
+        .test_oneof = ups::io::impl::ReadField<Erroneous::OneofType>(
+            ctx,
+            ups::io::impl::CreateFieldGetter(
+                msg, messages::Erroneous::kF4FieldNumber, &messages::Erroneous::f4, &messages::Erroneous::has_f4
+            )
+        )};
+}
+
+void WriteProtoStruct(ups::io::WriteContext& ctx, const Erroneous& obj, messages::Erroneous& msg) {
+    ups::io::impl::WriteField(
+        ctx,
+        obj.f1,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Erroneous::kF1FieldNumber, &messages::Erroneous::mutable_f1, &messages::Erroneous::clear_f1
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        obj.f2,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Erroneous::kF2FieldNumber, &messages::Erroneous::mutable_f2, &messages::Erroneous::clear_f2
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        obj.f3,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Erroneous::kF3FieldNumber, &messages::Erroneous::mutable_f3, &messages::Erroneous::clear_f3
+        )
+    );
+    ups::io::impl::WriteField(
+        ctx,
+        obj.test_oneof,
+        ups::io::impl::CreateFieldSetter(
+            msg, messages::Erroneous::kF4FieldNumber, &messages::Erroneous::mutable_f4, &messages::Erroneous::clear_f4
+        )
+    );
+}
+
+void CheckScalarEqual(const Scalar& obj, const messages::Scalar& msg) {
+    EXPECT_EQ(obj.f1, msg.f1());
+    EXPECT_EQ(obj.f2, msg.f2());
+    EXPECT_EQ(obj.f3, msg.f3());
+    EXPECT_EQ(obj.f4, msg.f4());
+    EXPECT_EQ(obj.f5, msg.f5());
+    EXPECT_EQ(obj.f6, msg.f6());
+    EXPECT_EQ(obj.f7, msg.f7());
+    EXPECT_EQ(obj.f8, msg.f8());
+    EXPECT_EQ(obj.f9, msg.f9());
+    EXPECT_EQ(obj.f10, static_cast<TestEnum>(msg.f10()));
+    EXPECT_EQ(static_cast<int>(obj.f11), msg.f11());
+}
+
+void CheckWellKnownEqual(const WellKnown& obj, const messages::WellKnown& msg) {
+    using TimeType = std::chrono::time_point<std::chrono::system_clock>;
+
+    EXPECT_EQ(obj.f1.GetProtobufAny().type_url(), msg.f1().type_url());
+    EXPECT_EQ(obj.f1.GetProtobufAny().value(), msg.f1().value());
+    EXPECT_EQ(
+        obj.f2.time_since_epoch(),
+        std::chrono::duration_cast<TimeType::duration>(std::chrono::nanoseconds{
+            ::google::protobuf::util::TimeUtil::TimestampToNanoseconds(msg.f2())})
+    );
+    EXPECT_EQ(
+        obj.f3,
+        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::nanoseconds{
+            ::google::protobuf::util::TimeUtil::DurationToNanoseconds(msg.f3())})
+    );
+
+    EXPECT_EQ(static_cast<int>(obj.f4.year()), msg.f4().year());
+    EXPECT_EQ(static_cast<unsigned>(obj.f4.month()), static_cast<unsigned>(msg.f4().month()));
+    EXPECT_EQ(static_cast<unsigned>(obj.f4.day()), static_cast<unsigned>(msg.f4().day()));
+
+    EXPECT_EQ(obj.f5.hours().count(), msg.f5().hours());
+    EXPECT_EQ(obj.f5.minutes().count(), msg.f5().minutes());
+    EXPECT_EQ(obj.f5.seconds().count(), msg.f5().seconds());
+    EXPECT_EQ(
+        obj.f5.subseconds().count(),
+        std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::nanoseconds(msg.f5().nanos())).count()
+    );
+
+    EXPECT_EQ(obj.f6.Hours().count(), msg.f6().hours());
+    EXPECT_EQ(obj.f6.Minutes().count(), msg.f6().minutes());
+    EXPECT_EQ(obj.f6.Seconds().count(), msg.f6().seconds());
+    EXPECT_EQ(
+        obj.f6.Subseconds().count(),
+        std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::nanoseconds(msg.f6().nanos())).count()
+    );
+
+    EXPECT_EQ(obj.f7, decimal64::Decimal<3>(msg.f7().value()));
+    EXPECT_EQ(ToString(obj.f7), msg.f7().value());
+}
+
+void CheckOptionalEqual(const Optional& obj, const messages::Optional& msg) {
+    if (obj.f1) {
+        EXPECT_TRUE(msg.has_f1());
+        EXPECT_EQ(obj.f1.value(), msg.f1());
+    } else {
+        EXPECT_FALSE(msg.has_f1());
+    }
+
+    if (obj.f2) {
+        EXPECT_TRUE(msg.has_f2());
+        EXPECT_EQ(obj.f2.value(), msg.f2());
+    } else {
+        EXPECT_FALSE(msg.has_f2());
+    }
+
+    if (obj.f3) {
+        EXPECT_TRUE(msg.has_f3());
+        EXPECT_EQ(obj.f3.value(), static_cast<TestEnum>(msg.f3()));
+    } else {
+        EXPECT_FALSE(msg.has_f3());
+    }
+
+    if (obj.f4) {
+        EXPECT_TRUE(msg.has_f4());
+        CheckSimpleEqual(obj.f4.value(), msg.f4());
+    } else {
+        EXPECT_FALSE(msg.has_f4());
+    }
+}
+
+void CheckRepeatedEqual(const Repeated& obj, const messages::Repeated& msg) {
+    ASSERT_EQ(obj.f1.size(), static_cast<std::size_t>(msg.f1().size()));
+
+    for (int i = 0; i < msg.f1().size(); ++i) {
+        EXPECT_EQ(obj.f1[i], msg.f1()[i]);
+    }
+
+    ASSERT_EQ(obj.f2.size(), static_cast<std::size_t>(msg.f2().size()));
+
+    for (int i = 0; i < msg.f2().size(); ++i) {
+        EXPECT_EQ(obj.f2[i], msg.f2()[i]);
+    }
+
+    ASSERT_EQ(obj.f3.size(), static_cast<std::size_t>(msg.f3().size()));
+
+    for (int i = 0; i < msg.f3().size(); ++i) {
+        EXPECT_EQ(static_cast<int>(obj.f3[i]), msg.f3()[i]);
+    }
+
+    ASSERT_EQ(obj.f4.size(), static_cast<std::size_t>(msg.f4().size()));
+
+    for (int i = 0; i < msg.f4().size(); ++i) {
+        EXPECT_EQ(obj.f4[i].f1, msg.f4()[i].f1());
+    }
+}
+
+void CheckMapEqual(const Map& obj, const messages::Map& msg) {
+    ASSERT_EQ(obj.f1.size(), static_cast<std::size_t>(msg.f1().size()));
+
+    for (const auto& [key, value] : msg.f1()) {
+        ASSERT_EQ(obj.f1.count(key), std::size_t{1});
+        EXPECT_EQ(obj.f1.at(key), value);
+    }
+
+    ASSERT_EQ(obj.f2.size(), static_cast<std::size_t>(msg.f2().size()));
+
+    for (const auto& [key, value] : msg.f2()) {
+        ASSERT_EQ(obj.f2.count(key), std::size_t{1});
+        EXPECT_EQ(obj.f2.at(key), value);
+    }
+
+    ASSERT_EQ(obj.f3.size(), static_cast<std::size_t>(msg.f3().size()));
+
+    for (const auto& [key, value] : msg.f3()) {
+        ASSERT_EQ(obj.f3.count(key), std::size_t{1});
+        EXPECT_EQ(obj.f3.at(key), static_cast<TestEnum>(value));
+    }
+
+    ASSERT_EQ(obj.f4.size(), static_cast<std::size_t>(msg.f4().size()));
+
+    for (const auto& [key, value] : msg.f4()) {
+        ASSERT_EQ(obj.f4.count(key), std::size_t{1});
+        CheckSimpleEqual(obj.f4.at(key), value);
+    }
+}
+
+void CheckOneofEqual(const Oneof& obj, const messages::Oneof& msg) {
+    if (!obj.test_oneof.ContainsAny()) {
+        EXPECT_EQ(msg.test_oneof_case(), messages::Oneof::TEST_ONEOF_NOT_SET);
+    }
+
+    if (obj.test_oneof.Contains(0)) {
+        EXPECT_TRUE(msg.has_f1());
+        EXPECT_EQ(obj.test_oneof.Get<0>(), msg.f1());
+    } else {
+        EXPECT_FALSE(msg.has_f1());
+    }
+
+    if (obj.test_oneof.Contains(1)) {
+        EXPECT_TRUE(msg.has_f2());
+        EXPECT_EQ(obj.test_oneof.Get<1>(), msg.f2());
+    } else {
+        EXPECT_FALSE(msg.has_f2());
+    }
+
+    if (obj.test_oneof.Contains(2)) {
+        EXPECT_TRUE(msg.has_f3());
+        EXPECT_EQ(obj.test_oneof.Get<2>(), static_cast<TestEnum>(msg.f3()));
+    } else {
+        EXPECT_FALSE(msg.has_f3());
+    }
+
+    if (obj.test_oneof.Contains(3)) {
+        EXPECT_TRUE(msg.has_f4());
+        CheckSimpleEqual(obj.test_oneof.Get<3>(), msg.f4());
+    } else {
+        EXPECT_FALSE(msg.has_f4());
+    }
+}
+
+void CheckIndirectEqual(const Indirect& obj, const messages::Indirect& msg) {
+    CheckSimpleEqual(*obj.f1, msg.f1());
+
+    if (obj.f2) {
+        EXPECT_TRUE(msg.has_f2());
+        EXPECT_EQ(
+            *obj.f2.value(),
+            std::chrono::nanoseconds{::google::protobuf::util::TimeUtil::DurationToNanoseconds(msg.f2())}
+        );
+    } else {
+        EXPECT_FALSE(msg.has_f2());
+    }
+
+    ASSERT_EQ(obj.f3.size(), static_cast<std::size_t>(msg.f3().size()));
+
+    for (int i = 0; i < msg.f3().size(); ++i) {
+        CheckSimpleEqual(*obj.f3[i], msg.f3()[i]);
+    }
+
+    ASSERT_EQ(obj.f4.size(), static_cast<std::size_t>(msg.f4().size()));
+
+    for (const auto& [key, value] : msg.f4()) {
+        ASSERT_EQ(obj.f4.count(key), std::size_t{1});
+        CheckSimpleEqual(*obj.f4.at(key), value);
+    }
+
+    if (!obj.test_oneof.ContainsAny()) {
+        EXPECT_EQ(msg.test_oneof_case(), messages::Indirect::TEST_ONEOF_NOT_SET);
+    }
+
+    if (obj.test_oneof.Contains(0)) {
+        EXPECT_TRUE(msg.has_f5());
+        CheckSimpleEqual(*obj.test_oneof.Get<0>(), msg.f5());
+    } else {
+        EXPECT_FALSE(msg.has_f5());
+    }
+
+    if (obj.test_oneof.Contains(1)) {
+        EXPECT_TRUE(msg.has_f6());
+        EXPECT_EQ(*obj.test_oneof.Get<1>(), msg.f6());
+    } else {
+        EXPECT_FALSE(msg.has_f6());
+    }
+
+    EXPECT_EQ(*obj.f7, msg.f7());
+    ASSERT_EQ((*obj.f8).size(), static_cast<std::size_t>(msg.f8().size()));
+
+    for (int i = 0; i < msg.f8().size(); ++i) {
+        EXPECT_EQ(*((*obj.f8)[i]), static_cast<TestEnum>(msg.f8()[i]));
+    }
+
+    ASSERT_EQ((*obj.f9).size(), static_cast<std::size_t>(msg.f9().size()));
+
+    for (const auto& [key, value] : msg.f9()) {
+        ASSERT_EQ((*obj.f9).count(key), std::size_t{1});
+        CheckSimpleEqual(*((*obj.f9).at(key)), value);
+    }
+}
+
+void CheckStrongEqual(const Strong& obj, const messages::Strong& msg) {
+    EXPECT_EQ(obj.f1.GetUnderlying(), msg.f1());
+
+    if (obj.f2) {
+        EXPECT_TRUE(msg.has_f2());
+        EXPECT_EQ(obj.f2.value().GetUnderlying(), msg.f2());
+    } else {
+        EXPECT_FALSE(msg.has_f2());
+    }
+
+    ASSERT_EQ(obj.f3.size(), static_cast<std::size_t>(msg.f3().size()));
+
+    for (int i = 0; i < msg.f3().size(); ++i) {
+        EXPECT_EQ(static_cast<int>(obj.f3[i].GetUnderlying()), msg.f3()[i]);
+    }
+
+    ASSERT_EQ(obj.f4.size(), static_cast<std::size_t>(msg.f4().size()));
+
+    for (const auto& [key, value] : msg.f4()) {
+        ASSERT_EQ(obj.f4.count(key), std::size_t{1});
+        CheckSimpleEqual(obj.f4.at(key).GetUnderlying(), value);
+    }
+
+    if (!obj.test_oneof.ContainsAny()) {
+        EXPECT_EQ(msg.test_oneof_case(), messages::Strong::TEST_ONEOF_NOT_SET);
+    }
+
+    if (obj.test_oneof.Contains(0)) {
+        EXPECT_TRUE(msg.has_f5());
+        EXPECT_EQ(
+            obj.test_oneof.Get<0>().GetUnderlying(),
+            std::chrono::nanoseconds{::google::protobuf::util::TimeUtil::DurationToNanoseconds(msg.f5())}
+        );
+    } else {
+        EXPECT_FALSE(msg.has_f5());
+    }
+}
+
+}  // namespace structs
diff --git a/libraries/proto-structs/tests/structs.hpp b/libraries/proto-structs/tests/structs.hpp
new file mode 100644
index 000000000000..7945407e8e57
--- /dev/null
+++ b/libraries/proto-structs/tests/structs.hpp
@@ -0,0 +1,203 @@
+#pragma once
+
+#include <cstdint>
+#include <userver/proto-structs/io/fwd.hpp>
+#include <userver/proto-structs/io/supported_types.hpp>
+#include <userver/proto-structs/type_mapping.hpp>
+
+#include "struct_simple.hpp"
+#include "userver/utils/box.hpp"
+
+namespace messages {
+class ConversionFailure;
+class Scalar;
+class WellKnown;
+class Optional;
+class Repeated;
+class Map;
+class Oneof;
+class Indirect;
+class Strong;
+class Erroneous;
+}  // namespace messages
+
+namespace structs {
+
+enum class ConversionFailureType { kUnspecified = 0, kException = 1, kError = 2, kErrorWithUnknownField = 3 };
+
+struct ConversionFailure {
+    ConversionFailureType error_type = {};
+};
+
+}  // namespace structs
+
+namespace proto_structs::traits {
+
+template <>
+struct CompatibleMessageTrait<::structs::ConversionFailure> {
+    using Type = ::messages::ConversionFailure;
+};
+
+}  // namespace proto_structs::traits
+
+namespace structs {
+
+enum class TestEnum { kUnspecified = 0, kValue1 = 1, kValue2 = 2 };
+
+struct Scalar {
+    using ProtobufMessage = messages::Scalar;
+
+    bool f1 = {};
+    int32_t f2 = {};
+    uint32_t f3 = {};
+    int64_t f4 = {};
+    uint64_t f5 = {};
+    float f6 = {};
+    double f7 = {};
+    std::string f8 = {};
+    std::string f9 = {};
+    TestEnum f10 = {};
+    std::size_t f11 = {};
+};
+
+struct WellKnown {
+    using ProtobufMessage = messages::WellKnown;
+
+    ups::Any f1 = {};
+    std::chrono::time_point<std::chrono::system_clock> f2 = {};
+    std::chrono::milliseconds f3 = {};
+    std::chrono::year_month_day f4 = {};
+    std::chrono::hh_mm_ss<std::chrono::microseconds> f5 = {};
+    USERVER_NAMESPACE::utils::datetime::TimeOfDay<std::chrono::microseconds> f6 = {};
+    USERVER_NAMESPACE::decimal64::Decimal<3> f7 = {};
+};
+
+struct Optional {
+    using ProtobufMessage = messages::Optional;
+
+    std::optional<int32_t> f1 = {};
+    std::optional<std::string> f2 = {};
+    std::optional<TestEnum> f3 = {};
+    std::optional<Simple> f4 = {};
+};
+
+struct Repeated {
+    using ProtobufMessage = messages::Repeated;
+
+    std::vector<int32_t> f1 = {};
+    std::vector<std::string> f2 = {};
+    std::vector<TestEnum> f3 = {};
+    std::vector<Simple> f4 = {};
+};
+
+struct Map {
+    using ProtobufMessage = messages::Map;
+
+    std::map<int32_t, int32_t> f1 = {};
+    std::unordered_map<std::string, std::string> f2 = {};
+    std::map<bool, TestEnum> f3 = {};
+    std::unordered_map<std::string, Simple, USERVER_NAMESPACE::utils::StrCaseHash> f4 = {};
+};
+
+struct Oneof {
+    using ProtobufMessage = messages::Oneof;
+    using Type = ups::Oneof<int32_t, std::string, TestEnum, Simple>;
+
+    Type test_oneof = {};
+};
+
+struct Indirect {
+    using ProtobufMessage = messages::Indirect;
+
+    template <typename T>
+    using Box = USERVER_NAMESPACE::utils::Box<T>;
+
+    using OneofType = ups::Oneof<Box<Simple>, Box<std::string>>;
+
+    Box<Simple> f1 = {};
+    std::optional<Box<std::chrono::nanoseconds>> f2 = {};
+    std::vector<Box<Simple>> f3 = {};
+    std::map<int32_t, Box<Simple>> f4 = {};
+    OneofType test_oneof = {};
+    Box<int32_t> f7 = {};
+    Box<std::vector<Box<TestEnum>>> f8 = {};
+    Box<std::map<std::string, Box<Simple>>> f9 = {};
+};
+
+struct Strong {
+    struct Tag {};
+
+    using ProtobufMessage = messages::Strong;
+    using F1Strong = USERVER_NAMESPACE::utils::StrongTypedef<Tag, int32_t>;
+    using F2Strong = USERVER_NAMESPACE::utils::StrongTypedef<Tag, std::string>;
+    using F3Strong = USERVER_NAMESPACE::utils::StrongTypedef<Tag, TestEnum>;
+    using F4Strong = USERVER_NAMESPACE::utils::StrongTypedef<Tag, Simple>;
+    using F5Strong = USERVER_NAMESPACE::utils::StrongTypedef<Tag, std::chrono::nanoseconds>;
+    using OneofType = ups::Oneof<F5Strong>;
+
+    F1Strong f1 = {};
+    std::optional<F2Strong> f2 = {};
+    std::vector<F3Strong> f3 = {};
+    std::map<int32_t, F4Strong> f4 = {};
+    OneofType test_oneof = {};
+};
+
+struct Erroneous {
+    using ProtobufMessage = messages::Erroneous;
+    using OneofType = ups::Oneof<ConversionFailure>;
+
+    std::optional<ConversionFailure> f1 = {};
+    std::vector<ConversionFailure> f2 = {};
+    std::unordered_map<int32_t, ConversionFailure> f3 = {};
+    OneofType test_oneof = {};
+};
+
+ConversionFailure
+ReadProtoStruct(ups::io::ReadContext&, ups::io::To<ConversionFailure>, const messages::ConversionFailure&);
+void WriteProtoStruct(ups::io::WriteContext& ctx, const ConversionFailure&, messages::ConversionFailure&);
+
+Scalar ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Scalar>, const messages::Scalar&);
+void WriteProtoStruct(ups::io::WriteContext&, const Scalar&, messages::Scalar&);
+void WriteProtoStruct(ups::io::WriteContext&, Scalar&&, messages::Scalar&);
+
+WellKnown ReadProtoStruct(ups::io::ReadContext&, ups::io::To<WellKnown>, const messages::WellKnown&);
+void WriteProtoStruct(ups::io::WriteContext&, const WellKnown&, messages::WellKnown&);
+void WriteProtoStruct(ups::io::WriteContext&, WellKnown&&, messages::WellKnown&);
+
+Optional ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Optional>, const messages::Optional&);
+void WriteProtoStruct(ups::io::WriteContext&, const Optional&, messages::Optional&);
+void WriteProtoStruct(ups::io::WriteContext&, Optional&&, messages::Optional&);
+
+Repeated ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Repeated>, const messages::Repeated&);
+void WriteProtoStruct(ups::io::WriteContext&, const Repeated&, messages::Repeated&);
+void WriteProtoStruct(ups::io::WriteContext&, Repeated&&, messages::Repeated&);
+
+Map ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Map>, const messages::Map&);
+void WriteProtoStruct(ups::io::WriteContext&, const Map&, messages::Map&);
+void WriteProtoStruct(ups::io::WriteContext&, Map&&, messages::Map&);
+
+Oneof ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Oneof>, const messages::Oneof&);
+void WriteProtoStruct(ups::io::WriteContext&, const Oneof&, messages::Oneof&);
+void WriteProtoStruct(ups::io::WriteContext&, Oneof&&, messages::Oneof&);
+
+Indirect ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Indirect>, const messages::Indirect&);
+void WriteProtoStruct(ups::io::WriteContext&, const Indirect&, messages::Indirect&);
+void WriteProtoStruct(ups::io::WriteContext&, Indirect&&, messages::Indirect&);
+
+Strong ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Strong>, const messages::Strong&);
+void WriteProtoStruct(ups::io::WriteContext&, const Strong&, messages::Strong&);
+void WriteProtoStruct(ups::io::WriteContext&, Strong&&, messages::Strong&);
+
+Erroneous ReadProtoStruct(ups::io::ReadContext&, ups::io::To<Erroneous>, const messages::Erroneous&);
+void WriteProtoStruct(ups::io::WriteContext&, const Erroneous&, messages::Erroneous&);
+
+void CheckScalarEqual(const Scalar&, const messages::Scalar&);
+void CheckWellKnownEqual(const WellKnown&, const messages::WellKnown&);
+void CheckOptionalEqual(const Optional&, const messages::Optional&);
+void CheckRepeatedEqual(const Repeated&, const messages::Repeated&);
+void CheckMapEqual(const Map&, const messages::Map&);
+void CheckOneofEqual(const Oneof&, const messages::Oneof&);
+void CheckIndirectEqual(const Indirect&, const messages::Indirect&);
+void CheckStrongEqual(const Strong&, const messages::Strong&);
+
+}  // namespace structs
diff --git a/libraries/s3api/CMakeLists.txt b/libraries/s3api/CMakeLists.txt
index 87359ab8009a..40be9c3e9115 100644
--- a/libraries/s3api/CMakeLists.txt
+++ b/libraries/s3api/CMakeLists.txt
@@ -7,6 +7,7 @@ userver_module(
     SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
     LINK_LIBRARIES_PRIVATE pugixml::pugixml
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    DEPENDS core
 )
 
 _userver_directory_install(
diff --git a/libraries/s3api/include/userver/s3api/clients/s3api.hpp b/libraries/s3api/include/userver/s3api/clients/s3api.hpp
index 0e40651e0c11..f67c2e3fc18e 100644
--- a/libraries/s3api/include/userver/s3api/clients/s3api.hpp
+++ b/libraries/s3api/include/userver/s3api/clients/s3api.hpp
@@ -13,7 +13,10 @@
 
 #include <userver/s3api/authenticators/access_key.hpp>
 #include <userver/s3api/authenticators/interface.hpp>
+#include <userver/s3api/models/errors.hpp>
 #include <userver/s3api/models/fwd.hpp>
+#include <userver/s3api/models/multipart_upload/requests.hpp>
+#include <userver/s3api/models/multipart_upload/responses.hpp>
 #include <userver/s3api/models/s3api_connection_type.hpp>
 
 USERVER_NAMESPACE_BEGIN
@@ -27,18 +30,6 @@ class Client;
 /// For more information see @ref scripts/docs/en/userver/libraries/s3api.md .
 namespace s3api {
 
-class AuthHeaderConflictError : public std::runtime_error {
-    using runtime_error::runtime_error;
-};
-
-class NoBucketError : public std::runtime_error {
-    using runtime_error::runtime_error;
-};
-
-class ListBucketError : public std::runtime_error {
-    using runtime_error::runtime_error;
-};
-
 /// Connection settings - retries, timeouts, and so on
 struct ConnectionCfg {
     explicit ConnectionCfg(
@@ -186,6 +177,45 @@ class Client {
 
     virtual std::vector<std::string> ListBucketDirectories(std::string_view path_prefix) const = 0;
 
+    /// @brief Initiate a multipart upload sequence
+    /// Performs a CreateMultipartUpload S3 Action.
+    /// Returns result with `upload ID` which is used to associate all of the parts in the specific multipart upload.
+    /// You specify this `upload ID` in each of your subsequent upload part requests
+    /// For details see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html
+    virtual multipart_upload::InitiateMultipartUploadResult CreateMultipartUpload(
+        const multipart_upload::CreateMultipartUploadRequest& request
+    ) const = 0;
+
+    /// @brief Upload a part in a multipart upload sequence.
+    /// Performs an UploadPart S3 Action.
+    /// Returns ETag value which you must include in the subsequent request to complete the multipart upload.
+    /// For details see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html
+    virtual multipart_upload::UploadPartResult UploadPart(const multipart_upload::UploadPartRequest& request) const = 0;
+
+    /// @brief Complete a multipart upload by assembling previously uploaded parts.
+    /// Performs a CompleteMultipartUpload S3 Action.
+    /// For details see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html
+    virtual multipart_upload::CompleteMultipartUploadResult CompleteMultipartUpload(
+        const multipart_upload::CompleteMultipartUploadRequest& request
+    ) const = 0;
+
+    /// @brief Abort a multipart upload sequence.
+    /// Performs an AbortMultipartUpload S3 Action.
+    /// For details see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html
+    virtual void AbortMultipartUpload(const multipart_upload::AbortMultipartUploadRequest& request) const = 0;
+
+    /// @brief List the parts that have been uploaded for a specific multipart upload.
+    /// Performs a ListParts S3 Action.
+    /// For details see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html
+    virtual multipart_upload::ListPartsResult ListParts(const multipart_upload::ListPartsRequest& request) const = 0;
+
+    /// @brief List in-progress multipart uploads in a bucket
+    /// Performs a ListMultipartUploads S3 Action.
+    /// For details see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html
+    virtual multipart_upload::ListMultipartUploadsResult ListMultipartUploads(
+        const multipart_upload::ListMultipartUploadsRequest& request
+    ) const = 0;
+
     virtual void UpdateConfig(ConnectionCfg&& config) = 0;
 
     virtual std::string_view GetBucketName() const = 0;
diff --git a/libraries/s3api/include/userver/s3api/models/errors.hpp b/libraries/s3api/include/userver/s3api/models/errors.hpp
new file mode 100644
index 000000000000..e92646a5d80c
--- /dev/null
+++ b/libraries/s3api/include/userver/s3api/models/errors.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <stdexcept>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace s3api {
+
+class AuthHeaderConflictError : public std::runtime_error {
+    using runtime_error::runtime_error;
+};
+
+class NoBucketError : public std::runtime_error {
+    using runtime_error::runtime_error;
+};
+
+class ListBucketError : public std::runtime_error {
+    using runtime_error::runtime_error;
+};
+
+class ResponseParsingError : public std::runtime_error {
+    using runtime_error::runtime_error;
+};
+
+class MultipartUploadError : public std::runtime_error {
+    using runtime_error::runtime_error;
+};
+
+}  // namespace s3api
+
+USERVER_NAMESPACE_END
diff --git a/libraries/s3api/include/userver/s3api/models/multipart_upload/requests.hpp b/libraries/s3api/include/userver/s3api/models/multipart_upload/requests.hpp
new file mode 100644
index 000000000000..750295893d0a
--- /dev/null
+++ b/libraries/s3api/include/userver/s3api/models/multipart_upload/requests.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace s3api {
+
+struct Request;
+
+namespace multipart_upload {
+
+/// For some unclear reasons almost all fields in S3 API are optional
+/// including even those fields which are clearly stated to be required
+/// in S3 documentation.
+/// There are some unconvincing explanations for this at
+///  https://github.com/boto/botocore/issues/1069#issuecomment-259255047, but that's it!
+/// This implementation of the API in this library is a bit stricter than it is in S3 API
+/// specifciation, intentionally making some `optional` fields to be `required non-empty`.
+
+/// CreateMultipartUpload action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html#API_CreateMultipartUpload_RequestSyntax
+/// NOTE:
+///     - `key` is expected to be URL encoded
+struct CreateMultipartUploadRequest {
+    std::string key;
+    std::optional<std::string> content_type;
+    std::optional<std::string> content_encoding;
+    std::optional<std::string> content_disposition;
+    std::optional<std::string> content_language;
+};
+
+/// CompleteMultipartUpload action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html#API_CreateMultipartUpload_RequestSyntax
+/// NOTE:
+///   - For each part in the list of completed parts, you must provide the
+///     PartNumber value and the ETag value that are returned after that part was uploaded.
+///     All parts must be placed in ascending order by their PartNumber.
+///     @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html
+///   - `key` is expected to be URL encoded;
+struct CompleteMultipartUploadRequest {
+    /// @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompletedPart.html
+    // It may also contain optional Checksum* attributes.
+    // The specification states that all attributes are optional, however
+    // CompleteMultipartUpload action specification explicitly requires ETag and PartNumber.
+    struct CompletedPart {
+        unsigned part_number;
+        std::string etag;
+    };
+
+    std::string key;
+    std::string upload_id;
+    std::vector<CompletedPart> completed_parts;
+};
+
+/// AbortMultipartUpload action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html#API_AbortMultipartUpload_RequestSyntax
+/// NOTE:
+///     - `key` is expected to be URL encoded
+struct AbortMultipartUploadRequest {
+    std::string key;
+    std::string upload_id;
+};
+
+/// UploadPart action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html#API_UploadPart_RequestSyntax
+struct UploadPartRequest {
+    std::string key;
+    std::string upload_id;
+    unsigned part_number{0};
+    std::string data;
+};
+
+/// ListParts action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html#API_ListParts_RequestSyntax
+/// NOTE:
+///     - The ListParts request returns a maximum of 1,000 uploaded parts.
+///       The limit of 1,000 parts is also the default value.
+///     - `key` is expected to be URL encoded
+struct ListPartsRequest {
+    std::string key;
+    std::string upload_id;
+    unsigned max_parts{1000u};
+    std::optional<unsigned> part_number_marker;
+};
+
+/// ListMultipartUploads action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html#API_ListMultipartUploads_RequestSyntax
+struct ListMultipartUploadsRequest {
+    enum class EncodingType { kNone, kUrl };
+
+    EncodingType encoding_type{EncodingType::kNone};
+    unsigned max_uploads{1000u};
+    std::optional<std::string> delimiter;
+    std::optional<std::string> key_marker;
+    std::optional<std::string> prefix;
+    std::optional<std::string> upload_id_marker;
+};
+
+}  // namespace multipart_upload
+}  // namespace s3api
+
+USERVER_NAMESPACE_END
diff --git a/libraries/s3api/include/userver/s3api/models/multipart_upload/responses.hpp b/libraries/s3api/include/userver/s3api/models/multipart_upload/responses.hpp
new file mode 100644
index 000000000000..31c4ad778d10
--- /dev/null
+++ b/libraries/s3api/include/userver/s3api/models/multipart_upload/responses.hpp
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <chrono>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <userver/utils/zstring_view.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace s3api::multipart_upload {
+
+/// For some unclear reasons almost all fields in S3 API are optional
+/// including even those fields which are clearly stated to be required
+/// in S3 documentation.
+/// There are some unconvincing explanations for this at
+///  https://github.com/boto/botocore/issues/1069#issuecomment-259255047, but that's it!
+/// This implementation of the API in this library is a bit stricter than it is in S3 API
+/// specifciation, intentionally making some `optional` fields to be `required non-empty`.
+
+/// The response body content of CreateMultipartUpload action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html#API_CreateMultipartUpload_ResponseSyntax
+/// NOTE: `bucket`, `key`, `upload_id` are allowed to be empty string values by the S3 specification.
+struct InitiateMultipartUploadResult {
+    std::string bucket;
+    std::string key;
+    std::string upload_id;
+
+    static InitiateMultipartUploadResult Parse(utils::zstring_view http_s3_respose_body);
+};
+
+/// The response body content of CompleteMultipartUpload action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html#API_CompleteMultipartUpload_ResponseSyntax
+/// May also include ETag, Checksum*, etc.
+/// NOTE: `bucket`, `key`, `location` are allowed to be empty string values by the S3 specification.
+struct CompleteMultipartUploadResult {
+    std::string bucket;
+    std::string key;
+    std::string location;
+
+    static CompleteMultipartUploadResult Parse(utils::zstring_view http_s3_respose_body);
+};
+
+/// The response body content of CompleteMultipartUpload action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html#API_ListMultipartUploads_ResponseSyntax
+/// NOTE:
+/// Do not use the result of this listing when sending a complete multipart upload request.
+/// Instead, maintain your own list of the part numbers that you specified when uploading parts
+/// and the corresponding ETag values that Amazon S3 returns.
+/// (details in https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html)
+struct ListMultipartUploadsResult {
+    struct MultipartUpload {
+        std::string key;
+        std::string upload_id;
+        std::optional<std::chrono::system_clock::time_point> initiated_ts;
+    };
+
+    std::string bucket;
+    std::optional<std::string> key_marker;
+    std::optional<std::string> upload_id_marker;
+    std::optional<std::string> next_key_marker;
+    std::optional<std::string> next_upload_id_marker;
+    std::optional<std::string> delimiter;
+    bool is_truncated{false};
+    std::optional<unsigned> max_uploads;
+    std::vector<MultipartUpload> uploads;
+    std::vector<std::string> common_prefixes;
+
+    static ListMultipartUploadsResult Parse(utils::zstring_view http_s3_respose_body);
+};
+
+/// The response body content of ListParts action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html#API_ListParts_ResponseSyntax
+/// May also include Initiator, Owner, Checksum*, StorageClass and etc.
+struct ListPartsResult {
+    struct Part {
+        std::string etag;
+        unsigned part_number;
+        std::optional<std::chrono::system_clock::time_point> last_modified_ts;
+        std::optional<unsigned long> byte_size;
+    };
+
+    std::string bucket;
+    std::string key;
+    std::string upload_id;
+    std::optional<unsigned> max_parts;
+    std::optional<unsigned> part_number_marker;
+    std::optional<unsigned> next_part_number_marker;
+    bool is_truncated{false};
+    std::vector<Part> parts;
+
+    static ListPartsResult Parse(utils::zstring_view http_s3_respose_body);
+};
+
+/// The response struct containing response header values for UploadPart action request
+/// @see
+/// https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html#API_UploadPart_ResponseSyntax
+/// May also include checksum headers and etc.
+struct UploadPartResult {
+    std::string etag;
+};
+
+}  // namespace s3api::multipart_upload
+
+USERVER_NAMESPACE_END
diff --git a/libraries/s3api/src/s3api/clients/client.cpp b/libraries/s3api/src/s3api/clients/client.cpp
index 8c4d205e6218..2a2c3641540d 100644
--- a/libraries/s3api/src/s3api/clients/client.cpp
+++ b/libraries/s3api/src/s3api/clients/client.cpp
@@ -26,6 +26,8 @@ const std::string kMeta = "x-amz-meta-";
 const std::string kTagging = "X-Amz-Tagging";
 constexpr const std::size_t kMaxS3Keys = 1000;
 
+constexpr http::headers::PredefinedHeader kEtagHeader{"ETag"};
+
 void SaveMeta(clients::http::Headers& headers, const ClientImpl::Meta& meta) {
     for (const auto& [header, value] : meta) {
         headers[kMeta + header] = value;
@@ -365,7 +367,6 @@ std::string ClientImpl::RequestApi(
             headers_data->meta.emplace();
             ReadMeta(response->headers(), *headers_data->meta);
         }
-
         if (headers_request.headers) {
             headers_data->headers.emplace();
             for (const auto& header : *headers_request.headers) {
@@ -490,6 +491,90 @@ ClientImpl::CopyObject(std::string_view key_from, std::string_view key_to, const
     return CopyObject(key_from, bucket_, key_to, meta);
 }
 
+multipart_upload::InitiateMultipartUploadResult ClientImpl::CreateMultipartUpload(
+    const multipart_upload::CreateMultipartUploadRequest& request
+) const try {
+    auto api_request = api_methods::CreateInternalApiRequest(bucket_, request);
+    const auto api_response_body = RequestApi(api_request, "create_multipart_upload");
+    return multipart_upload::InitiateMultipartUploadResult::Parse(api_response_body);
+} catch (const ResponseParsingError& exc) {
+    throw MultipartUploadError(
+        fmt::format("failed to parse CreateMultipartUpload action response - {}; key: {}", exc.what(), request.key)
+    );
+}
+
+multipart_upload::UploadPartResult ClientImpl::UploadPart(const multipart_upload::UploadPartRequest& request) const
+    try {
+    auto api_request = api_methods::CreateInternalApiRequest(bucket_, request);
+
+    const HeaderDataRequest expected_headers({{std::string(kEtagHeader)}}, false);
+    HeadersDataResponse response_headers_data;
+
+    RequestApi(api_request, "upload_part", &response_headers_data, expected_headers);
+    if (!response_headers_data.headers) {
+        throw ResponseParsingError("missing ETag header in response");
+    }
+    const auto iter = response_headers_data.headers->find(kEtagHeader);
+    if (iter == response_headers_data.headers->end()) {
+        throw ResponseParsingError("missing ETag header in response");
+    }
+    if (iter->second.empty()) {
+        throw ResponseParsingError("got empty ETag header value in response");
+    }
+    return {std::move(iter->second)};
+
+} catch (const ResponseParsingError& exc) {
+    throw MultipartUploadError(fmt::format(
+        "failed to parse UploadPart action response - {}; upload_id '{}'; key '{}'",
+        exc.what(),
+        request.upload_id,
+        request.key
+    ));
+}
+
+multipart_upload::CompleteMultipartUploadResult ClientImpl::CompleteMultipartUpload(
+    const multipart_upload::CompleteMultipartUploadRequest& request
+) const try {
+    auto api_request = api_methods::CreateInternalApiRequest(bucket_, request);
+    const auto api_response_body = RequestApi(api_request, "complete_multipart_upload");
+    return multipart_upload::CompleteMultipartUploadResult::Parse(api_response_body);
+} catch (const ResponseParsingError& exc) {
+    throw MultipartUploadError(fmt::format(
+        "failed to parse CompleteMultipartUpload action response - {}; upload_id '{}'; key '{}'",
+        exc.what(),
+        request.upload_id,
+        request.key
+    ));
+}
+
+void ClientImpl::AbortMultipartUpload(const multipart_upload::AbortMultipartUploadRequest& request) const {
+    auto api_request = api_methods::CreateInternalApiRequest(bucket_, request);
+    RequestApi(api_request, "abort_multipart_upload");
+}
+
+multipart_upload::ListPartsResult ClientImpl::ListParts(const multipart_upload::ListPartsRequest& request) const try {
+    auto api_request = api_methods::CreateInternalApiRequest(bucket_, request);
+    const auto api_response_body = RequestApi(api_request, "list_parts");
+    return multipart_upload::ListPartsResult::Parse(api_response_body);
+} catch (const ResponseParsingError& exc) {
+    throw MultipartUploadError(fmt::format(
+        "failed to parse ListParts action response - {}; upload_id '{}'; key '{}'",
+        exc.what(),
+        request.upload_id,
+        request.key
+    ));
+}
+
+multipart_upload::ListMultipartUploadsResult ClientImpl::ListMultipartUploads(
+    const multipart_upload::ListMultipartUploadsRequest& request
+) const try {
+    auto api_request = api_methods::CreateInternalApiRequest(bucket_, request);
+    const auto api_response_body = RequestApi(api_request, "list_multipart_uploads");
+    return multipart_upload::ListMultipartUploadsResult::Parse(api_response_body);
+} catch (const ResponseParsingError& exc) {
+    throw MultipartUploadError(fmt::format("failed to parse ListMultipartUploads action response - {}", exc.what()));
+}
+
 ClientPtr GetS3Client(
     std::shared_ptr<S3Connection> s3conn,
     std::shared_ptr<authenticators::AccessKey> authenticator,
diff --git a/libraries/s3api/src/s3api/clients/client.hpp b/libraries/s3api/src/s3api/clients/client.hpp
index 90a167eb9155..cb6e3fbd4c62 100644
--- a/libraries/s3api/src/s3api/clients/client.hpp
+++ b/libraries/s3api/src/s3api/clients/client.hpp
@@ -123,6 +123,24 @@ class ClientImpl : public Client {
 
     std::vector<std::string> ListBucketDirectories(std::string_view path_prefix) const final;
 
+    multipart_upload::InitiateMultipartUploadResult CreateMultipartUpload(
+        const multipart_upload::CreateMultipartUploadRequest& request
+    ) const final;
+
+    multipart_upload::UploadPartResult UploadPart(const multipart_upload::UploadPartRequest& request) const final;
+
+    multipart_upload::CompleteMultipartUploadResult CompleteMultipartUpload(
+        const multipart_upload::CompleteMultipartUploadRequest& request
+    ) const final;
+
+    void AbortMultipartUpload(const multipart_upload::AbortMultipartUploadRequest& request) const final;
+
+    multipart_upload::ListPartsResult ListParts(const multipart_upload::ListPartsRequest& request) const final;
+
+    multipart_upload::ListMultipartUploadsResult ListMultipartUploads(
+        const multipart_upload::ListMultipartUploadsRequest& request
+    ) const final;
+
     void UpdateConfig(ConnectionCfg&& config) final;
 
     std::string_view GetBucketName() const final;
diff --git a/libraries/s3api/src/s3api/models/multipart_upload/responses.cpp b/libraries/s3api/src/s3api/models/multipart_upload/responses.cpp
new file mode 100644
index 000000000000..02ac66e6cb03
--- /dev/null
+++ b/libraries/s3api/src/s3api/models/multipart_upload/responses.cpp
@@ -0,0 +1,186 @@
+#include <userver/s3api/models/multipart_upload/responses.hpp>
+
+#include <fmt/format.h>
+#include <pugixml.hpp>
+
+#include <userver/s3api/models/errors.hpp>
+#include <userver/utils/datetime.hpp>
+#include <userver/utils/from_string.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace s3api::multipart_upload {
+namespace {
+
+pugi::xml_node GetRequiredChildNode(const pugi::xml_document& doc, const char* child_name) {
+    auto child = doc.child(child_name);
+    if (!child) throw ResponseParsingError(fmt::format("document is missing root child node '{}'", child_name));
+    return child;
+}
+
+std::optional<std::string_view>
+ExtractChildValue(const pugi::xml_node& node, const char* child_name, bool is_empty_allowed = true) {
+    const auto child = node.child(child_name);
+    auto result = (!child.empty() ? std::make_optional<std::string_view>(child.child_value()) : std::nullopt);
+    if (!is_empty_allowed && result && result->empty()) {
+        throw ResponseParsingError(fmt::format("node '{}.{}' is not expected to be empty", node.name(), child_name));
+    }
+    return result;
+}
+
+std::string_view ExtractRequiredChildValue(const pugi::xml_node& node, const char* child_name) {
+    const auto result = ExtractChildValue(node, child_name, false);
+    if (!result) {
+        throw ResponseParsingError(
+            fmt::format("node '{}' is missing the required child node '{}'", node.name(), child_name)
+        );
+    }
+    return *result;
+}
+
+bool ToBoolean(const std::optional<std::string_view>& maybe_str) {
+    if (maybe_str.value_or("false") != "true") return false;
+    return true;
+}
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, std::optional<T>>
+ExtractChildValueAsIntegral(const pugi::xml_node& node, const char* child_name) try {
+    const auto maybe_str = ExtractChildValue(node, child_name, false);
+    if (!maybe_str) return std::nullopt;
+
+    return USERVER_NAMESPACE::utils::FromString<T>(*maybe_str);
+
+} catch (const std::exception& exc) {
+    throw ResponseParsingError(
+        fmt::format("failed to parse node '{}.{}' value as integral type - {}", node.name(), child_name, exc.what())
+    );
+}
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, T>
+ExtractRequiredChildValueAsIntegral(const pugi::xml_node& node, const char* child_name) {
+    const auto maybe_value = ExtractChildValueAsIntegral<T>(node, child_name);
+    if (!maybe_value) {
+        throw ResponseParsingError(
+            fmt::format("node '{}' is missing the required child node '{}'", node.name(), child_name)
+        );
+    }
+    return *maybe_value;
+}
+
+constexpr auto ExtractRequiredChildValueAsUInt = ExtractRequiredChildValueAsIntegral<unsigned>;
+constexpr auto ExtractChildValueAsUInt = ExtractChildValueAsIntegral<unsigned>;
+constexpr auto ExtractChildValueAsULong = ExtractChildValueAsIntegral<unsigned long>;
+
+}  // namespace
+
+InitiateMultipartUploadResult InitiateMultipartUploadResult::Parse(utils::zstring_view http_s3_respose_body) {
+    InitiateMultipartUploadResult result;
+    pugi::xml_document xml;
+    const pugi::xml_parse_result parse_result =
+        xml.load_string(http_s3_respose_body.c_str(), pugi::parse_default | pugi::parse_escapes);
+    if (parse_result.status != pugi::status_ok) {
+        throw ResponseParsingError(parse_result.description());
+    }
+    const auto xml_root_item = GetRequiredChildNode(xml, "InitiateMultipartUploadResult");
+    result.bucket = ExtractRequiredChildValue(xml_root_item, "Bucket");
+    result.upload_id = ExtractRequiredChildValue(xml_root_item, "UploadId");
+    result.key = ExtractRequiredChildValue(xml_root_item, "Key");
+    return result;
+}
+
+CompleteMultipartUploadResult CompleteMultipartUploadResult::Parse(utils::zstring_view http_s3_respose_body) {
+    CompleteMultipartUploadResult result;
+    pugi::xml_document xml;
+    const pugi::xml_parse_result parse_result =
+        xml.load_string(http_s3_respose_body.c_str(), pugi::parse_default | pugi::parse_escapes);
+    if (parse_result.status != pugi::status_ok) {
+        throw ResponseParsingError(parse_result.description());
+    }
+    const auto xml_root_item = GetRequiredChildNode(xml, "CompleteMultipartUploadResult");
+    result.location = ExtractRequiredChildValue(xml_root_item, "Location");
+    result.bucket = ExtractRequiredChildValue(xml_root_item, "Bucket");
+    result.key = ExtractRequiredChildValue(xml_root_item, "Key");
+    return result;
+}
+
+ListMultipartUploadsResult ListMultipartUploadsResult::Parse(utils::zstring_view http_s3_respose_body) {
+    ListMultipartUploadsResult result;
+    pugi::xml_document xml;
+    const pugi::xml_parse_result parse_result =
+        xml.load_string(http_s3_respose_body.c_str(), pugi::parse_default | pugi::parse_escapes);
+    if (parse_result.status != pugi::status_ok) {
+        throw ResponseParsingError(parse_result.description());
+    }
+
+    const auto xml_root_item = GetRequiredChildNode(xml, "ListMultipartUploadsResult");
+    result.bucket = ExtractRequiredChildValue(xml_root_item, "Bucket");
+    result.key_marker = ExtractChildValue(xml_root_item, "KeyMarker");
+    result.upload_id_marker = ExtractChildValue(xml_root_item, "UploadIdMarker");
+    result.next_key_marker = ExtractChildValue(xml_root_item, "NextKeyMarker");
+    result.next_upload_id_marker = ExtractChildValue(xml_root_item, "NextUploadIdMarker");
+    result.delimiter = ExtractChildValue(xml_root_item, "Delimiter");
+    result.is_truncated = ToBoolean(ExtractChildValue(xml_root_item, "IsTruncated"));
+    result.max_uploads = ExtractChildValueAsUInt(xml_root_item, "MaxUploads");
+
+    for (auto node = xml_root_item.child("Upload"); node; node = node.next_sibling("Upload")) {
+        ListMultipartUploadsResult::MultipartUpload multipart_upload;
+        multipart_upload.key = ExtractRequiredChildValue(node, "Key");
+        multipart_upload.upload_id = ExtractRequiredChildValue(node, "UploadId");
+        if (const auto maybe_initiated_str = ExtractChildValue(node, "Initiated")) {
+            // See S3 client aws-sdk-cpp implementaton references:
+            // https://github.com/aws/aws-sdk-cpp/blob/6762e8220ae37a35c7a8f762f9b97c5d2eda7455/generated/src/aws-cpp-sdk-s3/source/model/MultipartUpload.cpp#L49
+            multipart_upload.initiated_ts =
+                USERVER_NAMESPACE::utils::datetime::GuessStringtime(std::string{*maybe_initiated_str}, "UTC");
+        }
+        result.uploads.push_back(std::move(multipart_upload));
+    }
+
+    for (auto node = xml_root_item.child("CommonPrefixes"); node; node = node.next_sibling("CommonPrefixes")) {
+        result.common_prefixes.emplace_back(ExtractRequiredChildValue(node, "Prefix"));
+    }
+
+    return result;
+}
+
+ListPartsResult ListPartsResult::Parse(utils::zstring_view http_s3_respose_body) {
+    ListPartsResult result;
+    pugi::xml_document xml;
+    const pugi::xml_parse_result parse_result =
+        xml.load_string(http_s3_respose_body.c_str(), pugi::parse_default | pugi::parse_escapes);
+    if (parse_result.status != pugi::status_ok) {
+        throw ResponseParsingError(parse_result.description());
+    }
+
+    const auto xml_root_item = GetRequiredChildNode(xml, "ListPartsResult");
+    result.bucket = ExtractRequiredChildValue(xml_root_item, "Bucket");
+    result.upload_id = ExtractRequiredChildValue(xml_root_item, "UploadId");
+    result.max_parts = ExtractChildValueAsUInt(xml_root_item, "MaxParts");
+    result.part_number_marker = ExtractChildValueAsUInt(xml_root_item, "PartNumberMarker");
+    result.next_part_number_marker = ExtractChildValueAsUInt(xml_root_item, "NextPartNumberMarker");
+    result.key = ExtractRequiredChildValue(xml_root_item, "Key");
+    result.is_truncated = ToBoolean(ExtractChildValue(xml_root_item, "IsTruncated"));
+
+    for (auto part_node = xml_root_item.child("Part"); part_node; part_node = part_node.next_sibling("Part")) {
+        ListPartsResult::Part part;
+        part.etag = ExtractRequiredChildValue(part_node, "ETag");
+        part.part_number = ExtractRequiredChildValueAsUInt(part_node, "PartNumber");
+        part.byte_size = ExtractChildValueAsULong(part_node, "Size");
+
+        if (const auto maybe_last_modified_ts_str = ExtractChildValue(part_node, "LastModified")) {
+            // See S3 client aws-sdk-cpp implementaton references:
+            // https://github.com/aws/aws-sdk-cpp/blob/6762e8220ae37a35c7a8f762f9b97c5d2eda7455/generated/src/aws-cpp-sdk-s3/source/model/MultipartUpload.cpp#L49
+            part.last_modified_ts =
+                USERVER_NAMESPACE::utils::datetime::GuessStringtime(std::string{*maybe_last_modified_ts_str}, "UTC");
+        }
+
+        result.parts.push_back(std::move(part));
+    }
+
+    return result;
+}
+
+}  // namespace s3api::multipart_upload
+
+USERVER_NAMESPACE_END
diff --git a/libraries/s3api/src/s3api/models/multipart_upload/responses_test.cpp b/libraries/s3api/src/s3api/models/multipart_upload/responses_test.cpp
new file mode 100644
index 000000000000..0d0795650e00
--- /dev/null
+++ b/libraries/s3api/src/s3api/models/multipart_upload/responses_test.cpp
@@ -0,0 +1,240 @@
+#include <userver/s3api/models/multipart_upload/responses.hpp>
+
+#include <userver/utest/utest.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace s3api::multipart_upload {
+
+TEST(S3ApiInitiateMultipartUploadResult, ParseResponseBody) {
+    const auto result = InitiateMultipartUploadResult::Parse(
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        "<InitiateMultipartUploadResult>"
+        "<Bucket>some-bucket</Bucket><Key>some/key</Key><UploadId>123456ABCDEF</UploadId>"
+        "</InitiateMultipartUploadResult>"
+    );
+    EXPECT_EQ(result.bucket, "some-bucket");
+    EXPECT_EQ(result.key, "some/key");
+    EXPECT_EQ(result.upload_id, "123456ABCDEF");
+}
+
+TEST(S3ApiCompleteMultipartUploadeResult, ParseResponseBody) {
+    const auto result = CompleteMultipartUploadResult::Parse(
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        "<CompleteMultipartUploadResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+        "<Location>https://some-bucket.some-s3.net/some/key</Location>"
+        "<Bucket>some-bucket</Bucket><Key>some/key</Key>"
+        "<UploadId>123456ABCDEF</UploadId>"
+        "<ETag>\"123456\"</ETag>"
+        "</CompleteMultipartUploadResult>"
+    );
+    EXPECT_EQ(result.bucket, "some-bucket");
+    EXPECT_EQ(result.key, "some/key");
+    EXPECT_EQ(result.location, "https://some-bucket.some-s3.net/some/key");
+}
+
+TEST(S3ApiListMultipartUploadsResult, ParseResponseBody) {
+    using std::chrono::milliseconds;
+    using TimePoint = std::chrono::system_clock::time_point;
+
+    // no multipart uploads
+    {
+        const auto result = ListMultipartUploadsResult::Parse(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<ListMultipartUploadsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+            "<Bucket>some-bucket</Bucket>"
+            "<KeyMarker></KeyMarker><UploadIdMarker/><NextKeyMarker/><NextUploadIdMarker/>"
+            "<IsTruncated>false</IsTruncated>"
+            "<MaxUploads>1000</MaxUploads>"
+            "</ListMultipartUploadsResult>"
+        );
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.key_marker, std::string());
+        EXPECT_EQ(result.upload_id_marker, std::string());
+        EXPECT_EQ(result.next_key_marker, std::string());
+        EXPECT_EQ(result.next_upload_id_marker, std::string());
+        EXPECT_FALSE(result.is_truncated);
+        EXPECT_EQ(result.max_uploads, 1000);
+        EXPECT_TRUE(result.uploads.empty());
+        EXPECT_TRUE(result.common_prefixes.empty());
+    }
+    // 2 active multipart uploads
+    {
+        const auto result = ListMultipartUploadsResult::Parse(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<ListMultipartUploadsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+            "<Bucket>some-bucket</Bucket>"
+            "<KeyMarker/><UploadIdMarker/><NextKeyMarker/><NextUploadIdMarker/>"
+            "<IsTruncated>false</IsTruncated>"
+            "<MaxUploads>10</MaxUploads>"
+            "<Upload>"
+            "<Initiated>2025-08-29T09:29:46.506Z</Initiated><Key>a1/b1/c1</Key>"
+            "<StorageClass>STANDARD</StorageClass><UploadId>00063D7DA9A30F29</UploadId>"
+            "</Upload><Upload>"
+            "<Initiated>2025-08-29T09:29:46Z</Initiated><Key>a1/b1/c2</Key>"
+            "<StorageClass>STANDARD</StorageClass><UploadId>00063D7DA9A77808</UploadId>"
+            "</Upload></ListMultipartUploadsResult>"
+        );
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.key_marker, std::string());
+        EXPECT_EQ(result.upload_id_marker, std::string());
+        EXPECT_EQ(result.next_key_marker, std::string());
+        EXPECT_EQ(result.next_upload_id_marker, std::string());
+        EXPECT_TRUE(!result.delimiter);
+        EXPECT_FALSE(result.is_truncated);
+        EXPECT_EQ(result.max_uploads, 10);
+        ASSERT_EQ(result.uploads.size(), 2);
+        EXPECT_EQ(result.uploads[0].key, "a1/b1/c1");
+        EXPECT_EQ(result.uploads[0].upload_id, "00063D7DA9A30F29");
+        EXPECT_EQ(result.uploads[0].initiated_ts, TimePoint(milliseconds(1756459786506)));
+        EXPECT_EQ(result.uploads[1].key, "a1/b1/c2");
+        EXPECT_EQ(result.uploads[1].upload_id, "00063D7DA9A77808");
+        EXPECT_EQ(result.uploads[1].initiated_ts, TimePoint(milliseconds(1756459786000)));
+        EXPECT_TRUE(result.common_prefixes.empty());
+    }
+    // with one delimiter, with max uploads 2
+    {
+        const auto result = ListMultipartUploadsResult::Parse(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<ListMultipartUploadsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+            "<Bucket>some-bucket</Bucket><KeyMarker>a_1</KeyMarker>"
+            "<UploadIdMarker>00063D7E07565264</UploadIdMarker>"
+            "<Delimiter>/</Delimiter><IsTruncated>true</IsTruncated>"
+            "<NextKeyMarker>a_4</NextKeyMarker>"
+            "<NextUploadIdMarker>00063D7E075A93B9</NextUploadIdMarker>"
+            "<MaxUploads>2</MaxUploads>"
+            "<Upload>"
+            "<Initiated>2025-08-29T09:55:58.535Z</Initiated><Key>a_3</Key>"
+            "<StorageClass>STANDARD</StorageClass><UploadId>00063D7E07565265</UploadId>"
+            "</Upload><Upload><Key>a_4</Key>"
+            "<StorageClass>STANDARD</StorageClass><UploadId>00063D7E075A93B9</UploadId>"
+            "</Upload>"
+            "<CommonPrefixes><Prefix>a_1/</Prefix></CommonPrefixes>"
+            "<CommonPrefixes><Prefix>a_2/</Prefix></CommonPrefixes>"
+            "</ListMultipartUploadsResult>"
+        );
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.key_marker, "a_1");
+        EXPECT_EQ(result.upload_id_marker, "00063D7E07565264");
+        EXPECT_EQ(result.next_key_marker, "a_4");
+        EXPECT_EQ(result.next_upload_id_marker, "00063D7E075A93B9");
+        EXPECT_EQ(result.delimiter, "/");
+        EXPECT_TRUE(result.is_truncated);
+        EXPECT_EQ(result.max_uploads, 2);
+        ASSERT_EQ(result.uploads.size(), 2);
+        EXPECT_EQ(result.uploads[0].key, "a_3");
+        EXPECT_EQ(result.uploads[0].upload_id, "00063D7E07565265");
+        EXPECT_EQ(result.uploads[0].initiated_ts, TimePoint(milliseconds(1756461358535)));
+        EXPECT_EQ(result.uploads[1].key, "a_4");
+        EXPECT_EQ(result.uploads[1].upload_id, "00063D7E075A93B9");
+        ASSERT_FALSE(result.uploads[1].initiated_ts.has_value());
+        ASSERT_EQ(result.common_prefixes.size(), 2);
+        EXPECT_EQ(result.common_prefixes[0], "a_1/");
+        EXPECT_EQ(result.common_prefixes[1], "a_2/");
+    }
+}
+
+TEST(S3ApiListPartsResult, ParseResponseBody) {
+    using std::chrono::milliseconds;
+    using TimePoint = std::chrono::system_clock::time_point;
+
+    // no parts in multipart upload
+    {
+        const auto result = ListPartsResult::Parse(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<ListPartsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+            "<Bucket>some-bucket</Bucket>"
+            "<Key>a_1/b_1/c_1</Key><UploadId>00063DD078D0EFFC</UploadId>"
+            "<StorageClass>STANDARD</StorageClass><PartNumberMarker>0</PartNumberMarker>"
+            "<MaxParts>1000</MaxParts>"
+            "<IsTruncated>false</IsTruncated>"
+            "</ListPartsResult>"
+        );
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.key, "a_1/b_1/c_1");
+        EXPECT_EQ(result.upload_id, "00063DD078D0EFFC");
+        EXPECT_EQ(result.max_parts, 1000);
+        EXPECT_EQ(result.part_number_marker, 0);
+        EXPECT_FALSE(result.next_part_number_marker.has_value());
+        EXPECT_FALSE(result.is_truncated);
+        EXPECT_TRUE(result.parts.empty());
+    }
+    // 3 parts; not truncated
+    {
+        const auto result = ListPartsResult::Parse(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<ListPartsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+            "<Bucket>some-bucket</Bucket>"
+            "<Key>a_1/b_1/c_1</Key><UploadId>00063DD078D0EFFC</UploadId>"
+            "<StorageClass>STANDARD</StorageClass><PartNumberMarker>0</PartNumberMarker>"
+            "<MaxParts>10</MaxParts>"
+            "<IsTruncated>false</IsTruncated>"
+            "<Part><PartNumber>1</PartNumber>"
+            "<LastModified>2025-09-02T12:15:47.363Z</LastModified>"
+            "<ETag>&#34;975cd7fe7fd02f5556d0410161f9243e&#34;</ETag>"
+            "<Size>104857600</Size></Part>"
+            "<Part><PartNumber>2</PartNumber>"
+            "<LastModified>2025-09-02T12:15:50.482Z</LastModified>"
+            "<ETag>&#34;865db48e2a10f7fc8e2d06a5cc390f17&#34;</ETag>"
+            "<Size>104857600</Size></Part>"
+            "<Part><PartNumber>3</PartNumber>"
+            "<LastModified>2025-09-02T12:15:53.717Z</LastModified>"
+            "<ETag>&#34;44f2b11f5bf7f61283eab82bbe0998ca&#34;</ETag>"
+            "<Size>104857600</Size></Part>"
+            "</ListPartsResult>"
+        );
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.key, "a_1/b_1/c_1");
+        EXPECT_EQ(result.upload_id, "00063DD078D0EFFC");
+        EXPECT_EQ(result.max_parts, 10);
+        EXPECT_EQ(result.part_number_marker, 0);
+        EXPECT_FALSE(result.next_part_number_marker.has_value());
+        EXPECT_FALSE(result.is_truncated);
+        ASSERT_EQ(result.parts.size(), 3u);
+        EXPECT_EQ(result.parts[0].part_number, 1);
+        EXPECT_EQ(result.parts[0].byte_size, 104857600);
+        EXPECT_EQ(result.parts[0].last_modified_ts, TimePoint(milliseconds(1756815347363)));
+        EXPECT_EQ(result.parts[0].etag, "\"975cd7fe7fd02f5556d0410161f9243e\"");
+        EXPECT_EQ(result.parts[1].part_number, 2);
+        EXPECT_EQ(result.parts[1].byte_size, 104857600);
+        EXPECT_EQ(result.parts[1].last_modified_ts, TimePoint(milliseconds(1756815350482)));
+        EXPECT_EQ(result.parts[1].etag, "\"865db48e2a10f7fc8e2d06a5cc390f17\"");
+        EXPECT_EQ(result.parts[2].part_number, 3);
+        EXPECT_EQ(result.parts[2].byte_size, 104857600);
+        EXPECT_EQ(result.parts[2].last_modified_ts, TimePoint(milliseconds(1756815353717)));
+        EXPECT_EQ(result.parts[2].etag, "\"44f2b11f5bf7f61283eab82bbe0998ca\"");
+    }
+    // 1 part and truncated
+    {
+        const auto result = ListPartsResult::Parse(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            "<ListPartsResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+            "<Bucket>some-bucket</Bucket>"
+            "<Key>a_1/b_1/c_1</Key><UploadId>00063DD078D0EFFC</UploadId>"
+            "<StorageClass>STANDARD</StorageClass><PartNumberMarker>1</PartNumberMarker>"
+            "<NextPartNumberMarker>2</NextPartNumberMarker><MaxParts>1</MaxParts>"
+            "<IsTruncated>true</IsTruncated>"
+            "<Part><PartNumber>2</PartNumber>"
+            "<LastModified>2025-09-02T12:15:50.482Z</LastModified>"
+            "<ETag>&#34;865db48e2a10f7fc8e2d06a5cc390f17&#34;</ETag>"
+            "<Size>104857600</Size></Part>"
+            "</ListPartsResult>"
+        );
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.key, "a_1/b_1/c_1");
+        EXPECT_EQ(result.upload_id, "00063DD078D0EFFC");
+        EXPECT_EQ(result.max_parts, 1);
+        EXPECT_EQ(result.part_number_marker, 1);
+        EXPECT_EQ(result.next_part_number_marker, 2);
+        EXPECT_TRUE(result.is_truncated);
+        ASSERT_EQ(result.parts.size(), 1u);
+        EXPECT_EQ(result.parts[0].part_number, 2);
+        EXPECT_EQ(result.parts[0].byte_size, 104857600);
+        EXPECT_EQ(result.parts[0].last_modified_ts, TimePoint(milliseconds(1756815350482)));
+        EXPECT_EQ(result.parts[0].etag, "\"865db48e2a10f7fc8e2d06a5cc390f17\"");
+    }
+}
+
+}  // namespace s3api::multipart_upload
+
+USERVER_NAMESPACE_END
diff --git a/libraries/s3api/src/s3api/models/s3api_connection_type.cpp b/libraries/s3api/src/s3api/models/s3api_connection_type.cpp
index fe917801f7db..b6013ce47783 100644
--- a/libraries/s3api/src/s3api/models/s3api_connection_type.cpp
+++ b/libraries/s3api/src/s3api/models/s3api_connection_type.cpp
@@ -16,6 +16,8 @@ S3ConnectionType Parse(const formats::json::Value& elem, formats::parse::To<S3Co
         return S3ConnectionType::kHttps;
     }
     UINVARIANT(false, "invalid value of connection_type");
+    // Never reaches
+    return S3ConnectionType::kHttp;
 }
 
 std::string_view ToStringView(S3ConnectionType connection_type) {
diff --git a/libraries/s3api/src/s3api/s3api_methods.cpp b/libraries/s3api/src/s3api/s3api_methods.cpp
index 859cfe53e8a9..288c473278a0 100644
--- a/libraries/s3api/src/s3api/s3api_methods.cpp
+++ b/libraries/s3api/src/s3api/s3api_methods.cpp
@@ -1,6 +1,7 @@
 #include "s3api_methods.hpp"
 
 #include <fmt/format.h>
+#include <pugixml.hpp>
 
 #include <unordered_map>
 
@@ -10,6 +11,45 @@
 USERVER_NAMESPACE_BEGIN
 
 namespace s3api::api_methods {
+namespace {
+
+class StringWriter : public pugi::xml_writer {
+public:
+    explicit StringWriter(std::string& out) : out_(out) {}
+
+    void write(const void* data, size_t size) override { out_.append(static_cast<const char*>(data), size); }
+
+private:
+    std::string& out_;
+};
+
+namespace query_args {
+constexpr std::string_view kDelimeter = "delimiter";
+constexpr std::string_view kEncodingType = "encoding-type";
+constexpr std::string_view kMarker = "marker";
+constexpr std::string_view kMaxKeys = "max-keys";
+constexpr std::string_view kMaxParts = "max-parts";
+constexpr std::string_view kMaxUploads = "max-uploads";
+constexpr std::string_view kPartNumber = "partNumber";
+constexpr std::string_view kPartNumberMarker = "part-number-marker";
+constexpr std::string_view kPrefix = "prefix";
+constexpr std::string_view kUploadId = "uploadId";
+constexpr std::string_view kUploadIdMarker = "upload-id-marker";
+}  // namespace query_args
+
+namespace content_types {
+constexpr std::string_view kDefault = "application/octet-stream";
+constexpr std::string_view kApplicationXml = "application/xml; charset=UTF-8";
+}  // namespace content_types
+
+constexpr std::string_view kEncodingTypeValueUrl = "url";
+
+constexpr std::string_view kS3AwsXmlNamespace = "http://s3.amazonaws.com/doc/2006-03-01/";
+
+// see @ref https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html
+const unsigned kMaxUploadsListLimit = 1000u;
+
+}  // namespace
 
 Request PutObject(
     std::string_view bucket,
@@ -86,15 +126,15 @@ Request ListBucketContents(
     std::unordered_map<std::string, std::string> params;
     params.emplace("prefix", path);
     if (max_keys > 0) {
-        params.emplace("max-keys", std::to_string(max_keys));
+        params.emplace(query_args::kMaxKeys, std::to_string(max_keys));
     }
 
     if (!marker.empty()) {
-        params.emplace("marker", marker);
+        params.emplace(query_args::kMarker, marker);
     }
 
     if (!delimiter.empty()) {
-        params.emplace("delimiter", delimiter);
+        params.emplace(query_args::kDelimeter, delimiter);
     }
 
     req.req = "?" + USERVER_NAMESPACE::http::MakeQuery(params);
@@ -118,6 +158,152 @@ Request CopyObject(
     return req;
 }
 
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::CreateMultipartUploadRequest& request) {
+    Request result;
+    result.method = clients::http::HttpMethod::kPost;
+    result.bucket = bucket;
+    result.req = fmt::format("{}?uploads", request.key);
+
+    if (request.content_type) {
+        result.headers[http::headers::kContentType] = *request.content_type;
+    }
+
+    if (request.content_disposition) {
+        result.headers[http::headers::kContentDisposition] = *request.content_disposition;
+    }
+
+    if (request.content_encoding) {
+        result.headers[http::headers::kContentEncoding] = *request.content_encoding;
+    }
+
+    if (request.content_language) {
+        result.headers[http::headers::kContentLanguage] = *request.content_language;
+    }
+
+    return result;
+}
+
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::AbortMultipartUploadRequest& request) {
+    Request result;
+    result.method = clients::http::HttpMethod::kDelete;
+    result.bucket = bucket;
+    result.req = fmt::format("{}?{}", request.key, http::MakeQuery({{query_args::kUploadId, request.upload_id}}));
+    return result;
+}
+
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::CompleteMultipartUploadRequest& request) {
+    Request result;
+    result.method = clients::http::HttpMethod::kPost;
+    result.bucket = bucket;
+    result.req = fmt::format("{}?{}", request.key, http::MakeQuery({{query_args::kUploadId, request.upload_id}}));
+
+    pugi::xml_document doc;
+    auto multipart_upload_node = doc.append_child("CompleteMultipartUpload");
+    multipart_upload_node.append_attribute("xmlns").set_value(kS3AwsXmlNamespace.data());
+    for (const auto& part : request.completed_parts) {
+        auto part_node = multipart_upload_node.append_child("Part");
+        part_node.append_child("PartNumber")
+            .append_child(pugi::node_pcdata)
+            .set_value(std::to_string(part.part_number).c_str());
+        part_node.append_child("ETag").append_child(pugi::node_pcdata).set_value(part.etag.c_str());
+    }
+    StringWriter writer{result.body};
+    doc.save(writer, "", pugi::format_raw);
+    result.headers = clients::http::Headers{
+        {http::headers::kContentType, content_types::kApplicationXml},
+        {http::headers::kContentLength, std::to_string(result.body.size())}};
+
+    return result;
+}
+
+Request CreateInternalApiRequest(const std::string& bucket, const multipart_upload::UploadPartRequest& request) {
+    Request result;
+    result.method = clients::http::HttpMethod::kPut;
+    // `Content-Type`-header is absent in S3 API, however PUT-request implementaion in CURL for URIs with query
+    // may implicitly insert `application/x-www-form-urlencoded` which must be taken into account when making
+    // canonical request for signature. But it happens after we sign the request without knowlege of this header.
+    // We explicitly override this Content-Type value here to make this request be signed correctly.
+    result.headers = clients::http::Headers{
+        {http::headers::kContentLength, std::to_string(request.data.size())},
+        {http::headers::kContentType, std::string{content_types::kDefault}}};
+
+    result.bucket = bucket;
+    result.req = fmt::format(
+        "{}?{}",
+        request.key,
+        http::MakeQuery(
+            {{query_args::kUploadId, request.upload_id}, {query_args::kPartNumber, std::to_string(request.part_number)}}
+        )
+    );
+    result.body = std::move(request.data);
+    return result;
+}
+
+Request CreateInternalApiRequest(const std::string& bucket, const multipart_upload::ListPartsRequest& request) {
+    Request result;
+    result.method = clients::http::HttpMethod::kGet;
+    result.bucket = bucket;
+    result.req = request.key;
+
+    http::Args params{{std::string{query_args::kUploadId}, request.upload_id}};
+
+    if (request.max_parts > 0 && request.max_parts < kMaxUploadsListLimit) {
+        params.emplace(query_args::kMaxParts, std::to_string(request.max_parts));
+    }
+
+    if (auto part_number_marker = request.part_number_marker.value_or(0u)) {
+        params.emplace(query_args::kPartNumberMarker, std::to_string(part_number_marker));
+    }
+
+    result.req = fmt::format("{}?{}", request.key, http::MakeQuery(params));
+
+    return result;
+}
+
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::ListMultipartUploadsRequest& request) {
+    using EncodingType = multipart_upload::ListMultipartUploadsRequest::EncodingType;
+
+    Request result;
+    result.method = clients::http::HttpMethod::kGet;
+    result.bucket = bucket;
+
+    http::Args params;
+    if (request.delimiter) {
+        params.emplace(query_args::kDelimeter, *request.delimiter);
+    }
+
+    if (request.prefix) {
+        params.emplace(query_args::kPrefix, *request.prefix);
+    }
+
+    if (request.max_uploads > 0 && request.max_uploads < kMaxUploadsListLimit) {
+        params.emplace(query_args::kMaxUploads, std::to_string(request.max_uploads));
+    }
+
+    if (request.key_marker) {
+        params.emplace(query_args::kMarker, *request.key_marker);
+    }
+
+    if (request.upload_id_marker) {
+        params.emplace(query_args::kUploadIdMarker, *request.upload_id_marker);
+    }
+
+    if (request.encoding_type == EncodingType::kUrl) {
+        params.emplace(query_args::kEncodingType, kEncodingTypeValueUrl);
+    }
+
+    result.req = "?uploads";
+    if (!params.empty()) {
+        result.req += "&" + http::MakeQuery(params);
+    }
+
+    return result;
+}
+
 }  // namespace s3api::api_methods
 
 USERVER_NAMESPACE_END
diff --git a/libraries/s3api/src/s3api/s3api_methods.hpp b/libraries/s3api/src/s3api/s3api_methods.hpp
index 69340192b579..6c07e5ff584e 100644
--- a/libraries/s3api/src/s3api/s3api_methods.hpp
+++ b/libraries/s3api/src/s3api/s3api_methods.hpp
@@ -4,7 +4,7 @@
 #include <string>
 
 #include <userver/http/predefined_header.hpp>
-
+#include <userver/s3api/models/multipart_upload/requests.hpp>
 #include <userver/s3api/models/request.hpp>
 
 USERVER_NAMESPACE_BEGIN
@@ -52,6 +52,22 @@ Request CopyObject(
     std::string_view content_type
 );
 
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::CreateMultipartUploadRequest& request);
+
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::AbortMultipartUploadRequest& request);
+
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::CompleteMultipartUploadRequest& request);
+
+Request CreateInternalApiRequest(const std::string& bucket, const multipart_upload::UploadPartRequest& request);
+
+Request CreateInternalApiRequest(const std::string& bucket, const multipart_upload::ListPartsRequest& request);
+
+Request
+CreateInternalApiRequest(const std::string& bucket, const multipart_upload::ListMultipartUploadsRequest& request);
+
 }  // namespace s3api::api_methods
 
 USERVER_NAMESPACE_END
diff --git a/libraries/s3api/src/s3api/s3api_methods_test.cpp b/libraries/s3api/src/s3api/s3api_methods_test.cpp
index add5882e70b6..df913ec2f030 100644
--- a/libraries/s3api/src/s3api/s3api_methods_test.cpp
+++ b/libraries/s3api/src/s3api/s3api_methods_test.cpp
@@ -1,10 +1,14 @@
 #include "s3api_methods.hpp"
 
+#include <unordered_set>
+
 #include <fmt/format.h>
 
 #include <userver/http/common_headers.hpp>
+#include <userver/http/url.hpp>
 #include <userver/utest/utest.hpp>
 #include <userver/utils/algo.hpp>
+#include <userver/utils/text.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -40,6 +44,196 @@ TEST(S3ApiMethods, GetObjectWithRange) {
     );
 }
 
+TEST(S3ApiMethods, CreateMultipartUpload) {
+    const std::string content_type = "application/octet-stream";
+    const std::string content_disposition = "attachment; filename=some_file.bin";
+    {
+        multipart_upload::CreateMultipartUploadRequest request;
+        request.key = "some-key";
+        request.content_type = "application/binary";
+        request.content_disposition = "attachment; filename=\"some_file.bin\"";
+        request.content_encoding = "gzip";
+        request.content_language = "ru-RU";
+
+        const auto result = CreateInternalApiRequest("bucket", request);
+
+        EXPECT_EQ(result.bucket, "bucket");
+        EXPECT_EQ(result.req, "some-key?uploads");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kPost);
+        EXPECT_TRUE(result.body.empty());
+
+        const auto expected_headers = clients::http::Headers{
+            {USERVER_NAMESPACE::http::headers::kContentType, "application/binary"},
+            {USERVER_NAMESPACE::http::headers::kContentDisposition, "attachment; filename=\"some_file.bin\""},
+            {USERVER_NAMESPACE::http::headers::kContentLanguage, "ru-RU"},
+            {USERVER_NAMESPACE::http::headers::kContentEncoding, "gzip"}};
+        EXPECT_EQ(expected_headers, result.headers);
+    }
+    {
+        multipart_upload::CreateMultipartUploadRequest request;
+        request.key = "some-key";
+
+        const auto result = CreateInternalApiRequest("bucket", request);
+
+        EXPECT_EQ(result.bucket, "bucket");
+        EXPECT_EQ(result.req, "some-key?uploads");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kPost);
+        EXPECT_TRUE(result.body.empty());
+        EXPECT_EQ(clients::http::Headers{}, result.headers);
+    }
+}
+
+TEST(S3ApiMethods, UploadPart) {
+    multipart_upload::UploadPartRequest request;
+    request.key = "some/key.bin";
+    request.upload_id = "some_id";
+    request.part_number = 2;
+    request.data = "some data";
+
+    const auto result = CreateInternalApiRequest("some-bucket", request);
+    EXPECT_EQ(result.bucket, "some-bucket");
+    EXPECT_EQ(result.method, clients::http::HttpMethod::kPut);
+    const auto requested_query_params = utils::text::SplitIntoStringViewVector(http::ExtractQueryView(result.req), "&");
+    EXPECT_EQ(
+        std::unordered_set<std::string_view>({"partNumber=2", "uploadId=some_id"}),
+        std::unordered_set<std::string_view>(requested_query_params.begin(), requested_query_params.end())
+    );
+    EXPECT_EQ(result.req.substr(0, result.req.find('?')), "some/key.bin");
+
+    const auto expected_headers = clients::http::Headers{
+        {USERVER_NAMESPACE::http::headers::kContentType, "application/octet-stream"},
+        {USERVER_NAMESPACE::http::headers::kContentLength, std::to_string(result.body.size())},
+    };
+    EXPECT_EQ(expected_headers, result.headers);
+    EXPECT_EQ(result.body, request.data);
+}
+
+TEST(S3ApiMethods, AbortMultipartUpload) {
+    multipart_upload::AbortMultipartUploadRequest request;
+    request.key = "some/key.bin";
+    request.upload_id = "some_id";
+
+    const auto result = CreateInternalApiRequest("some-bucket", request);
+    EXPECT_EQ(result.bucket, "some-bucket");
+    EXPECT_EQ(result.method, clients::http::HttpMethod::kDelete);
+    EXPECT_EQ(result.req, "some/key.bin?uploadId=some_id");
+}
+
+TEST(S3ApiMethods, CompleteMultipartUpload) {
+    multipart_upload::CompleteMultipartUploadRequest request;
+    request.key = "some-key";
+    request.upload_id = "some_id";
+    request.completed_parts = {{1, "\"etag1\""}, {2, "\"etag2\""}, {3, "\"etag3\""}};
+
+    const auto result = CreateInternalApiRequest("some-bucket", request);
+
+    EXPECT_EQ(result.bucket, "some-bucket");
+    EXPECT_EQ(result.method, clients::http::HttpMethod::kPost);
+    EXPECT_EQ(result.req, "some-key?uploadId=some_id");
+
+    const auto expected_headers = clients::http::Headers{
+        {USERVER_NAMESPACE::http::headers::kContentType, "application/xml; charset=UTF-8"},
+        {USERVER_NAMESPACE::http::headers::kContentLength, std::to_string(result.body.size())},
+    };
+    EXPECT_EQ(expected_headers, result.headers);
+    EXPECT_EQ(
+        result.body,
+        "<?xml version=\"1.0\"?><CompleteMultipartUpload xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">"
+        "<Part><PartNumber>1</PartNumber><ETag>\"etag1\"</ETag></Part>"
+        "<Part><PartNumber>2</PartNumber><ETag>\"etag2\"</ETag></Part>"
+        "<Part><PartNumber>3</PartNumber><ETag>\"etag3\"</ETag></Part>"
+        "</CompleteMultipartUpload>"
+    );
+}
+
+TEST(S3ApiMethods, ListMultipartUploads) {
+    {
+        multipart_upload::ListMultipartUploadsRequest request;
+        const auto result = CreateInternalApiRequest("some-bucket", request);
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kGet);
+        EXPECT_EQ(result.req, "?uploads");
+        EXPECT_EQ(result.headers, clients::http::Headers{});
+        EXPECT_TRUE(result.body.empty());
+    }
+    {
+        multipart_upload::ListMultipartUploadsRequest request;
+        request.prefix = "some/prefix/to";
+        const auto result = CreateInternalApiRequest("some-bucket", request);
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kGet);
+        EXPECT_EQ(result.headers, clients::http::Headers{});
+        EXPECT_TRUE(result.body.empty());
+
+        const auto requested_query_params = utils::text::SplitIntoStringViewVector(result.req, "&");
+        EXPECT_EQ(
+            std::unordered_set<std::string_view>({"?uploads", "prefix=some%2Fprefix%2Fto"}),
+            std::unordered_set<std::string_view>(requested_query_params.begin(), requested_query_params.end())
+        );
+    }
+    {
+        multipart_upload::ListMultipartUploadsRequest request;
+        request.prefix = "some/prefix/to";
+        request.max_uploads = 100;
+        request.delimiter = "/";
+        request.key_marker = "abc";
+        request.upload_id_marker = "def";
+
+        const auto result = CreateInternalApiRequest("some-bucket", request);
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kGet);
+        EXPECT_EQ(result.headers, clients::http::Headers{});
+        EXPECT_TRUE(result.body.empty());
+
+        const auto requested_query_params = utils::text::SplitIntoStringViewVector(result.req, "&");
+        EXPECT_EQ(
+            std::unordered_set<std::string_view>(
+                {"?uploads",
+                 "prefix=some%2Fprefix%2Fto",
+                 "max-uploads=100",
+                 "marker=abc",
+                 "delimiter=%2F",
+                 "upload-id-marker=def"}
+            ),
+            std::unordered_set<std::string_view>(requested_query_params.begin(), requested_query_params.end())
+        );
+    }
+}
+
+TEST(S3ApiMethods, ListParts) {
+    {
+        multipart_upload::ListPartsRequest request;
+        request.key = "some/path/to";
+        request.upload_id = "some_id";
+        const auto result = CreateInternalApiRequest("some-bucket", request);
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kGet);
+        EXPECT_EQ(result.req, "some/path/to?uploadId=some_id");
+        EXPECT_EQ(result.headers, clients::http::Headers{});
+    }
+    {
+        multipart_upload::ListPartsRequest request;
+        request.key = "some/path/to";
+        request.upload_id = "some_id";
+        request.max_parts = 10;
+        request.part_number_marker = 11;
+
+        const auto result = CreateInternalApiRequest("some-bucket", request);
+        EXPECT_EQ(result.bucket, "some-bucket");
+        EXPECT_EQ(result.method, clients::http::HttpMethod::kGet);
+
+        const auto requested_query_params =
+            utils::text::SplitIntoStringViewVector(http::ExtractQueryView(result.req), "&");
+        EXPECT_EQ(
+            std::unordered_set<std::string_view>({"uploadId=some_id", "max-parts=10", "part-number-marker=11"}),
+            std::unordered_set<std::string_view>(requested_query_params.begin(), requested_query_params.end())
+        );
+        EXPECT_EQ(result.req.substr(0, result.req.find('?')), "some/path/to");
+
+        EXPECT_EQ(result.headers, clients::http::Headers{});
+    }
+}
+
 }  // namespace s3api::api_methods
 
 USERVER_NAMESPACE_END
diff --git a/libraries/s3api/utest/include/userver/s3api/utest/client_gmock.hpp b/libraries/s3api/utest/include/userver/s3api/utest/client_gmock.hpp
index b1de5afa30fd..c8ed865f808a 100644
--- a/libraries/s3api/utest/include/userver/s3api/utest/client_gmock.hpp
+++ b/libraries/s3api/utest/include/userver/s3api/utest/client_gmock.hpp
@@ -125,6 +125,48 @@ class GMockClient : public Client {
 
     MOCK_METHOD(std::vector<std::string>, ListBucketDirectories, (std::string_view path_prefix), (const, override));
 
+    MOCK_METHOD(
+        multipart_upload::InitiateMultipartUploadResult,
+        CreateMultipartUpload,
+        (const multipart_upload::CreateMultipartUploadRequest& request),
+        (const, override)
+    );
+
+    MOCK_METHOD(
+        multipart_upload::UploadPartResult,
+        UploadPart,
+        (const multipart_upload::UploadPartRequest& request),
+        (const, override)
+    );
+
+    MOCK_METHOD(
+        multipart_upload::CompleteMultipartUploadResult,
+        CompleteMultipartUpload,
+        (const multipart_upload::CompleteMultipartUploadRequest& request),
+        (const, override)
+    );
+
+    MOCK_METHOD(
+        void,
+        AbortMultipartUpload,
+        (const multipart_upload::AbortMultipartUploadRequest& request),
+        (const, override)
+    );
+
+    MOCK_METHOD(
+        multipart_upload::ListPartsResult,
+        ListParts,
+        (const multipart_upload::ListPartsRequest& request),
+        (const, override)
+    );
+
+    MOCK_METHOD(
+        multipart_upload::ListMultipartUploadsResult,
+        ListMultipartUploads,
+        (const multipart_upload::ListMultipartUploadsRequest& request),
+        (const, override)
+    );
+
     MOCK_METHOD(void, UpdateConfig, (ConnectionCfg && config), (override));
 
     MOCK_METHOD(std::string_view, GetBucketName, (), (const, override));
diff --git a/mongo/CMakeLists.txt b/mongo/CMakeLists.txt
index 93529a0ef082..7d4a43551117 100644
--- a/mongo/CMakeLists.txt
+++ b/mongo/CMakeLists.txt
@@ -17,6 +17,7 @@ userver_module(
     # Tests that use IsCollectionWriteConcernTimeout require multi-instance mongo
     DBTEST_ENV TESTSUITE_MONGO_RS_INSTANCE_COUNT=5
     UBENCH_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_benchmark.cpp"
+    DEPENDS core
     GENERATE_DYNAMIC_CONFIGS
 )
 
diff --git a/mongo/dynamic_configs/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.yaml b/mongo/dynamic_configs/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.yaml
deleted file mode 100644
index 0e971f0fff7d..000000000000
--- a/mongo/dynamic_configs/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.yaml
+++ /dev/null
@@ -1,6 +0,0 @@
-default: true
-description: |
-    Whether task-inherited deadline should be accounted for
-    while executing mongodb queries.
-schema:
-    type: boolean
diff --git a/mongo/dynamic_configs/USERVER_DEADLINE_PROPAGATION_ENABLED.yaml b/mongo/dynamic_configs/USERVER_DEADLINE_PROPAGATION_ENABLED.yaml
new file mode 100644
index 000000000000..dda05690752d
--- /dev/null
+++ b/mongo/dynamic_configs/USERVER_DEADLINE_PROPAGATION_ENABLED.yaml
@@ -0,0 +1,14 @@
+default: true
+description: |
+    When `false`, disables deadline propagation in the service. This includes:
+
+    - reading the task-inherited deadline from HTTP headers and gRPC metadata;
+    - interrupting operations when deadline expires;
+    - propagating the deadline to downstream services and databases.
+
+    Deadline propagation can also be disabled in the static config of:
+    - components::Server (disables the HTTP handler part).
+
+    Deadline propagation is disabled if disabled statically OR dynamically.
+schema:
+    type: boolean
diff --git a/mongo/functional_tests/basic_chaos/tests-deadline-propagation/test_deadline_propagation.py b/mongo/functional_tests/basic_chaos/tests-deadline-propagation/test_deadline_propagation.py
index 77b98a56c2e9..3441a4f81815 100644
--- a/mongo/functional_tests/basic_chaos/tests-deadline-propagation/test_deadline_propagation.py
+++ b/mongo/functional_tests/basic_chaos/tests-deadline-propagation/test_deadline_propagation.py
@@ -14,7 +14,7 @@ async def _put_foo_value(service_client):
 
 
 async def test_works(service_client, put_foo_value, dynamic_config):
-    assert dynamic_config.get('MONGO_DEADLINE_PROPAGATION_ENABLED_V2')
+    assert dynamic_config.get('USERVER_DEADLINE_PROPAGATION_ENABLED')
 
     async with service_client.capture_logs() as capture:
         response = await service_client.get(
@@ -29,20 +29,3 @@ async def test_works(service_client, put_foo_value, dynamic_config):
     text = logs[0]['text']
     assert 'Operation cancelled: deadline propagation' in text, text
     assert 'storages::mongo::CancelledException' in text, text
-
-
-@pytest.mark.config(MONGO_DEADLINE_PROPAGATION_ENABLED_V2=False)
-async def test_disabled(service_client, put_foo_value, dynamic_config):
-    async with service_client.capture_logs() as capture:
-        response = await service_client.get(
-            '/v1/key-value?key=foo&sleep_ms=200',
-            headers={DP_TIMEOUT_MS: '100'},
-        )
-        assert response.status == 498
-        assert response.text == 'Deadline expired'
-
-    # The mongo request should be completed ignoring the fact that
-    # deadline has already expired.
-    logs = capture.select(_type='response', meta_type='/v1/key-value')
-    assert len(logs) == 1, logs
-    assert logs[0].get('dp_original_body', None) == 'bar', str(logs)
diff --git a/mongo/include/userver/cache/mongo_cache_type_traits.hpp b/mongo/include/userver/cache/mongo_cache_type_traits.hpp
index eaca914a7c02..86039e973e81 100644
--- a/mongo/include/userver/cache/mongo_cache_type_traits.hpp
+++ b/mongo/include/userver/cache/mongo_cache_type_traits.hpp
@@ -22,17 +22,17 @@ namespace mongo_cache::impl {
 template <typename T>
 using CollectionsField = decltype(T::kMongoCollectionsField);
 template <typename T>
-inline constexpr bool kHasCollectionsField = meta::kIsDetected<CollectionsField, T>;
+inline constexpr bool kHasCollectionsField = meta::IsDetected<CollectionsField, T>;
 
 template <typename T>
 using UpdateFieldName = decltype(T::kMongoUpdateFieldName);
 template <typename T>
-inline constexpr bool kHasUpdateFieldName = meta::kIsDetected<UpdateFieldName, T>;
+inline constexpr bool kHasUpdateFieldName = meta::IsDetected<UpdateFieldName, T>;
 
 template <typename T>
 using KeyField = decltype(T::kKeyField);
 template <typename T>
-inline constexpr bool kHasKeyField = meta::kIsDetected<KeyField, T>;
+inline constexpr bool kHasKeyField = meta::IsDetected<KeyField, T>;
 
 template <typename T>
 using DataType = typename T::DataType;
@@ -42,29 +42,29 @@ inline constexpr bool kHasValidDataType = meta::kIsMap<meta::DetectedType<DataTy
 template <typename T>
 using HasSecondaryPreferred = decltype(T::kIsSecondaryPreferred);
 template <typename T>
-inline constexpr bool kHasSecondaryPreferred = meta::kIsDetected<HasSecondaryPreferred, T>;
+inline constexpr bool kHasSecondaryPreferred = meta::IsDetected<HasSecondaryPreferred, T>;
 
 template <typename T>
 using HasDeserializeObject = decltype(T::DeserializeObject);
 template <typename T>
-inline constexpr bool kHasDeserializeObject = meta::kIsDetected<HasDeserializeObject, T>;
+inline constexpr bool kHasDeserializeObject = meta::IsDetected<HasDeserializeObject, T>;
 
 template <typename T>
 using HasCorrectDeserializeObject = meta::ExpectSame<
     typename T::ObjectType,
     decltype(std::declval<const T&>().DeserializeObject(std::declval<const formats::bson::Document&>()))>;
 template <typename T>
-inline constexpr bool kHasCorrectDeserializeObject = meta::kIsDetected<HasCorrectDeserializeObject, T>;
+inline constexpr bool kHasCorrectDeserializeObject = meta::IsDetected<HasCorrectDeserializeObject, T>;
 
 template <typename T>
 using HasDefaultDeserializeObject = decltype(T::kUseDefaultDeserializeObject);
 template <typename T>
-inline constexpr bool kHasDefaultDeserializeObject = meta::kIsDetected<HasDefaultDeserializeObject, T>;
+inline constexpr bool kHasDefaultDeserializeObject = meta::IsDetected<HasDefaultDeserializeObject, T>;
 
 template <typename T>
 using HasFindOperation = decltype(T::GetFindOperation);
 template <typename T>
-inline constexpr bool kHasFindOperation = meta::kIsDetected<HasFindOperation, T>;
+inline constexpr bool kHasFindOperation = meta::IsDetected<HasFindOperation, T>;
 
 template <typename T>
 using HasCorrectFindOperation = meta::ExpectSame<
@@ -77,17 +77,17 @@ using HasCorrectFindOperation = meta::ExpectSame<
     ))>;
 
 template <typename T>
-inline constexpr bool kHasCorrectFindOperation = meta::kIsDetected<HasCorrectFindOperation, T>;
+inline constexpr bool kHasCorrectFindOperation = meta::IsDetected<HasCorrectFindOperation, T>;
 
 template <typename T>
 using HasDefaultFindOperation = decltype(T::kUseDefaultFindOperation);
 template <typename T>
-inline constexpr bool kHasDefaultFindOperation = meta::kIsDetected<HasDefaultFindOperation, T>;
+inline constexpr bool kHasDefaultFindOperation = meta::IsDetected<HasDefaultFindOperation, T>;
 
 template <typename T>
 using HasInvalidDocumentsSkipped = decltype(T::kAreInvalidDocumentsSkipped);
 template <typename T>
-inline constexpr bool kHasInvalidDocumentsSkipped = meta::kIsDetected<HasInvalidDocumentsSkipped, T>;
+inline constexpr bool kHasInvalidDocumentsSkipped = meta::IsDetected<HasInvalidDocumentsSkipped, T>;
 
 template <typename>
 struct ClassByMemberPointer {};
diff --git a/mongo/include/userver/formats/bson/value.hpp b/mongo/include/userver/formats/bson/value.hpp
index 57626ce38450..c9efc6c61d6d 100644
--- a/mongo/include/userver/formats/bson/value.hpp
+++ b/mongo/include/userver/formats/bson/value.hpp
@@ -332,7 +332,7 @@ using formats::common::Items;
 /// 'using namespace ABC' may contradict code style of your company.
 namespace formats::literals {
 
-bson::Value operator"" _bson(const char* str, std::size_t len);
+bson::Value operator""_bson(const char* str, std::size_t len);
 
 }  // namespace formats::literals
 
diff --git a/mongo/include/userver/storages/mongo/collection.hpp b/mongo/include/userver/storages/mongo/collection.hpp
index 2d59acd84738..e4c364f44e9b 100644
--- a/mongo/include/userver/storages/mongo/collection.hpp
+++ b/mongo/include/userver/storages/mongo/collection.hpp
@@ -117,6 +117,20 @@ class Collection {
     template <typename... Options>
     Cursor Aggregate(formats::bson::Value pipeline, Options&&... options);
 
+    /// @brief Retrieves distinct values for a specified field
+    /// @param field name of the field for which to return distinct values
+    /// @param options see @ref storages::mongo::options
+    template <typename... Options>
+    std::vector<formats::bson::Value> Distinct(std::string field, Options&&... options) const;
+
+    /// @brief Retrieves distinct values for a specified field with a query filter
+    /// @param field name of the field for which to return distinct values
+    /// @param filter query that specifies the documents from which to retrieve distinct values
+    /// @param options see @ref storages::mongo::options
+    template <typename... Options>
+    std::vector<formats::bson::Value> Distinct(std::string field, formats::bson::Document filter, Options&&... options)
+        const;
+
     /// Get collection name
     const std::string& GetCollectionName() const;
 
@@ -125,6 +139,7 @@ class Collection {
     size_t Execute(const operations::Count&) const;
     size_t Execute(const operations::CountApprox&) const;
     Cursor Execute(const operations::Find&) const;
+    std::vector<formats::bson::Value> Execute(const operations::Distinct&) const;
     WriteResult Execute(const operations::InsertOne&);
     WriteResult Execute(const operations::InsertMany&);
     WriteResult Execute(const operations::ReplaceOne&);
@@ -276,6 +291,21 @@ Cursor Collection::Aggregate(formats::bson::Value pipeline, Options&&... options
     return Execute(aggregate);
 }
 
+template <typename... Options>
+std::vector<formats::bson::Value> Collection::Distinct(std::string field, Options&&... options) const {
+    operations::Distinct distinct_op(std::move(field));
+    (distinct_op.SetOption(std::forward<Options>(options)), ...);
+    return Execute(distinct_op);
+}
+
+template <typename... Options>
+std::vector<formats::bson::Value>
+Collection::Distinct(std::string field, formats::bson::Document filter, Options&&... options) const {
+    operations::Distinct distinct_op(std::move(field), std::move(filter));
+    (distinct_op.SetOption(std::forward<Options>(options)), ...);
+    return Execute(distinct_op);
+}
+
 }  // namespace storages::mongo
 
 USERVER_NAMESPACE_END
diff --git a/mongo/include/userver/storages/mongo/operations.hpp b/mongo/include/userver/storages/mongo/operations.hpp
index 14dcaad9d80d..7ebd34517212 100644
--- a/mongo/include/userver/storages/mongo/operations.hpp
+++ b/mongo/include/userver/storages/mongo/operations.hpp
@@ -339,6 +339,35 @@ class Aggregate {
     utils::FastPimpl<Impl, kSize, kAlignment, false> impl_;
 };
 
+/// Retrieves distinct values for a specified field
+class Distinct final {
+public:
+    explicit Distinct(std::string field);
+    Distinct(std::string field, formats::bson::Document filter);
+    ~Distinct();
+
+    Distinct(const Distinct&);
+    Distinct(Distinct&&) noexcept;
+    Distinct& operator=(const Distinct&);
+    Distinct& operator=(Distinct&&) noexcept;
+
+    void SetOption(const options::ReadPreference&);
+    void SetOption(options::ReadPreference::Mode);
+    void SetOption(options::ReadConcern);
+    void SetOption(const options::Collation&);
+    void SetOption(const options::Comment&);
+    void SetOption(const options::MaxServerTime&);
+
+private:
+    friend class storages::mongo::impl::cdriver::CDriverCollectionImpl;
+
+    class Impl;
+    static constexpr size_t kSize = 104;
+    static constexpr size_t kAlignment = 8;
+    // MAC_COMPAT: std::string size differs
+    utils::FastPimpl<Impl, kSize, kAlignment, false> impl_;
+};
+
 class Drop {
 public:
     Drop();
diff --git a/mongo/include/userver/storages/mongo/options.hpp b/mongo/include/userver/storages/mongo/options.hpp
index 66d97610b042..55aa0ca8e980 100644
--- a/mongo/include/userver/storages/mongo/options.hpp
+++ b/mongo/include/userver/storages/mongo/options.hpp
@@ -139,6 +139,7 @@ class Skip {
 
     size_t Value() const { return value_; }
 
+private:
     size_t value_;
 };
 
@@ -311,6 +312,91 @@ class MaxServerTime {
     std::chrono::milliseconds value_;
 };
 
+/// @brief Specifies collation options for text comparison
+/// @see https://docs.mongodb.com/manual/reference/collation/
+/// @see https://unicode-org.github.io/icu/userguide/collation/concepts.html
+class Collation final {
+public:
+    enum class Strength {
+        /// Primary level of comparison (base characters only)
+        kPrimary = 1,
+        /// Secondary level (base characters + diacritics)
+        kSecondary = 2,
+        /// Tertiary level (base + diacritics + case), default
+        kTertiary = 3,
+        /// Quaternary level
+        kQuaternary = 4,
+        /// Identical level (tie breaker)
+        kIdentical = 5
+    };
+
+    enum class CaseFirst {
+        /// Default value, similar to lower with slight differences
+        kOff,
+        /// Uppercase sorts before lowercase
+        kUpper,
+        /// Lowercase sorts before uppercase
+        kLower
+    };
+
+    enum class Alternate {
+        /// Whitespace and punctuation are considered base characters (default)
+        kNonIgnorable,
+        /// Whitespace and punctuation not considered base characters
+        kShifted
+    };
+
+    enum class MaxVariable {
+        /// Both whitespace and punctuation are ignorable
+        kPunct,
+        /// Only whitespace is ignorable
+        kSpace
+    };
+
+    /// Creates a collation with mandatory locale
+    explicit Collation(std::string locale);
+
+    /// @brief Sets the ICU collation level
+    /// Default is kTertiary
+    Collation& SetStrength(Strength strength);
+
+    /// @brief Sets whether to include case comparison at strength level 1 or 2
+    /// Default is false
+    Collation& SetCaseLevel(bool case_level);
+
+    /// @brief Sets sort order of case differences during tertiary level comparisons
+    /// Default is kOff
+    Collation& SetCaseFirst(CaseFirst case_first);
+
+    /// @brief Sets whether to compare numeric strings as numbers or as strings
+    /// Default is false (compare as strings)
+    Collation& SetNumericOrdering(bool numeric_ordering);
+
+    /// @brief Sets whether collation should consider whitespace and punctuation as base characters
+    /// Default is kNonIgnorable
+    Collation& SetAlternate(Alternate alternate);
+
+    /// @brief Sets up to which characters are considered ignorable when alternate is kShifted
+    /// Has no effect if alternate is kNonIgnorable
+    Collation& SetMaxVariable(MaxVariable max_variable);
+
+    /// @brief Sets whether strings with diacritics sort from back of the string
+    /// Default is false (compare from front to back)
+    Collation& SetBackwards(bool backwards);
+
+    /// @brief Sets whether to check if text require normalization and perform normalization
+    /// Default is false
+    Collation& SetNormalization(bool normalization);
+
+    /// @cond
+    /// Collation specification BSON access for internal use
+    const bson_t* GetCollationBson() const;
+    /// @endcond
+
+private:
+    formats::bson::impl::BsonBuilder collation_builder_;
+};
+
 }  // namespace storages::mongo::options
 
 USERVER_NAMESPACE_END
diff --git a/mongo/library.yaml b/mongo/library.yaml
index b09428ae543b..2dc241d39d56 100644
--- a/mongo/library.yaml
+++ b/mongo/library.yaml
@@ -14,5 +14,4 @@ configs:
       - MONGO_CONGESTION_CONTROL_ENABLED
       - MONGO_CONGESTION_CONTROL_SETTINGS
       - MONGO_CONNECTION_POOL_SETTINGS
-      - MONGO_DEADLINE_PROPAGATION_ENABLED_V2
       - MONGO_DEFAULT_MAX_TIME_MS
diff --git a/mongo/src/formats/bson/value.cpp b/mongo/src/formats/bson/value.cpp
index 9bf4164e6f56..6af73c248b03 100644
--- a/mongo/src/formats/bson/value.cpp
+++ b/mongo/src/formats/bson/value.cpp
@@ -291,7 +291,7 @@ const impl::BsonHolder& Value::GetBson() const { return impl_->GetBson(); }
 
 namespace formats::literals {
 
-bson::Value operator"" _bson(const char* str, size_t len) { return bson::FromJsonString(std::string(str, len)); }
+bson::Value operator""_bson(const char* str, size_t len) { return bson::FromJsonString(std::string(str, len)); }
 
 }  // namespace formats::literals
 
diff --git a/mongo/src/storages/mongo/bulk_ops_impl.hpp b/mongo/src/storages/mongo/bulk_ops_impl.hpp
index b82d1b31805d..837b4ab03500 100644
--- a/mongo/src/storages/mongo/bulk_ops_impl.hpp
+++ b/mongo/src/storages/mongo/bulk_ops_impl.hpp
@@ -12,15 +12,15 @@ namespace storages::mongo::bulk_ops {
 
 class InsertOne::Impl {
 public:
-    explicit Impl(formats::bson::Document&& document_) : document(std::move(document_)) {}
+    explicit Impl(formats::bson::Document&& document) : document(std::move(document)) {}
 
     formats::bson::Document document;
 };
 
 class ReplaceOne::Impl {
 public:
-    Impl(formats::bson::Document&& selector_, formats::bson::Document&& replacement_)
-        : selector(std::move(selector_)), replacement(std::move(replacement_)) {}
+    Impl(formats::bson::Document&& selector, formats::bson::Document&& replacement)
+        : selector(std::move(selector)), replacement(std::move(replacement)) {}
 
     formats::bson::Document selector;
     formats::bson::Document replacement;
@@ -29,8 +29,8 @@ class ReplaceOne::Impl {
 
 class Update::Impl {
 public:
-    Impl(Mode mode_, formats::bson::Document&& selector_, formats::bson::Document&& update_)
-        : mode(mode_), selector(std::move(selector_)), update(std::move(update_)) {}
+    Impl(Mode mode, formats::bson::Document&& selector, formats::bson::Document&& update)
+        : mode(mode), selector(std::move(selector)), update(std::move(update)) {}
 
     Mode mode;
     formats::bson::Document selector;
@@ -40,7 +40,7 @@ class Update::Impl {
 
 class Delete::Impl {
 public:
-    Impl(Mode mode_, formats::bson::Document&& selector_) : mode(mode_), selector(std::move(selector_)) {}
+    Impl(Mode mode, formats::bson::Document&& selector) : mode(mode), selector(std::move(selector)) {}
 
     Mode mode;
     formats::bson::Document selector;
diff --git a/mongo/src/storages/mongo/cdriver/collection_impl.cpp b/mongo/src/storages/mongo/cdriver/collection_impl.cpp
index 6ef144858c2d..52843832ccb1 100644
--- a/mongo/src/storages/mongo/cdriver/collection_impl.cpp
+++ b/mongo/src/storages/mongo/cdriver/collection_impl.cpp
@@ -22,8 +22,8 @@
 #include <storages/mongo/operations_common.hpp>
 #include <storages/mongo/operations_impl.hpp>
 
-#include <dynamic_config/variables/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.hpp>
 #include <dynamic_config/variables/MONGO_DEFAULT_MAX_TIME_MS.hpp>
+#include <dynamic_config/variables/USERVER_DEADLINE_PROPAGATION_ENABLED.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -105,7 +105,7 @@ impl::cdriver::FindAndModifyOptsPtr CopyFindAndModifyOptions(const impl::cdriver
 }
 
 std::optional<std::chrono::milliseconds> GetDeadlineTimeLeft(const dynamic_config::Snapshot& config) {
-    if (!config[::dynamic_config::MONGO_DEADLINE_PROPAGATION_ENABLED_V2]) return std::nullopt;
+    if (!config[::dynamic_config::USERVER_DEADLINE_PROPAGATION_ENABLED]) return std::nullopt;
 
     const auto inherited_deadline = server::request::GetTaskInheritedDeadline();
     if (!inherited_deadline.IsReachable()) return std::nullopt;
@@ -246,6 +246,59 @@ Cursor CDriverCollectionImpl::Execute(const operations::Find& operation) const {
     ));
 }
 
+std::vector<formats::bson::Value> CDriverCollectionImpl::Execute(const operations::Distinct& operation) const {
+    auto context = MakeRequestContext("mongo_distinct", operation);
+
+    auto options = operation.impl_->options;
+    SetMaxServerTime(options, operation.impl_->max_server_time, context);
+    bool has_comment_option = operation.impl_->has_comment_option;
+    if (!has_comment_option) SetLinkComment(impl::EnsureBuilder(options), has_comment_option);
+
+    MongoError error;
+    stats::OperationStopwatch stopwatch(std::move(context.stats));
+
+    formats::bson::impl::BsonBuilder command_builder;
+    command_builder.Append("distinct", GetCollectionName());
+    command_builder.Append("key", operation.impl_->field);
+
+    if (operation.impl_->filter.has_value()) {
+        command_builder.Append("query", operation.impl_->filter.value());
+    }
+
+    auto command_bson = command_builder.Extract();
+    const bson_t* native_command_bson_ptr = command_bson.get();
+
+    formats::bson::impl::UninitializedBson result_bson;
+    if (!mongoc_collection_read_command_with_opts(
+            context.collection.get(),
+            native_command_bson_ptr,
+            operation.impl_->read_prefs.Get(),
+            impl::GetNative(options),
+            result_bson.Get(),
+            error.GetNative()
+        )) {
+        stopwatch.AccountError(error.GetKind());
+        error.Throw("Error executing distinct operation");
+    }
+
+    stopwatch.AccountSuccess();
+
+    auto result_doc = formats::bson::Document(result_bson.Extract());
+    auto values_field = result_doc["values"];
+    if (!values_field.IsArray()) {
+        throw MongoException("Distinct operation result is not an array");
+    }
+
+    std::vector<formats::bson::Value> distinct_values;
+    distinct_values.reserve(values_field.GetSize());
+
+    for (auto& value : values_field) {
+        distinct_values.push_back(std::move(value));
+    }
+
+    return distinct_values;
+}
+
 WriteResult CDriverCollectionImpl::Execute(const operations::InsertOne& operation) {
     auto context = MakeRequestContext("mongo_insert_one", operation);
 
diff --git a/mongo/src/storages/mongo/cdriver/collection_impl.hpp b/mongo/src/storages/mongo/cdriver/collection_impl.hpp
index 62673e697f37..fb888db6119b 100644
--- a/mongo/src/storages/mongo/cdriver/collection_impl.hpp
+++ b/mongo/src/storages/mongo/cdriver/collection_impl.hpp
@@ -30,6 +30,7 @@ class CDriverCollectionImpl : public CollectionImpl {
     size_t Execute(const operations::Count&) const override;
     size_t Execute(const operations::CountApprox&) const override;
     Cursor Execute(const operations::Find&) const override;
+    std::vector<formats::bson::Value> Execute(const operations::Distinct&) const override;
     WriteResult Execute(const operations::InsertOne&) override;
     WriteResult Execute(const operations::InsertMany&) override;
     WriteResult Execute(const operations::ReplaceOne&) override;
diff --git a/mongo/src/storages/mongo/cdriver/pool_impl.cpp b/mongo/src/storages/mongo/cdriver/pool_impl.cpp
index ac1f308b25f8..3b1304f8e226 100644
--- a/mongo/src/storages/mongo/cdriver/pool_impl.cpp
+++ b/mongo/src/storages/mongo/cdriver/pool_impl.cpp
@@ -25,7 +25,7 @@
 #include <userver/storages/mongo/exception.hpp>
 #include <userver/storages/mongo/mongo_error.hpp>
 
-#include <dynamic_config/variables/MONGO_DEADLINE_PROPAGATION_ENABLED_V2.hpp>
+#include <dynamic_config/variables/USERVER_DEADLINE_PROPAGATION_ENABLED.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -164,26 +164,26 @@ stats::ConnStats& GetStats(void* stats_ptr) {
 
 void CommandSucceeded(const mongoc_apm_command_succeeded_t* event) {
     auto& stats = GetStats(mongoc_apm_command_succeeded_get_context(event));
-    stats.event_stats_.success += utils::statistics::Rate{1};
+    stats.event_stats.success += utils::statistics::Rate{1};
 }
 
 void CommandFailed(const mongoc_apm_command_failed_t* event) {
     auto& stats = GetStats(mongoc_apm_command_failed_get_context(event));
-    stats.event_stats_.failed += utils::statistics::Rate{1};
+    stats.event_stats.failed += utils::statistics::Rate{1};
 }
 
 void HeartbeatStarted(const mongoc_apm_server_heartbeat_started_t* event) {
     auto& stats = GetStats(mongoc_apm_server_heartbeat_started_get_context(event));
-    ++stats.apm_stats_->heartbeats.start;
+    ++stats.apm_stats->heartbeats.start;
     LOG_LIMITED_DEBUG() << mongoc_apm_server_heartbeat_started_get_host(event)->host_and_port << " heartbeat started";
-    stats.apm_stats_->heartbeats.hb_started = std::chrono::steady_clock::now();
+    stats.apm_stats->heartbeats.hb_started = std::chrono::steady_clock::now();
 }
 
 void HeartbeatFinished(stats::ConnStats& stats) {
     auto* span = tracing::Span::CurrentSpanUnchecked();
     if (span) {
         auto diff = std::chrono::duration_cast<RealMilliseconds>(
-            std::chrono::steady_clock::now() - stats.apm_stats_->heartbeats.hb_started
+            std::chrono::steady_clock::now() - stats.apm_stats->heartbeats.hb_started
         );
         span->AddTag("heartbeat_time", diff.count());
     }
@@ -191,7 +191,7 @@ void HeartbeatFinished(stats::ConnStats& stats) {
 
 void HeartbeatSuccess(const mongoc_apm_server_heartbeat_succeeded_t* event) {
     auto& stats = GetStats(mongoc_apm_server_heartbeat_succeeded_get_context(event));
-    ++stats.apm_stats_->heartbeats.success;
+    ++stats.apm_stats->heartbeats.success;
     LOG_LIMITED_DEBUG() << mongoc_apm_server_heartbeat_succeeded_get_host(event)->host_and_port
                         << " heartbeat succeeded";
     HeartbeatFinished(stats);
@@ -199,7 +199,7 @@ void HeartbeatSuccess(const mongoc_apm_server_heartbeat_succeeded_t* event) {
 
 void HeartbeatFailed(const mongoc_apm_server_heartbeat_failed_t* event) {
     auto& stats = GetStats(mongoc_apm_server_heartbeat_failed_get_context(event));
-    ++stats.apm_stats_->heartbeats.failed;
+    ++stats.apm_stats->heartbeats.failed;
 
     MongoError error;
     mongoc_apm_server_heartbeat_failed_get_error(event, error.GetNative());
@@ -279,7 +279,7 @@ std::string CreateTopologyChangeMessage(const mongoc_apm_topology_changed_t* eve
 
 void TopologyChanged(const mongoc_apm_topology_changed_t* event) {
     auto& stats = GetStats(mongoc_apm_topology_changed_get_context(event));
-    ++stats.apm_stats_->topology.changed;
+    ++stats.apm_stats->topology.changed;
 
     LOG_INFO() << CreateTopologyChangeMessage(event);
 }
@@ -454,7 +454,7 @@ CDriverPoolImpl::ConnPtr CDriverPoolImpl::Pop() {
     std::optional<engine::Deadline::Duration> inherited_timeout{};
 
     const auto dynamic_config = GetConfig();
-    if (dynamic_config[::dynamic_config::MONGO_DEADLINE_PROPAGATION_ENABLED_V2]) {
+    if (dynamic_config[::dynamic_config::USERVER_DEADLINE_PROPAGATION_ENABLED]) {
         HandleCancellations(queue_deadline, inherited_timeout);
     }
 
diff --git a/mongo/src/storages/mongo/cdriver/pool_impl.hpp b/mongo/src/storages/mongo/cdriver/pool_impl.hpp
index 36eb0100c737..7660b7edf65c 100644
--- a/mongo/src/storages/mongo/cdriver/pool_impl.hpp
+++ b/mongo/src/storages/mongo/cdriver/pool_impl.hpp
@@ -35,7 +35,7 @@ class CDriverPoolImpl final : public PoolImpl {
             : epoch_(epoch), client_(client) {
             UASSERT(client_);
             UASSERT(apm_stats);
-            stats_.apm_stats_ = apm_stats;
+            stats_.apm_stats = apm_stats;
         }
 
         Connection(Connection&& other) = delete;
@@ -74,7 +74,7 @@ class CDriverPoolImpl final : public PoolImpl {
 
         stats::EventStats GetEventStatsSnapshot() {
             UASSERT(ptr_);
-            return ptr_->GetStatsPtr()->event_stats_;
+            return ptr_->GetStatsPtr()->event_stats;
         }
 
         void reset() {
diff --git a/mongo/src/storages/mongo/collection.cpp b/mongo/src/storages/mongo/collection.cpp
index 4a5884a62444..0c08f54d2d18 100644
--- a/mongo/src/storages/mongo/collection.cpp
+++ b/mongo/src/storages/mongo/collection.cpp
@@ -17,6 +17,10 @@ size_t Collection::Execute(const operations::CountApprox& count_approx_op) const
 
 Cursor Collection::Execute(const operations::Find& find_op) const { return impl_->Execute(find_op); }
 
+std::vector<formats::bson::Value> Collection::Execute(const operations::Distinct& distinct_op) const {
+    return impl_->Execute(distinct_op);
+}
+
 WriteResult Collection::Execute(const operations::InsertOne& insert_op) { return impl_->Execute(insert_op); }
 
 WriteResult Collection::Execute(const operations::InsertMany& insert_op) { return impl_->Execute(insert_op); }
diff --git a/mongo/src/storages/mongo/collection_impl.hpp b/mongo/src/storages/mongo/collection_impl.hpp
index 995ead5f2bf9..e77a01be6fb9 100644
--- a/mongo/src/storages/mongo/collection_impl.hpp
+++ b/mongo/src/storages/mongo/collection_impl.hpp
@@ -23,6 +23,7 @@ class CollectionImpl {
     virtual size_t Execute(const operations::Count&) const = 0;
     virtual size_t Execute(const operations::CountApprox&) const = 0;
     virtual Cursor Execute(const operations::Find&) const = 0;
+    virtual std::vector<formats::bson::Value> Execute(const operations::Distinct&) const = 0;
     virtual WriteResult Execute(const operations::InsertOne&) = 0;
     virtual WriteResult Execute(const operations::InsertMany&) = 0;
     virtual WriteResult Execute(const operations::ReplaceOne&) = 0;
diff --git a/mongo/src/storages/mongo/collection_mongotest.cpp b/mongo/src/storages/mongo/collection_mongotest.cpp
index 75dcb3a6c663..1e29cc4e166a 100644
--- a/mongo/src/storages/mongo/collection_mongotest.cpp
+++ b/mongo/src/storages/mongo/collection_mongotest.cpp
@@ -96,7 +96,7 @@ UTEST_F(Collection, Read) {
     }
     {
         auto cursor = coll.Find({});
-        EXPECT_EQ(cursor.GetBatchSize(), 0) << "Deafault value should be 0 (use server side size)";
+        EXPECT_EQ(cursor.GetBatchSize(), 0) << "Default value should be 0 (use server side size)";
         EXPECT_NO_THROW(cursor.SetBatchSize(0)) << "Setting to 0 should be fine";
         EXPECT_TRUE(cursor);
         EXPECT_TRUE(cursor.HasMore());
@@ -599,4 +599,248 @@ UTEST_F(Collection, ExecuteOps) {
     EXPECT_EQ(GetWinners(mongo_coll), "some_name_3 <anonymous> some_name_1 ");
 }
 
+std::vector<formats::bson::Value> SortBsonValues(std::vector<formats::bson::Value> values) {
+    std::sort(values.begin(), values.end(), [](const auto& a, const auto& b) {
+        if (a.IsString() && b.IsString()) {
+            return a.template As<std::string>() < b.template As<std::string>();
+        }
+        if (a.IsInt32() && b.IsInt32()) {
+            return a.template As<int32_t>() < b.template As<int32_t>();
+        }
+        if (a.IsInt64() && b.IsInt64()) {
+            return a.template As<int64_t>() < b.template As<int64_t>();
+        }
+        if (a.IsDouble() && b.IsDouble()) {
+            return a.template As<double>() < b.template As<double>();
+        }
+
+        return a.template ConvertTo<std::string>() < b.template ConvertTo<std::string>();
+    });
+
+    return values;
+}
+
+UTEST_F(Collection, Distinct) {
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "category", "A", "value", 10),
+             bson::MakeDoc("_id", 2, "category", "B", "value", 20),
+             bson::MakeDoc("_id", 3, "category", "A", "value", 30),
+             bson::MakeDoc("_id", 4, "category", "C", "value", 40),
+             bson::MakeDoc("_id", 5, "category", "B", "value", 50),
+             bson::MakeDoc("_id", 6, "category", "A", "value", 60)}
+        );
+
+        {
+            const auto sorted_result = SortBsonValues(coll.Distinct("category"));
+            ASSERT_EQ(3, sorted_result.size());
+            EXPECT_EQ("A", sorted_result[0].As<std::string>());
+            EXPECT_EQ("B", sorted_result[1].As<std::string>());
+            EXPECT_EQ("C", sorted_result[2].As<std::string>());
+        }
+
+        {
+            const auto sorted_result = SortBsonValues(coll.Distinct("value"));
+            ASSERT_EQ(6, sorted_result.size());
+            EXPECT_EQ(10, sorted_result[0].As<int32_t>());
+            EXPECT_EQ(20, sorted_result[1].As<int32_t>());
+            EXPECT_EQ(30, sorted_result[2].As<int32_t>());
+            EXPECT_EQ(40, sorted_result[3].As<int32_t>());
+            EXPECT_EQ(50, sorted_result[4].As<int32_t>());
+            EXPECT_EQ(60, sorted_result[5].As<int32_t>());
+        }
+
+        {
+            const auto result = coll.Distinct("nonexistent");
+            EXPECT_TRUE(result.empty());
+        }
+    }
+
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct_filter");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "category", "A", "status", "active", "score", 85),
+             bson::MakeDoc("_id", 2, "category", "B", "status", "inactive", "score", 70),
+             bson::MakeDoc("_id", 3, "category", "A", "status", "active", "score", 90),
+             bson::MakeDoc("_id", 4, "category", "C", "status", "active", "score", 60),
+             bson::MakeDoc("_id", 5, "category", "B", "status", "active", "score", 95),
+             bson::MakeDoc("_id", 6, "category", "A", "status", "inactive", "score", 75)}
+        );
+
+        {
+            const auto sorted_result = SortBsonValues(coll.Distinct("category", bson::MakeDoc("status", "active")));
+            ASSERT_EQ(3, sorted_result.size());
+            EXPECT_EQ("A", sorted_result[0].As<std::string>());
+            EXPECT_EQ("B", sorted_result[1].As<std::string>());
+            EXPECT_EQ("C", sorted_result[2].As<std::string>());
+        }
+
+        {
+            const auto sorted_result =
+                SortBsonValues(coll.Distinct("category", bson::MakeDoc("score", bson::MakeDoc("$gte", 80))));
+
+            ASSERT_EQ(2, sorted_result.size());
+            EXPECT_EQ("A", sorted_result[0].As<std::string>());
+            EXPECT_EQ("B", sorted_result[1].As<std::string>());
+        }
+
+        {
+            const auto sorted_result = SortBsonValues(coll.Distinct(
+                "category",
+                bson::MakeDoc(
+                    "$and",
+                    bson::MakeArray(bson::MakeDoc("status", "active"), bson::MakeDoc("score", bson::MakeDoc("$gt", 80)))
+                )
+            ));
+            ASSERT_EQ(2, sorted_result.size());
+            EXPECT_EQ("A", sorted_result[0].As<std::string>());
+            EXPECT_EQ("B", sorted_result[1].As<std::string>());
+        }
+
+        {
+            const auto result = coll.Distinct("category", bson::MakeDoc("status", "unknown"));
+            EXPECT_TRUE(result.empty());
+        }
+    }
+
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct_mixed");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "mixed_field", "string_value"),
+             bson::MakeDoc("_id", 2, "mixed_field", 42),
+             bson::MakeDoc("_id", 3, "mixed_field", 3.14),
+             bson::MakeDoc("_id", 4, "mixed_field", true),
+             bson::MakeDoc("_id", 5, "mixed_field", "string_value"),
+             bson::MakeDoc("_id", 6, "mixed_field", 42),
+             bson::MakeDoc("_id", 7),
+             bson::MakeDoc("_id", 8, "mixed_field", nullptr)}
+        );
+
+        const auto result = coll.Distinct("mixed_field");
+
+        EXPECT_GE(result.size(), 4);
+
+        bool has_string = false, has_int = false, has_double = false, has_bool = false;
+        for (const auto& value : result) {
+            if (value.IsString())
+                has_string = true;
+            else if (value.IsInt32())
+                has_int = true;
+            else if (value.IsDouble())
+                has_double = true;
+            else if (value.IsBool())
+                has_bool = true;
+        }
+
+        EXPECT_TRUE(has_string);
+        EXPECT_TRUE(has_int);
+        EXPECT_TRUE(has_double);
+        EXPECT_TRUE(has_bool);
+    }
+
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct_arrays");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "tags", bson::MakeArray("red", "blue")),
+             bson::MakeDoc("_id", 2, "tags", bson::MakeArray("green", "blue")),
+             bson::MakeDoc("_id", 3, "tags", bson::MakeArray("red", "yellow")),
+             bson::MakeDoc("_id", 4, "tags", bson::MakeArray("blue", "purple")),
+             bson::MakeDoc("_id", 5, "single_tag", "orange")}
+        );
+
+        const auto sorted_result = SortBsonValues(coll.Distinct("tags"));
+
+        ASSERT_EQ(5, sorted_result.size());
+        EXPECT_EQ("blue", sorted_result[0].As<std::string>());
+        EXPECT_EQ("green", sorted_result[1].As<std::string>());
+        EXPECT_EQ("purple", sorted_result[2].As<std::string>());
+        EXPECT_EQ("red", sorted_result[3].As<std::string>());
+        EXPECT_EQ("yellow", sorted_result[4].As<std::string>());
+
+        coll = GetDefaultPool().GetCollection("distinct_collation");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "name", "apple"),
+             bson::MakeDoc("_id", 2, "name", "Apple"),
+             bson::MakeDoc("_id", 3, "name", "APPLE"),
+             bson::MakeDoc("_id", 4, "name", "banana"),
+             bson::MakeDoc("_id", 5, "name", "Banana")}
+        );
+        {
+            const auto result = coll.Distinct("name");
+            EXPECT_EQ(5, result.size());
+        }
+
+        {
+            mongo::options::Collation collation("en");
+            collation.SetStrength(mongo::options::Collation::Strength::kPrimary);
+
+            const auto result = coll.Distinct("name", collation);
+            EXPECT_EQ(2, result.size());
+        }
+
+        {
+            mongo::options::Collation collation("en");
+            collation.SetStrength(mongo::options::Collation::Strength::kSecondary);
+
+            const auto result = coll.Distinct("name", collation);
+            EXPECT_GE(result.size(), 2);
+        }
+    }
+
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct_comment");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "type", "A"),
+             bson::MakeDoc("_id", 2, "type", "B"),
+             bson::MakeDoc("_id", 3, "type", "A")}
+        );
+
+        UEXPECT_NO_THROW({
+            const auto result = coll.Distinct("type", mongo::options::Comment("test distinct operation"));
+            EXPECT_EQ(2, result.size());
+        });
+    }
+
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct_timeout");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "category", "X"),
+             bson::MakeDoc("_id", 2, "category", "Y"),
+             bson::MakeDoc("_id", 3, "category", "X")}
+        );
+
+        UEXPECT_NO_THROW({
+            const auto result =
+                coll.Distinct("category", mongo::options::MaxServerTime(std::chrono::milliseconds(5000)));
+            EXPECT_EQ(2, result.size());
+        });
+    }
+
+    {
+        auto coll = GetDefaultPool().GetCollection("distinct_nested");
+
+        coll.InsertMany(
+            {bson::MakeDoc("_id", 1, "user", bson::MakeDoc("profile", bson::MakeDoc("role", "admin"))),
+             bson::MakeDoc("_id", 2, "user", bson::MakeDoc("profile", bson::MakeDoc("role", "user"))),
+             bson::MakeDoc("_id", 3, "user", bson::MakeDoc("profile", bson::MakeDoc("role", "admin"))),
+             bson::MakeDoc("_id", 4, "user", bson::MakeDoc("profile", bson::MakeDoc("role", "guest")))}
+        );
+
+        const auto sorted_result = SortBsonValues(coll.Distinct("user.profile.role"));
+
+        ASSERT_EQ(3, sorted_result.size());
+        EXPECT_EQ("admin", sorted_result[0].As<std::string>());
+        EXPECT_EQ("guest", sorted_result[1].As<std::string>());
+        EXPECT_EQ("user", sorted_result[2].As<std::string>());
+    }
+}
+
 USERVER_NAMESPACE_END
diff --git a/mongo/src/storages/mongo/congestion_control/sensor.cpp b/mongo/src/storages/mongo/congestion_control/sensor.cpp
index 3a69d21d8fde..f9d87895952f 100644
--- a/mongo/src/storages/mongo/congestion_control/sensor.cpp
+++ b/mongo/src/storages/mongo/congestion_control/sensor.cpp
@@ -2,6 +2,8 @@
 
 #include <algorithm>  // for std::max
 
+#include <userver/logging/log.hpp>
+
 #include <storages/mongo/pool_impl.hpp>
 
 USERVER_NAMESPACE_BEGIN
diff --git a/mongo/src/storages/mongo/operations.cpp b/mongo/src/storages/mongo/operations.cpp
index 86669ca002bd..9a409fae6416 100644
--- a/mongo/src/storages/mongo/operations.cpp
+++ b/mongo/src/storages/mongo/operations.cpp
@@ -286,7 +286,7 @@ void InsertOne::SetOption(options::SuppressServerExceptions) { impl_->should_thr
 
 InsertMany::InsertMany() = default;
 
-InsertMany::InsertMany(std::vector<formats::bson::Document> documents_) : impl_(std::move(documents_)) {}
+InsertMany::InsertMany(std::vector<formats::bson::Document> documents) : impl_(std::move(documents)) {}
 
 InsertMany::~InsertMany() = default;
 
@@ -568,6 +568,46 @@ void Drop::SetOption(const options::WriteConcern& write_concern) {
     AppendWriteConcern(impl::EnsureBuilder(impl_->options), write_concern);
 }
 
+ATTRIBUTE_NO_SANITIZE_UNDEFINED
+void AppendCollation(formats::bson::impl::BsonBuilder& builder, const options::Collation& collation) {
+    const bson_t* collation_bson = collation.GetCollationBson();
+    if (bson_empty0(collation_bson)) return;
+
+    static constexpr utils::StringLiteral kOptionName = "collation";
+    builder.Append(kOptionName, collation_bson);
+}
+
+Distinct::Distinct(std::string field) : impl_(std::move(field)) {}
+
+Distinct::Distinct(std::string field, formats::bson::Document filter) : impl_(std::move(field), std::move(filter)) {}
+
+Distinct::~Distinct() = default;
+
+Distinct::Distinct(const Distinct& other) = default;
+Distinct::Distinct(Distinct&&) noexcept = default;
+Distinct& Distinct::operator=(const Distinct& rhs) = default;
+Distinct& Distinct::operator=(Distinct&&) noexcept = default;
+
+void Distinct::SetOption(const options::ReadPreference& read_prefs) {
+    impl_->read_prefs = MakeCDriverReadPrefs(read_prefs);
+}
+
+void Distinct::SetOption(options::ReadPreference::Mode mode) { impl_->read_prefs = MakeCDriverReadPrefs(mode); }
+
+void Distinct::SetOption(options::ReadConcern level) { AppendReadConcern(impl::EnsureBuilder(impl_->options), level); }
+
+void Distinct::SetOption(const options::Collation& collation) {
+    AppendCollation(impl::EnsureBuilder(impl_->options), collation);
+}
+
+void Distinct::SetOption(const options::Comment& comment) {
+    AppendComment(impl::EnsureBuilder(impl_->options), impl_->has_comment_option, comment);
+}
+
+void Distinct::SetOption(const options::MaxServerTime& max_server_time) {
+    AppendMaxServerTime(impl_->max_server_time, max_server_time);
+}
+
 }  // namespace storages::mongo::operations
 
 USERVER_NAMESPACE_END
diff --git a/mongo/src/storages/mongo/operations_impl.hpp b/mongo/src/storages/mongo/operations_impl.hpp
index c5ae818037f8..7cfdfd8ebf84 100644
--- a/mongo/src/storages/mongo/operations_impl.hpp
+++ b/mongo/src/storages/mongo/operations_impl.hpp
@@ -26,7 +26,7 @@ stats::OpType ToStatsOpType(operations::Delete::Mode);
 
 class Count::Impl {
 public:
-    explicit Impl(formats::bson::Document filter_) : filter(std::move(filter_)) {}
+    explicit Impl(formats::bson::Document filter) : filter(std::move(filter)) {}
 
     formats::bson::Document filter;
     stats::OperationKey op_key{stats::OpType::kCount};
@@ -45,7 +45,7 @@ class CountApprox::Impl {
 
 class Find::Impl {
 public:
-    explicit Impl(formats::bson::Document filter_) : filter(std::move(filter_)) {}
+    explicit Impl(formats::bson::Document filter) : filter(std::move(filter)) {}
 
     formats::bson::Document filter;
     stats::OperationKey op_key{stats::OpType::kFind};
@@ -57,7 +57,7 @@ class Find::Impl {
 
 class InsertOne::Impl {
 public:
-    explicit Impl(formats::bson::Document&& document_) : document(std::move(document_)) {}
+    explicit Impl(formats::bson::Document&& document) : document(std::move(document)) {}
 
     formats::bson::Document document;
     stats::OperationKey op_key{stats::OpType::kInsertOne};
@@ -69,7 +69,7 @@ class InsertMany::Impl {
 public:
     Impl() = default;
 
-    explicit Impl(std::vector<formats::bson::Document>&& documents_) : documents(std::move(documents_)) {}
+    explicit Impl(std::vector<formats::bson::Document>&& documents) : documents(std::move(documents)) {}
 
     std::vector<formats::bson::Document> documents;
     stats::OperationKey op_key{stats::OpType::kInsertMany};
@@ -79,8 +79,8 @@ class InsertMany::Impl {
 
 class ReplaceOne::Impl {
 public:
-    Impl(formats::bson::Document&& selector_, formats::bson::Document&& replacement_)
-        : selector(std::move(selector_)), replacement(std::move(replacement_)) {}
+    Impl(formats::bson::Document&& selector, formats::bson::Document&& replacement)
+        : selector(std::move(selector)), replacement(std::move(replacement)) {}
 
     formats::bson::Document selector;
     formats::bson::Document replacement;
@@ -91,8 +91,8 @@ class ReplaceOne::Impl {
 
 class Update::Impl {
 public:
-    Impl(Mode mode_, formats::bson::Document&& selector_, formats::bson::Document update_)
-        : mode(mode_), selector(std::move(selector_)), update(std::move(update_)) {}
+    Impl(Mode mode, formats::bson::Document&& selector, formats::bson::Document update)
+        : mode(mode), selector(std::move(selector)), update(std::move(update)) {}
 
     Mode mode;
     bool should_throw{true};  // moved here for size optimization
@@ -105,7 +105,7 @@ class Update::Impl {
 
 class Delete::Impl {
 public:
-    Impl(Mode mode_, formats::bson::Document&& selector_) : mode(mode_), selector(std::move(selector_)) {}
+    Impl(Mode mode, formats::bson::Document&& selector) : mode(mode), selector(std::move(selector)) {}
 
     Mode mode;
     bool should_throw{true};  // moved here for size optimization
@@ -116,7 +116,7 @@ class Delete::Impl {
 
 class FindAndModify::Impl {
 public:
-    explicit Impl(formats::bson::Document&& query_) : query(std::move(query_)) {}
+    explicit Impl(formats::bson::Document&& query) : query(std::move(query)) {}
 
     formats::bson::Document query;
     stats::OperationKey op_key{stats::OpType::kFindAndModify};
@@ -127,7 +127,7 @@ class FindAndModify::Impl {
 
 class FindAndRemove::Impl {
 public:
-    explicit Impl(formats::bson::Document&& query_) : query(std::move(query_)) {}
+    explicit Impl(formats::bson::Document&& query) : query(std::move(query)) {}
 
     formats::bson::Document query;
     stats::OperationKey op_key{stats::OpType::kFindAndRemove};
@@ -137,7 +137,7 @@ class FindAndRemove::Impl {
 
 class Bulk::Impl {
 public:
-    explicit Impl(Mode mode_) : mode(mode_) {}
+    explicit Impl(Mode mode) : mode(mode) {}
 
     impl::cdriver::BulkOperationPtr bulk;
     stats::OperationKey op_key{stats::OpType::kBulk};
@@ -147,7 +147,7 @@ class Bulk::Impl {
 
 class Aggregate::Impl {
 public:
-    explicit Impl(formats::bson::Value pipeline_) : pipeline(std::move(pipeline_)) {}
+    explicit Impl(formats::bson::Value pipeline) : pipeline(std::move(pipeline)) {}
 
     formats::bson::Value pipeline;
     impl::cdriver::ReadPrefsPtr read_prefs;
@@ -157,6 +157,21 @@ class Aggregate::Impl {
     std::chrono::milliseconds max_server_time{kNoMaxServerTime};
 };
 
+class Distinct::Impl {
+public:
+    explicit Impl(std::string field) : field(std::move(field)) {}
+
+    Impl(std::string field, formats::bson::Document filter) : field(std::move(field)), filter(std::move(filter)) {}
+
+    std::string field;
+    std::optional<formats::bson::Document> filter;
+    stats::OperationKey op_key{stats::OpType::kDistinct};
+    impl::cdriver::ReadPrefsPtr read_prefs;
+    std::optional<formats::bson::impl::BsonBuilder> options;
+    bool has_comment_option{false};
+    std::chrono::milliseconds max_server_time{kNoMaxServerTime};
+};
+
 class Drop::Impl {
 public:
     Impl() = default;
diff --git a/mongo/src/storages/mongo/options.cpp b/mongo/src/storages/mongo/options.cpp
index 760fb4ced674..6e17728cae1d 100644
--- a/mongo/src/storages/mongo/options.cpp
+++ b/mongo/src/storages/mongo/options.cpp
@@ -144,6 +144,95 @@ Comment::Comment(std::string value) : value_(std::move(value)) {
 
 const std::string& Comment::Value() const { return value_; }
 
+Collation::Collation(std::string locale) { collation_builder_.Append("locale", std::move(locale)); }
+
+Collation& Collation::SetStrength(Strength strength) {
+    collation_builder_.Append("strength", static_cast<int>(strength));
+    return *this;
+}
+
+Collation& Collation::SetCaseLevel(bool case_level) {
+    collation_builder_.Append("caseLevel", case_level);
+    return *this;
+}
+
+Collation& Collation::SetCaseFirst(CaseFirst case_first) {
+    std::string case_first_str;
+
+    switch (case_first) {
+        case CaseFirst::kOff:
+            case_first_str = "off";
+            break;
+        case CaseFirst::kUpper:
+            case_first_str = "upper";
+            break;
+        case CaseFirst::kLower:
+            case_first_str = "lower";
+            break;
+        default:
+            throw InvalidQueryArgumentException(fmt::format("Invalid CaseFirst value {}", static_cast<int>(case_first))
+            );
+    }
+
+    collation_builder_.Append("caseFirst", case_first_str);
+    return *this;
+}
+
+Collation& Collation::SetNumericOrdering(bool numeric_ordering) {
+    collation_builder_.Append("numericOrdering", numeric_ordering);
+    return *this;
+}
+
+Collation& Collation::SetAlternate(Alternate alternate) {
+    std::string alternate_str;
+
+    switch (alternate) {
+        case Alternate::kNonIgnorable:
+            alternate_str = "non-ignorable";
+            break;
+        case Alternate::kShifted:
+            alternate_str = "shifted";
+            break;
+        default:
+            throw InvalidQueryArgumentException(fmt::format("Invalid Alternate value {}", static_cast<int>(alternate)));
+    }
+
+    collation_builder_.Append("alternate", alternate_str);
+    return *this;
+}
+
+Collation& Collation::SetMaxVariable(MaxVariable max_variable) {
+    std::string max_variable_str;
+
+    switch (max_variable) {
+        case MaxVariable::kPunct:
+            max_variable_str = "punct";
+            break;
+        case MaxVariable::kSpace:
+            max_variable_str = "space";
+            break;
+        default:
+            throw InvalidQueryArgumentException(
+                fmt::format("Invalid MaxVariable value {}", static_cast<int>(max_variable))
+            );
+    }
+
+    collation_builder_.Append("maxVariable", max_variable_str);
+    return *this;
+}
+
+Collation& Collation::SetBackwards(bool backwards) {
+    collation_builder_.Append("backwards", backwards);
+    return *this;
+}
+
+Collation& Collation::SetNormalization(bool normalization) {
+    collation_builder_.Append("normalization", normalization);
+    return *this;
+}
+
+const bson_t* Collation::GetCollationBson() const { return collation_builder_.Get(); }
+
 }  // namespace storages::mongo::options
 
 USERVER_NAMESPACE_END
diff --git a/mongo/src/storages/mongo/stats.cpp b/mongo/src/storages/mongo/stats.cpp
index b4e518d53396..085550ce0736 100644
--- a/mongo/src/storages/mongo/stats.cpp
+++ b/mongo/src/storages/mongo/stats.cpp
@@ -110,12 +110,16 @@ std::string_view ToString(OpType type) {
     switch (type) {
         case Type::kInvalid:
             UINVARIANT(false, "Unexpected OpType::kInvalid");
+            // Never reaches
+            return {};
         case Type::kCount:
             return "count";
         case Type::kCountApprox:
             return "count-approx";
         case Type::kFind:
             return "find";
+        case Type::kDistinct:
+            return "distinct";
         case Type::kInsertOne:
             return "insert-one";
         case Type::kInsertMany:
diff --git a/mongo/src/storages/mongo/stats.hpp b/mongo/src/storages/mongo/stats.hpp
index 95956d58ab52..022efa224ed4 100644
--- a/mongo/src/storages/mongo/stats.hpp
+++ b/mongo/src/storages/mongo/stats.hpp
@@ -72,6 +72,7 @@ enum class OpType {
     kCount = kReadMin,
     kCountApprox,
     kFind,
+    kDistinct,
     kAggregate,
 
     kWriteMin,
@@ -142,8 +143,8 @@ struct EventStats final {
 };
 
 struct ConnStats final {
-    EventStats event_stats_;  // per-connection
-    ApmStats* apm_stats_{nullptr};
+    EventStats event_stats;  // per-connection
+    ApmStats* apm_stats{nullptr};
 };
 
 struct PoolStatistics final {
diff --git a/mysql/CMakeLists.txt b/mysql/CMakeLists.txt
index be0eb8237b9c..80d237641559 100644
--- a/mysql/CMakeLists.txt
+++ b/mysql/CMakeLists.txt
@@ -14,6 +14,7 @@ userver_module(
     UBENCH_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/benchmarks"
     UBENCH_LINK_LIBRARIES libmariadb
     UBENCH_DATABASES mysql
+    DEPENDS core
 )
 
 if(USERVER_MYSQL_ALLOW_BUGGY_LIBMARIADB)
diff --git a/mysql/include/userver/storages/mysql/convert.hpp b/mysql/include/userver/storages/mysql/convert.hpp
index 19caee7baf60..d8fb52f199e7 100644
--- a/mysql/include/userver/storages/mysql/convert.hpp
+++ b/mysql/include/userver/storages/mysql/convert.hpp
@@ -18,7 +18,7 @@ template <typename T, typename DbType>
 using HasConvert = decltype(Convert(std::declval<DbType&&>(), convert::To<T>{}));
 
 template <typename T, typename DbType>
-inline constexpr bool kHasConvert = meta::kIsDetected<HasConvert, T, DbType>;
+inline constexpr bool kHasConvert = meta::IsDetected<HasConvert, T, DbType>;
 
 }  // namespace impl
 
diff --git a/mysql/include/userver/storages/mysql/transaction.hpp b/mysql/include/userver/storages/mysql/transaction.hpp
index dc68e3066005..69e15f8ee77e 100644
--- a/mysql/include/userver/storages/mysql/transaction.hpp
+++ b/mysql/include/userver/storages/mysql/transaction.hpp
@@ -4,6 +4,7 @@
 
 #include <userver/tracing/span.hpp>
 #include <userver/utils/fast_pimpl.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 #include <userver/storages/mysql/cluster_host_type.hpp>
 #include <userver/storages/mysql/command_result_set.hpp>
@@ -103,6 +104,7 @@ class Transaction final {
     utils::FastPimpl<infra::ConnectionPtr, 24, 8> connection_;
     engine::Deadline deadline_;
     tracing::Span span_;
+    utils::trx_tracker::TransactionLock trx_lock_;
 };
 
 template <typename... Args>
diff --git a/mysql/src/storages/mysql/transaction.cpp b/mysql/src/storages/mysql/transaction.cpp
index 6dfcd2b49f96..d40c03bb8577 100644
--- a/mysql/src/storages/mysql/transaction.cpp
+++ b/mysql/src/storages/mysql/transaction.cpp
@@ -12,6 +12,7 @@ namespace storages::mysql {
 Transaction::Transaction(infra::ConnectionPtr&& connection, engine::Deadline deadline)
     : connection_{std::move(connection)}, deadline_{deadline}, span_{impl::tracing::kTransactionSpan} {
     (*connection_)->ExecuteQuery("BEGIN", deadline);
+    trx_lock_.Lock();
 }
 
 Transaction::Transaction(Transaction&& other) noexcept = default;
@@ -32,6 +33,7 @@ void Transaction::Commit() {
         auto connection = std::move(connection_);
         (*connection)->Commit(deadline_);
     }
+    trx_lock_.Unlock();
 }
 
 void Transaction::Rollback() {
@@ -40,6 +42,7 @@ void Transaction::Rollback() {
         auto connection = std::move(connection_);
         (*connection)->Rollback(deadline_);
     }
+    trx_lock_.Unlock();
 }
 
 StatementResultSet Transaction::DoExecute(const Query& query, impl::io::ParamsBinderBase& params) const {
diff --git a/odbc/CMakeLists.txt b/odbc/CMakeLists.txt
index 25ebdc71d0b4..9692472cfeec 100644
--- a/odbc/CMakeLists.txt
+++ b/odbc/CMakeLists.txt
@@ -8,6 +8,7 @@ userver_module(
     UTEST_LINK_LIBRARIES odbc
     DBTEST_DATABASES postgresql
     DBTEST_ENV POSTGRES_TEST_DSN=postgresql://testsuite@localhost:15433/postgres
+    DEPENDS core
 )
 
 _userver_directory_install(
diff --git a/odbc/include/userver/storages/odbc/field.hpp b/odbc/include/userver/storages/odbc/field.hpp
index 989d46a37148..1e4db70a3bb7 100644
--- a/odbc/include/userver/storages/odbc/field.hpp
+++ b/odbc/include/userver/storages/odbc/field.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstdint>
+
 #include <userver/storages/odbc/odbc_fwd.hpp>
 
 USERVER_NAMESPACE_BEGIN
diff --git a/odbc/include/userver/storages/odbc/settings.hpp b/odbc/include/userver/storages/odbc/settings.hpp
index 50290168437d..b88955411532 100644
--- a/odbc/include/userver/storages/odbc/settings.hpp
+++ b/odbc/include/userver/storages/odbc/settings.hpp
@@ -8,8 +8,8 @@ USERVER_NAMESPACE_BEGIN
 namespace storages::odbc::settings {
 
 struct PoolSettings final {
-    std::size_t minSize{5};
-    std::size_t maxSize{10};
+    std::size_t min_size{5};
+    std::size_t max_size{10};
 };
 
 struct HostSettings final {
diff --git a/odbc/src/storages/odbc/detail/cluster_impl.cpp b/odbc/src/storages/odbc/detail/cluster_impl.cpp
index 2c46031fd8f5..9a7fb54d0651 100644
--- a/odbc/src/storages/odbc/detail/cluster_impl.cpp
+++ b/odbc/src/storages/odbc/detail/cluster_impl.cpp
@@ -11,7 +11,7 @@ namespace storages::odbc::detail {
 
 ClusterImpl::ClusterImpl(const settings::ODBCClusterSettings& settings) {
     for (const auto& host : settings.pools) {
-        pools_.push_back(std::make_shared<Pool>(host.dsn, host.pool.minSize, host.pool.maxSize));
+        pools_.push_back(std::make_shared<Pool>(host.dsn, host.pool.min_size, host.pool.max_size));
     }
 }
 
diff --git a/odbc/src/storages/odbc/detail/result_wrapper.cpp b/odbc/src/storages/odbc/detail/result_wrapper.cpp
index 5bdf34968b51..dfa3db090b97 100644
--- a/odbc/src/storages/odbc/detail/result_wrapper.cpp
+++ b/odbc/src/storages/odbc/detail/result_wrapper.cpp
@@ -40,29 +40,29 @@ ResultWrapper::ResultHandle MakeResultHandle(SQLHDBC handle) {
     return resultHandle;
 }
 
-ResultWrapper::ResultWrapper(ResultHandle&& res) : handle_{std::move(res)} {}
+ResultWrapper::ResultWrapper(ResultHandle&& res) : handle{std::move(res)} {}
 ResultWrapper::~ResultWrapper() = default;
 
 ResultWrapper::ResultWrapper(ResultWrapper&& other) noexcept = default;
 
 SQLRETURN ResultWrapper::GetStatus() const {
-    SQLRETURN ret = SQLMoreResults(handle_.get());
+    SQLRETURN ret = SQLMoreResults(handle.get());
     return ret;
 }
 
-void ResultWrapper::Fetch() { CheckStatus(SQLFetch(handle_.get()), handle_.get(), SQL_HANDLE_STMT); }
+void ResultWrapper::Fetch() { CheckStatus(SQLFetch(handle.get()), handle.get(), SQL_HANDLE_STMT); }
 
 std::size_t ResultWrapper::RowCount() const {
     // TODO: drivers may return -1 or 0 if rows are not fetched yet, overall implementation for select is
     // driver-dependent, needs checking
     SQLLEN rowCount = 0;
-    CheckStatus(SQLRowCount(handle_.get(), &rowCount), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLRowCount(handle.get(), &rowCount), handle.get(), SQL_HANDLE_STMT);
     return static_cast<std::size_t>(rowCount);
 }
 
 std::size_t ResultWrapper::FieldCount() const {
     SQLSMALLINT fieldCount = 0;
-    CheckStatus(SQLNumResultCols(handle_.get(), &fieldCount), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLNumResultCols(handle.get(), &fieldCount), handle.get(), SQL_HANDLE_STMT);
     return static_cast<std::size_t>(fieldCount);
 }
 
@@ -72,8 +72,8 @@ std::string ResultWrapper::GetFieldName(std::size_t col) const {
     SQLCHAR name[1024];
     SQLLEN name_len = sizeof(name);
     CheckStatus(
-        SQLDescribeCol(handle_.get(), col + 1, name, sizeof(name), nullptr, nullptr, nullptr, nullptr, nullptr),
-        handle_.get(),
+        SQLDescribeCol(handle.get(), col + 1, name, sizeof(name), nullptr, nullptr, nullptr, nullptr, nullptr),
+        handle.get(),
         SQL_HANDLE_STMT
     );
     return std::string(reinterpret_cast<char*>(name), name_len);
@@ -82,8 +82,8 @@ std::string ResultWrapper::GetFieldName(std::size_t col) const {
 SQLSMALLINT ResultWrapper::GetColumnType(std::size_t col) const {
     SQLSMALLINT type = 0;
     CheckStatus(
-        SQLDescribeCol(handle_.get(), col + 1, nullptr, 0, nullptr, &type, nullptr, nullptr, nullptr),
-        handle_.get(),
+        SQLDescribeCol(handle.get(), col + 1, nullptr, 0, nullptr, &type, nullptr, nullptr, nullptr),
+        handle.get(),
         SQL_HANDLE_STMT
     );
     return type;
@@ -96,11 +96,11 @@ std::string ResultWrapper::GetString(std::size_t row, std::size_t col) const {
         throw ResultSetError(fmt::format("Type mismatch: column {} is not a string type (SQL type: {})", col + 1, type)
         );
     }
-    CheckStatus(SQLFetchScroll(handle_.get(), SQL_FETCH_ABSOLUTE, row + 1), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLFetchScroll(handle.get(), SQL_FETCH_ABSOLUTE, row + 1), handle.get(), SQL_HANDLE_STMT);
     SQLCHAR value[1024];
     SQLLEN valueLen = sizeof(value);
     CheckStatus(
-        SQLGetData(handle_.get(), col + 1, SQL_C_CHAR, value, sizeof(value), &valueLen), handle_.get(), SQL_HANDLE_STMT
+        SQLGetData(handle.get(), col + 1, SQL_C_CHAR, value, sizeof(value), &valueLen), handle.get(), SQL_HANDLE_STMT
     );
     return std::string(reinterpret_cast<char*>(value), valueLen);
 }
@@ -110,9 +110,9 @@ std::int32_t ResultWrapper::GetInt32(std::size_t row, std::size_t col) const {
     if (type != SQL_INTEGER && type != SQL_SMALLINT && type != SQL_TINYINT) {
         throw ResultSetError(fmt::format("Type mismatch: column {} is not an int32 type (SQL type: {})", col, type));
     }
-    CheckStatus(SQLFetchScroll(handle_.get(), SQL_FETCH_ABSOLUTE, row + 1), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLFetchScroll(handle.get(), SQL_FETCH_ABSOLUTE, row + 1), handle.get(), SQL_HANDLE_STMT);
     SQLINTEGER value = 0;
-    CheckStatus(SQLGetData(handle_.get(), col + 1, SQL_C_SLONG, &value, 0, nullptr), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLGetData(handle.get(), col + 1, SQL_C_SLONG, &value, 0, nullptr), handle.get(), SQL_HANDLE_STMT);
     return static_cast<std::int32_t>(value);
 }
 
@@ -121,9 +121,9 @@ std::int64_t ResultWrapper::GetInt64(std::size_t row, std::size_t col) const {
     if (type != SQL_BIGINT) {
         throw ResultSetError(fmt::format("Type mismatch: column {} is not an int64 type (SQL type: {})", col, type));
     }
-    CheckStatus(SQLFetchScroll(handle_.get(), SQL_FETCH_ABSOLUTE, row + 1), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLFetchScroll(handle.get(), SQL_FETCH_ABSOLUTE, row + 1), handle.get(), SQL_HANDLE_STMT);
     SQLBIGINT value = 0;
-    CheckStatus(SQLGetData(handle_.get(), col + 1, SQL_C_SBIGINT, &value, 0, nullptr), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLGetData(handle.get(), col + 1, SQL_C_SBIGINT, &value, 0, nullptr), handle.get(), SQL_HANDLE_STMT);
     return static_cast<std::int64_t>(value);
 }
 
@@ -134,30 +134,28 @@ double ResultWrapper::GetDouble(std::size_t row, std::size_t col) const {
             fmt::format("Type mismatch: column {} is not a floating-point type (SQL type: {})", col, type)
         );
     }
-    CheckStatus(SQLFetchScroll(handle_.get(), SQL_FETCH_ABSOLUTE, row + 1), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLFetchScroll(handle.get(), SQL_FETCH_ABSOLUTE, row + 1), handle.get(), SQL_HANDLE_STMT);
     SQLDOUBLE value = 0;
-    CheckStatus(SQLGetData(handle_.get(), col + 1, SQL_C_DOUBLE, &value, 0, nullptr), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLGetData(handle.get(), col + 1, SQL_C_DOUBLE, &value, 0, nullptr), handle.get(), SQL_HANDLE_STMT);
     return static_cast<double>(value);
 }
 
 bool ResultWrapper::GetBool(std::size_t row, std::size_t col) const {
     // NOTE: typecheck for bools omitted, since drivers may handle bools differently, but always support SQL_C_BIT
-    CheckStatus(SQLFetchScroll(handle_.get(), SQL_FETCH_ABSOLUTE, row + 1), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLFetchScroll(handle.get(), SQL_FETCH_ABSOLUTE, row + 1), handle.get(), SQL_HANDLE_STMT);
     bool value = false;
     CheckStatus(
-        SQLGetData(handle_.get(), col + 1, SQL_C_BIT, &value, sizeof(value), nullptr), handle_.get(), SQL_HANDLE_STMT
+        SQLGetData(handle.get(), col + 1, SQL_C_BIT, &value, sizeof(value), nullptr), handle.get(), SQL_HANDLE_STMT
     );
     return value;
 }
 
 bool ResultWrapper::IsFieldNull(std::size_t row, std::size_t col) const {
-    CheckStatus(SQLFetchScroll(handle_.get(), SQL_FETCH_ABSOLUTE, row + 1), handle_.get(), SQL_HANDLE_STMT);
+    CheckStatus(SQLFetchScroll(handle.get(), SQL_FETCH_ABSOLUTE, row + 1), handle.get(), SQL_HANDLE_STMT);
     SQLLEN marker = 0;
     bool dummy = false;  // NOTE: odbc requires a buffer for SQL_C_DEFAULT
     CheckStatus(
-        SQLGetData(handle_.get(), col + 1, SQL_C_DEFAULT, &dummy, sizeof(dummy), &marker),
-        handle_.get(),
-        SQL_HANDLE_STMT
+        SQLGetData(handle.get(), col + 1, SQL_C_DEFAULT, &dummy, sizeof(dummy), &marker), handle.get(), SQL_HANDLE_STMT
     );
     return marker == SQL_NULL_DATA;
 }
diff --git a/odbc/src/storages/odbc/detail/result_wrapper.hpp b/odbc/src/storages/odbc/detail/result_wrapper.hpp
index 50515c269649..3c51bbea8b95 100644
--- a/odbc/src/storages/odbc/detail/result_wrapper.hpp
+++ b/odbc/src/storages/odbc/detail/result_wrapper.hpp
@@ -42,7 +42,7 @@ class ResultWrapper {
 
     bool IsFieldNull(std::size_t row, std::size_t col) const;
 
-    ResultHandle handle_;
+    ResultHandle handle;
 };
 
 ResultWrapper::ResultHandle MakeResultHandle(SQLHDBC);
diff --git a/otlp/CMakeLists.txt b/otlp/CMakeLists.txt
index 598eac75caf4..875ad6abf2a8 100644
--- a/otlp/CMakeLists.txt
+++ b/otlp/CMakeLists.txt
@@ -9,6 +9,7 @@ userver_module(
     LINK_LIBRARIES userver-otlp-proto
     UTEST_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests"
     UTEST_LINK_LIBRARIES userver-grpc-utest
+    DEPENDS grpc
 )
 
 _userver_install_targets(COMPONENT otlp TARGETS userver-otlp-proto)
diff --git a/otlp/include/userver/otlp/logs/component.hpp b/otlp/include/userver/otlp/logs/component.hpp
index 45763f055425..c074ee2dc7fa 100644
--- a/otlp/include/userver/otlp/logs/component.hpp
+++ b/otlp/include/userver/otlp/logs/component.hpp
@@ -26,7 +26,9 @@ class Logger;
 /// ## Static options:
 /// Name | Description | Default value
 /// ---- | ----------- | -------------
-/// endpoint | URI of otel collector (e.g. 127.0.0.1:4317) | -
+/// endpoint | URI of otel collector (e.g. 127.0.0.1:4317). This endpoint is used both for logs and traces. If you want separate endpoints, then use below options. | -
+/// logs-endpoint | URI of otel collector (gRPC). This endpoint is used only for logs. | -
+/// tracing-endpoint | URI of otel collector (gRPC). This endpoint is used only for traces. | -
 /// client-factory-name | Name of the grpc client factory | -
 /// max-queue-size | Maximum async queue size | 65535
 /// max-batch-delay | Maximum batch delay | 100ms
@@ -44,6 +46,8 @@ class Logger;
 // clang-format on
 class LoggerComponent final : public components::RawComponentBase {
 public:
+    /// @ingroup userver_component_names
+    /// @brief The default name of otlp::LoggerComponent
     static constexpr std::string_view kName = "otlp-logger";
 
     LoggerComponent(const components::ComponentConfig&, const components::ComponentContext&);
diff --git a/otlp/src/otlp/logs/component.cpp b/otlp/src/otlp/logs/component.cpp
index 534f77320445..70932d319c05 100644
--- a/otlp/src/otlp/logs/component.cpp
+++ b/otlp/src/otlp/logs/component.cpp
@@ -30,13 +30,37 @@ LoggerComponent::LoggerComponent(const components::ComponentConfig& config, cons
     auto& client_factory =
         context.FindComponent<ugrpc::client::ClientFactoryComponent>(client_factory_name).GetFactory();
 
-    auto endpoint = config["endpoint"].As<std::string>();
+    std::string logs_endpoint;
+    std::string tracing_endpoint;
+
+    auto endpoint_cfg = config["endpoint"];
+    auto logs_endpoint_cfg = config["logs-endpoint"];
+    auto tracing_endpoint_cfg = config["tracing-endpoint"];
+
+    auto is_present = [](auto&& x) { return !(x.IsMissing() || x.IsNull()); };
+
+    if (is_present(endpoint_cfg)) {
+        // we have one endpoint
+        if (is_present(logs_endpoint_cfg)) {
+            throw std::runtime_error(R"("endpoint" option is incompatible with "logs-endpoint")");
+        }
+        if (is_present(tracing_endpoint_cfg)) {
+            throw std::runtime_error(R"("endpoint" option is incompatible with "tracing-endpoint")");
+        }
+
+        logs_endpoint = endpoint_cfg.As<std::string>();
+        tracing_endpoint = endpoint_cfg.As<std::string>();
+    } else {
+        logs_endpoint = logs_endpoint_cfg.As<std::string>();
+        tracing_endpoint = tracing_endpoint_cfg.As<std::string>();
+    }
+
     auto client = client_factory.MakeClient<opentelemetry::proto::collector::logs::v1::LogsServiceClient>(
-        "otlp-logger", endpoint
+        "otlp-logger", logs_endpoint
     );
 
     auto trace_client = client_factory.MakeClient<opentelemetry::proto::collector::trace::v1::TraceServiceClient>(
-        "otlp-tracer", endpoint
+        "otlp-tracer", tracing_endpoint
     );
 
     LoggerConfig logger_config;
@@ -112,7 +136,22 @@ additionalProperties: false
     endpoint:
         type: string
         description: >
-            Hostname:port of otel collector (gRPC).
+            Hostname:port of otel collector (gRPC). This endpoint is used
+            both for logs and traces. If you want separate endpoints, then
+            use "logs-endpoint" and "tracing-endpoint" members.
+            Please note that "endpoint" is mutually exclusive with either
+            "logs-endpoint" or "tracing-endpoint". Basically, you either have
+            one endpoint for both, or you specify directly what goes where.
+    logs-endpoint:
+        type: string
+        description: >
+            Hostname:port of otel collector (gRPC). This endpoint is used
+            only for logs.
+    tracing-endpoint:
+        type: string
+        description: >
+            Hostname:port of otel collector (gRPC). This endpoint is used
+            only for traces.
     client-factory-name:
         type: string
         description: >
diff --git a/otlp/src/otlp/logs/logger.cpp b/otlp/src/otlp/logs/logger.cpp
index 8857e4c8cdda..61c6fee98554 100644
--- a/otlp/src/otlp/logs/logger.cpp
+++ b/otlp/src/otlp/logs/logger.cpp
@@ -227,10 +227,10 @@ void Logger::Stop() noexcept {
 const logging::impl::LogStatistics& Logger::GetStatistics() const { return stats_; }
 
 void Logger::PrependCommonTags(logging::impl::TagWriter writer) const {
-    logging::impl::default_::PrependCommonTags(writer, GetLevel());
+    logging::impl::PrependCommonTags(writer, GetLevel());
 }
 
-bool Logger::DoShouldLog(logging::Level level) const noexcept { return logging::impl::default_::DoShouldLog(level); }
+bool Logger::DoShouldLog(logging::Level level) const noexcept { return logging::impl::DoShouldLog(level); }
 
 void Logger::Log(logging::Level level, logging::impl::formatters::LoggerItemRef item) {
     UASSERT(dynamic_cast<Item*>(&item));
diff --git a/postgresql/CMakeLists.txt b/postgresql/CMakeLists.txt
index 651a9479ab24..0468a6bada62 100644
--- a/postgresql/CMakeLists.txt
+++ b/postgresql/CMakeLists.txt
@@ -48,6 +48,7 @@ userver_module(
     UBENCH_LINK_LIBRARIES userver-libpq
     UBENCH_DATABASES postgresql
     UBENCH_ENV POSTGRES_DSN_BENCH=postgresql://testsuite@localhost:15433/postgres
+    DEPENDS core
     GENERATE_DYNAMIC_CONFIGS
 )
 
diff --git a/postgresql/dynamic_configs/POSTGRES_CONNECTION_POOL_SETTINGS.yaml b/postgresql/dynamic_configs/POSTGRES_CONNECTION_POOL_SETTINGS.yaml
index c2e98cd85ff1..52c25570e691 100644
--- a/postgresql/dynamic_configs/POSTGRES_CONNECTION_POOL_SETTINGS.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_CONNECTION_POOL_SETTINGS.yaml
@@ -2,8 +2,8 @@ default: {}
 description: |
     Dynamic config that controls connection pool settings of PostgreSQL driver.
 
-    Dictionary keys can be either the service **component name** (not database name!)
-    or `__default__`. The latter configuration is applied for every non-matching
+    Dictionary keys can be either the value of `name_alias` static configuration option of the PostgreSQL component
+    (**not database name!**) or `__default__`. The latter configuration is applied for every non-matching
     PostgreSQL component of the service.
 
     Take note that it overrides the static configuration values of the service!
@@ -41,19 +41,30 @@ schema:
                     minimum: 0
                     default: 4
                     x-usrv-cpp-type: std::size_t
+                    description: |
+                        Number of connections created initially by PostgreSQL component instance to each of the provided
+                        PostgreSQL hosts. Connections are kept even without requests.
                 max_pool_size:
                     type: integer
                     minimum: 1
                     default: 15
                     x-usrv-cpp-type: std::size_t
+                    description: |
+                        Maximum number of connections that can be created by PostgreSQL component instance to each of
+                        the provided hosts for "connlimit_mode: manual". Should not be less than `min_pool_size`.
                 max_queue_size:
                     type: integer
                     minimum: 1
                     default: 200
+                    description: |
+                        Maximum number of clients waiting for a connection. Exception is thrown if a new request
+                        exceeds this limit.
                 connecting_limit:
                     type: integer
                     minimum: 0
                     default: 0
+                    description: |
+                        Limit for concurrent establishing connections number per PostgreSQL host (0 - unlimited).
             required:
               - min_pool_size
               - max_pool_size
diff --git a/postgresql/dynamic_configs/POSTGRES_CONNECTION_SETTINGS.yaml b/postgresql/dynamic_configs/POSTGRES_CONNECTION_SETTINGS.yaml
index e86f925ca333..2b168f88c05d 100644
--- a/postgresql/dynamic_configs/POSTGRES_CONNECTION_SETTINGS.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_CONNECTION_SETTINGS.yaml
@@ -3,8 +3,8 @@ description: |
     Dynamic config that controls settings for newly created connections of
     PostgreSQL driver.
 
-    Dictionary keys can be either the service **component name** (not database name!)
-    or `__default__`. The latter configuration is applied for every non-matching
+    Dictionary keys can be either the value of `name_alias` static configuration option of the PostgreSQL component
+    (**not database name!**) or `__default__`. The latter configuration is applied for every non-matching
     PostgreSQL component of the service.
 
     Take note that it overrides the static configuration values of the service!
diff --git a/postgresql/dynamic_configs/POSTGRES_DEFAULT_COMMAND_CONTROL.yaml b/postgresql/dynamic_configs/POSTGRES_DEFAULT_COMMAND_CONTROL.yaml
index e9b6b4d3f82c..8447ae56e9c5 100644
--- a/postgresql/dynamic_configs/POSTGRES_DEFAULT_COMMAND_CONTROL.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_DEFAULT_COMMAND_CONTROL.yaml
@@ -14,3 +14,5 @@ schema:
         statement_timeout_ms:
             type: integer
             minimum: 1
+        prepared_statements_enabled:
+            type: boolean
diff --git a/postgresql/dynamic_configs/POSTGRES_HANDLERS_COMMAND_CONTROL.yaml b/postgresql/dynamic_configs/POSTGRES_HANDLERS_COMMAND_CONTROL.yaml
index 9141daef934e..649cf96edf9a 100644
--- a/postgresql/dynamic_configs/POSTGRES_HANDLERS_COMMAND_CONTROL.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_HANDLERS_COMMAND_CONTROL.yaml
@@ -24,3 +24,5 @@ schema:
                 statement_timeout_ms:
                     type: integer
                     minimum: 1
+                prepared_statements_enabled:
+                    type: boolean
diff --git a/postgresql/dynamic_configs/POSTGRES_QUERIES_COMMAND_CONTROL.yaml b/postgresql/dynamic_configs/POSTGRES_QUERIES_COMMAND_CONTROL.yaml
index 87ac79413fd1..f0944bb3e958 100644
--- a/postgresql/dynamic_configs/POSTGRES_QUERIES_COMMAND_CONTROL.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_QUERIES_COMMAND_CONTROL.yaml
@@ -32,3 +32,5 @@ schema:
                 statement_timeout_ms:
                     type: integer
                     minimum: 1
+                prepared_statements_enabled:
+                    type: boolean
diff --git a/postgresql/dynamic_configs/POSTGRES_STATEMENT_METRICS_SETTINGS.yaml b/postgresql/dynamic_configs/POSTGRES_STATEMENT_METRICS_SETTINGS.yaml
index 2b2f13a67361..1a8f5c51f3df 100644
--- a/postgresql/dynamic_configs/POSTGRES_STATEMENT_METRICS_SETTINGS.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_STATEMENT_METRICS_SETTINGS.yaml
@@ -2,8 +2,8 @@ default: {}
 description: |
     Dynamic config that controls statement metrics settings for specific service.
 
-    Dictionary keys can be either the service **component name** (not database name!)
-    or `__default__`. The latter configuration is applied for every non-matching
+    Dictionary keys can be either the value of `name_alias` static configuration option of the PostgreSQL component
+    (**not database name!**) or `__default__`. The latter configuration is applied for every non-matching
     PostgreSQL component of the service.
 
     The value of `max_statement_metrics` controls the maximum size of LRU-cache
diff --git a/postgresql/dynamic_configs/POSTGRES_TOPOLOGY_SETTINGS.yaml b/postgresql/dynamic_configs/POSTGRES_TOPOLOGY_SETTINGS.yaml
index e9aba2d9c0b7..05f8dbc7ce44 100644
--- a/postgresql/dynamic_configs/POSTGRES_TOPOLOGY_SETTINGS.yaml
+++ b/postgresql/dynamic_configs/POSTGRES_TOPOLOGY_SETTINGS.yaml
@@ -3,8 +3,8 @@ description: |
     Dynamic config that controls topology settings of service's PostgreSQL
     components.
 
-    Dictionary keys can be either the service **component name** (not database name!)
-    or `__default__`. The latter configuration is applied for every non-matching
+    Dictionary keys can be either the value of `name_alias` static configuration option of the PostgreSQL component
+    (**not database name!**) or `__default__`. The latter configuration is applied for every non-matching
     PostgreSQL component of the service.
 
     Take note that it overrides the static configuration values of the service!
@@ -32,9 +32,13 @@ schema:
                 max_replication_lag_ms:
                     type: integer
                     minimum: 0
+                    description: |
+                        Replication lag limit in milliseconds for usable replicas. If a replica's lag exceeds this
+                        value, it stops receiving new requests.
                 disabled_replicas:
                     type: array
                     x-taxi-cpp-type: std::unordered_set
+                    description: List of force disabled replicas (FQDN).
                     items:
                         type: string
             required:
diff --git a/postgresql/include/userver/cache/base_postgres_cache.hpp b/postgresql/include/userver/cache/base_postgres_cache.hpp
index 5e4a603308c5..8096e8dca87a 100644
--- a/postgresql/include/userver/cache/base_postgres_cache.hpp
+++ b/postgresql/include/userver/cache/base_postgres_cache.hpp
@@ -101,6 +101,10 @@ namespace components {
 ///
 /// In case one provides a custom CacheContainer within Policy, it is notified
 /// of Update completion via its public member function OnWritesDone, if any.
+/// Custom CacheContainer must provide size method and insert_or_assign method
+/// similar to std::unordered_map's one or CacheInsertOrAssign function similar
+/// to one defined in namespace utils::impl::projected_set (i.e. used for
+/// utils::ProjectedUnorderedSet).
 /// See the following code snippet for an example of usage:
 ///
 /// @snippet cache/postgres_cache_test.cpp Pg Cache Policy Custom Container With Write Notification Example
@@ -126,12 +130,12 @@ namespace pg_cache::detail {
 template <typename T>
 using ValueType = typename T::ValueType;
 template <typename T>
-inline constexpr bool kHasValueType = meta::kIsDetected<ValueType, T>;
+inline constexpr bool kHasValueType = meta::IsDetected<ValueType, T>;
 
 template <typename T>
 using RawValueTypeImpl = typename T::RawValueType;
 template <typename T>
-inline constexpr bool kHasRawValueType = meta::kIsDetected<RawValueTypeImpl, T>;
+inline constexpr bool kHasRawValueType = meta::IsDetected<RawValueTypeImpl, T>;
 template <typename T>
 using RawValueType = meta::DetectedOr<ValueType<T>, RawValueTypeImpl, T>;
 
@@ -148,51 +152,78 @@ auto ExtractValue(RawValueType<PostgreCachePolicy>&& raw) {
 template <typename T>
 using HasNameImpl = std::enable_if_t<!std::string_view{T::kName}.empty()>;
 template <typename T>
-inline constexpr bool kHasName = meta::kIsDetected<HasNameImpl, T>;
+inline constexpr bool kHasName = meta::IsDetected<HasNameImpl, T>;
 
 // Component query in policy
 template <typename T>
 using HasQueryImpl = decltype(T::kQuery);
 template <typename T>
-inline constexpr bool kHasQuery = meta::kIsDetected<HasQueryImpl, T>;
+inline constexpr bool kHasQuery = meta::IsDetected<HasQueryImpl, T>;
 
 // Component GetQuery in policy
 template <typename T>
 using HasGetQueryImpl = decltype(T::GetQuery());
 template <typename T>
-inline constexpr bool kHasGetQuery = meta::kIsDetected<HasGetQueryImpl, T>;
+inline constexpr bool kHasGetQuery = meta::IsDetected<HasGetQueryImpl, T>;
 
 // Component kWhere in policy
 template <typename T>
 using HasWhere = decltype(T::kWhere);
 template <typename T>
-inline constexpr bool kHasWhere = meta::kIsDetected<HasWhere, T>;
+inline constexpr bool kHasWhere = meta::IsDetected<HasWhere, T>;
 
 // Component kOrderBy in policy
 template <typename T>
 using HasOrderBy = decltype(T::kOrderBy);
 template <typename T>
-inline constexpr bool kHasOrderBy = meta::kIsDetected<HasOrderBy, T>;
+inline constexpr bool kHasOrderBy = meta::IsDetected<HasOrderBy, T>;
 
 // Update field
 template <typename T>
 using HasUpdatedField = decltype(T::kUpdatedField);
 template <typename T>
-inline constexpr bool kHasUpdatedField = meta::kIsDetected<HasUpdatedField, T>;
+inline constexpr bool kHasUpdatedField = meta::IsDetected<HasUpdatedField, T>;
 
 template <typename T>
 using WantIncrementalUpdates = std::enable_if_t<!std::string_view{T::kUpdatedField}.empty()>;
 template <typename T>
-inline constexpr bool kWantIncrementalUpdates = meta::kIsDetected<WantIncrementalUpdates, T>;
+inline constexpr bool kWantIncrementalUpdates = meta::IsDetected<WantIncrementalUpdates, T>;
 
 // Key member in policy
 template <typename T>
 using KeyMemberTypeImpl = std::decay_t<std::invoke_result_t<decltype(T::kKeyMember), ValueType<T>>>;
 template <typename T>
-inline constexpr bool kHasKeyMember = meta::kIsDetected<KeyMemberTypeImpl, T>;
+inline constexpr bool kHasKeyMember = meta::IsDetected<KeyMemberTypeImpl, T>;
 template <typename T>
 using KeyMemberType = meta::DetectedType<KeyMemberTypeImpl, T>;
 
+// size method in custom container in policy
+template <typename T>
+using SizeMethodInvokeResultImpl = decltype(std::declval<T>().size());
+template <typename T>
+inline constexpr bool kHasSizeMethod = meta::IsDetected<SizeMethodInvokeResultImpl, T> &&
+                                       std::is_convertible_v<SizeMethodInvokeResultImpl<T>, std::size_t>;
+
+// insert_or_assign method in custom container in policy
+template <typename T>
+using InsertOrAssignMethodInvokeResultImpl = decltype(std::declval<typename T::CacheContainer>().insert_or_assign(
+    std::declval<KeyMemberTypeImpl<T>>(),
+    std::declval<ValueType<T>>()
+));
+template <typename T>
+inline constexpr bool kHasInsertOrAssignMethod = meta::IsDetected<InsertOrAssignMethodInvokeResultImpl, T>;
+
+// CacheInsertOrAssign function for custom container in policy
+template <typename T>
+using CacheInsertOrAssignFunctionInvokeResultImpl = decltype(CacheInsertOrAssign(
+    std::declval<typename T::CacheContainer&>(),
+    std::declval<ValueType<T>>(),
+    std::declval<KeyMemberTypeImpl<T>>()
+));
+template <typename T>
+inline constexpr bool kHasCacheInsertOrAssignFunction =
+    meta::IsDetected<CacheInsertOrAssignFunctionInvokeResultImpl, T>;
+
 // Data container for cache
 template <typename T, typename = USERVER_NAMESPACE::utils::void_t<>>
 struct DataCacheContainer {
@@ -206,6 +237,13 @@ struct DataCacheContainer {
 
 template <typename T>
 struct DataCacheContainer<T, USERVER_NAMESPACE::utils::void_t<typename T::CacheContainer>> {
+    static_assert(kHasSizeMethod<typename T::CacheContainer>, "Custom CacheContainer must provide `size` method");
+    static_assert(
+        kHasInsertOrAssignMethod<T> || kHasCacheInsertOrAssignFunction<T>,
+        "Custom CacheContainer must provide `insert_or_assign`  method similar to std::unordered_map's "
+        "one or CacheInsertOrAssign function"
+    );
+
     using type = typename T::CacheContainer;
 };
 
@@ -252,7 +290,7 @@ using HasOnWritesDoneImpl = decltype(std::declval<T&>().OnWritesDone());
 
 template <typename T>
 void OnWritesDone(T& container) {
-    if constexpr (meta::kIsDetected<HasOnWritesDoneImpl, T>) {
+    if constexpr (meta::IsDetected<HasOnWritesDoneImpl, T>) {
         container.OnWritesDone();
     }
 }
@@ -261,12 +299,12 @@ template <typename T>
 using HasCustomUpdatedImpl = decltype(T::GetLastKnownUpdated(std::declval<DataCacheContainerType<T>>()));
 
 template <typename T>
-inline constexpr bool kHasCustomUpdated = meta::kIsDetected<HasCustomUpdatedImpl, T>;
+inline constexpr bool kHasCustomUpdated = meta::IsDetected<HasCustomUpdatedImpl, T>;
 
 template <typename T>
 using UpdatedFieldTypeImpl = typename T::UpdatedFieldType;
 template <typename T>
-inline constexpr bool kHasUpdatedFieldType = meta::kIsDetected<UpdatedFieldTypeImpl, T>;
+inline constexpr bool kHasUpdatedFieldType = meta::IsDetected<UpdatedFieldTypeImpl, T>;
 template <typename T>
 using UpdatedFieldType = meta::DetectedOr<storages::postgres::TimePointTz, UpdatedFieldTypeImpl, T>;
 
@@ -307,7 +345,7 @@ using HasClusterHostTypeImpl = decltype(T::kClusterHostType);
 
 template <typename T>
 constexpr storages::postgres::ClusterHostTypeFlags ClusterHostType() {
-    if constexpr (meta::kIsDetected<HasClusterHostTypeImpl, T>) {
+    if constexpr (meta::IsDetected<HasClusterHostTypeImpl, T>) {
         return T::kClusterHostType;
     } else {
         return storages::postgres::ClusterHostType::kSlave;
@@ -320,7 +358,7 @@ using HasMayReturnNull = decltype(T::kMayReturnNull);
 
 template <typename T>
 constexpr bool MayReturnNull() {
-    if constexpr (meta::kIsDetected<HasMayReturnNull, T>) {
+    if constexpr (meta::IsDetected<HasMayReturnNull, T>) {
         return T::kMayReturnNull;
     } else {
         return false;
diff --git a/postgresql/include/userver/storages/postgres/component.hpp b/postgresql/include/userver/storages/postgres/component.hpp
index 54d7cd7c689f..cfa9c980a1f0 100644
--- a/postgresql/include/userver/storages/postgres/component.hpp
+++ b/postgresql/include/userver/storages/postgres/component.hpp
@@ -124,7 +124,7 @@ namespace components {
 /// name_alias              | name alias to use in dynamic configs                                          | name of the component
 /// dbconnection            | connection DSN string (used if no dbalias specified)                          | --
 /// blocking_task_processor | name of task processor for background blocking operations                     | engine::current_task::GetBlockingTaskProcessor()
-/// max_replication_lag     | replication lag limit for usable slaves                                       | 60s
+/// max_replication_lag     | replication lag limit for usable replicas. If a replica's lag exceeds this value, it stops receiving new requests | 60s
 /// sync-start              | perform initial connections synchronously                                     | true
 /// dns_resolver            | server hostname resolver type (getaddrinfo or async)                          | 'async'
 /// persistent-prepared-statements | cache prepared statements or not                                       | true
@@ -134,11 +134,11 @@ namespace components {
 /// monitoring-dbalias      | name of the database for monitorings                                          | calculated from dbalias or dbconnection options
 /// max_prepared_cache_size | prepared statements cache size limit                                          | 200
 /// max_statement_metrics   | limit of exported metrics for named statements                                | 0
-/// min_pool_size           | number of connections created initially                                       | 4
-/// max_pool_size           | maximum number of created connections for "connlimit_mode: manual"            | 15
-/// max_queue_size          | maximum number of clients waiting for a connection                            | 200
-/// connecting_limit        | limit for concurrent establishing connections number per pool (0 - unlimited) | 0
-/// connlimit_mode          | max_connections setup mode (manual or auto), also see @ref scripts/docs/en/userver/pg_connlimit_mode_auto.md | auto
+/// min_pool_size           | number of connections created initially by this component instance to each of the provided PostgreSQL hosts. Connections are kept even without requests | 4
+/// max_pool_size           | maximum number of connections that can be created by this component instance to each of the provided hosts for "connlimit_mode: manual". Should not be less than `min_pool_size` | 15
+/// max_queue_size          | maximum number of clients waiting for a connection. storages::postgres::PoolError is thrown if a new request exceeds this limit.                        | 200
+/// connecting_limit        | limit for concurrent establishing connections number per PostgreSQL host (0 - unlimited)                                                                | 0
+/// connlimit_mode          | max_connections setup mode (manual or auto), also see @ref scripts/docs/en/userver/pg_connlimit_mode_auto.md                                            | auto
 /// error-injection         | artificial error injection settings, error_injection::Settings                | --
 /// deadline-propagation-enabled | whether deadline propagation sets statement timeout                      | true
 
diff --git a/postgresql/include/userver/storages/postgres/detail/const_data_iterator.hpp b/postgresql/include/userver/storages/postgres/detail/const_data_iterator.hpp
index 1d0a52ceacea..b24c5963fcda 100644
--- a/postgresql/include/userver/storages/postgres/detail/const_data_iterator.hpp
+++ b/postgresql/include/userver/storages/postgres/detail/const_data_iterator.hpp
@@ -16,7 +16,7 @@ namespace storages::postgres::detail {
 /// Compare(...)
 /// Distance(...)
 /// Valid()
-template <typename FinalType, typename DataType, IteratorDirection direction = IteratorDirection::kForward>
+template <typename FinalType, typename DataType, IteratorDirection Direction = IteratorDirection::kForward>
 class ConstDataIterator : protected DataType {
     using Iter = ConstDataIterator;
 
@@ -70,9 +70,9 @@ class ConstDataIterator : protected DataType {
         return res;
     }
 
-    difference_type operator-(const FinalType& rhs) const { return this->Distance(rhs) * static_cast<int>(direction); }
+    difference_type operator-(const FinalType& rhs) const { return this->Distance(rhs) * static_cast<int>(Direction); }
 
-    FinalType operator[](difference_type index) const { return *this + index * static_cast<int>(direction); }
+    FinalType operator[](difference_type index) const { return *this + index * static_cast<int>(Direction); }
 
     FinalType& operator+=(difference_type distance) { return DoAdvance(distance); }
     FinalType& operator-=(difference_type distance) { return DoAdvance(-distance); }
@@ -97,7 +97,7 @@ class ConstDataIterator : protected DataType {
     const FinalType& Rebind() const { return static_cast<const FinalType&>(*this); }
 
     FinalType& DoAdvance(difference_type distance) {
-        this->Advance(distance * static_cast<int>(direction));
+        this->Advance(distance * static_cast<int>(Direction));
         return Rebind();
     }
     int DoCompare(const Iter& rhs) const { return this->Compare(rhs); }
diff --git a/postgresql/include/userver/storages/postgres/detail/query_parameters.hpp b/postgresql/include/userver/storages/postgres/detail/query_parameters.hpp
index 9fe891df2efc..39f3a5c1b5b4 100644
--- a/postgresql/include/userver/storages/postgres/detail/query_parameters.hpp
+++ b/postgresql/include/userver/storages/postgres/detail/query_parameters.hpp
@@ -54,10 +54,10 @@ class StaticQueryParameters {
     StaticQueryParameters& operator=(StaticQueryParameters&&) = delete;
 
     std::size_t Size() const { return ParamsCount; }
-    const char* const* ParamBuffers() const { return param_buffers; }
-    const Oid* ParamTypesBuffer() const { return param_types; }
-    const int* ParamLengthsBuffer() const { return param_lengths; }
-    const int* ParamFormatsBuffer() const { return param_formats; }
+    const char* const* ParamBuffers() const { return param_buffers_; }
+    const Oid* ParamTypesBuffer() const { return param_types_; }
+    const int* ParamLengthsBuffer() const { return param_lengths_; }
+    const int* ParamFormatsBuffer() const { return param_formats_; }
 
     template <typename T>
     void Write(std::size_t index, const UserTypes& types, const T& arg) {
@@ -67,9 +67,11 @@ class StaticQueryParameters {
             "Type doesn't have mapping to Postgres type. "
             "Enums should be either streamed as their underlying value via the "
             "`template<> struct CanUseEnumAsStrongTypedef<T>: std::true_type {};` "
-            "specialization or as a PostgreSQL datatype via the "
+            "specialization, or as a PostgreSQL datatype via the "
             "`template<> struct CppToUserPg<T> : EnumMappingBase<R> { ... };` "
-            "specialization. "
+            "specialization, or for enums with Parse() and ToString() functions, use "
+            "`template<> struct CppToSystemPg<T> : PredefinedOid<PredefinedOids::kText> {};` "
+            "specialization for automatic mapping to PostgreSQL text type. "
             "See page `uPg: Supported data types` for more information."
         );
         WriteParamType(index, types, arg);
@@ -86,16 +88,16 @@ class StaticQueryParameters {
     template <typename T>
     void WriteParamType(std::size_t index, const UserTypes& types, const T&) {
         // C++ to pg oid mapping
-        param_types[index] = io::CppToPg<T>::GetOid(types);
+        param_types_[index] = io::CppToPg<T>::GetOid(types);
     }
 
     template <typename T>
     void WriteNullable(std::size_t index, const UserTypes& types, const T& arg, std::true_type) {
         using NullDetector = io::traits::GetSetNull<T>;
         if (NullDetector::IsNull(arg)) {
-            param_formats[index] = io::kPgBinaryDataFormat;
-            param_lengths[index] = io::kPgNullBufferSize;
-            param_buffers[index] = nullptr;
+            param_formats_[index] = io::kPgBinaryDataFormat;
+            param_lengths_[index] = io::kPgNullBufferSize;
+            param_buffers_[index] = nullptr;
         } else {
             WriteNullable(index, types, arg, std::false_type{});
         }
@@ -103,15 +105,15 @@ class StaticQueryParameters {
 
     template <typename T>
     void WriteNullable(std::size_t index, const UserTypes& types, const T& arg, std::false_type) {
-        param_formats[index] = io::kPgBinaryDataFormat;
-        auto& buffer = parameters[index];
+        param_formats_[index] = io::kPgBinaryDataFormat;
+        auto& buffer = parameters_[index];
         io::WriteBuffer(types, buffer, arg);
         auto size = buffer.size();
-        param_lengths[index] = size;
+        param_lengths_[index] = size;
         if (size == 0) {
-            param_buffers[index] = empty_buffer;
+            param_buffers_[index] = empty_buffer;
         } else {
-            param_buffers[index] = buffer.data();
+            param_buffers_[index] = buffer.data();
         }
     }
 
@@ -122,11 +124,11 @@ class StaticQueryParameters {
 
     static constexpr const char* empty_buffer = "";
 
-    ParameterList parameters{};
-    OidList param_types{};
-    const char* param_buffers[ParamsCount]{};
-    IntList param_lengths{};
-    IntList param_formats{};
+    ParameterList parameters_{};
+    OidList param_types_{};
+    const char* param_buffers_[ParamsCount]{};
+    IntList param_lengths_{};
+    IntList param_formats_{};
 };
 
 template <>
@@ -149,11 +151,11 @@ class DynamicQueryParameters {
     DynamicQueryParameters& operator=(const DynamicQueryParameters&) = delete;
     DynamicQueryParameters& operator=(DynamicQueryParameters&&) = default;
 
-    std::size_t Size() const { return param_types.size(); }
-    const char* const* ParamBuffers() const { return param_buffers.data(); }
-    const Oid* ParamTypesBuffer() const { return param_types.data(); }
-    const int* ParamLengthsBuffer() const { return param_lengths.data(); }
-    const int* ParamFormatsBuffer() const { return param_formats.data(); }
+    std::size_t Size() const { return param_types_.size(); }
+    const char* const* ParamBuffers() const { return param_buffers_.data(); }
+    const Oid* ParamTypesBuffer() const { return param_types_.data(); }
+    const int* ParamLengthsBuffer() const { return param_lengths_.data(); }
+    const int* ParamFormatsBuffer() const { return param_formats_.data(); }
 
     template <typename T>
     void Write(const UserTypes& types, const T& arg) {
@@ -171,16 +173,16 @@ class DynamicQueryParameters {
     template <typename T>
     void WriteParamType(const UserTypes& types, const T&) {
         // C++ to pg oid mapping
-        param_types.push_back(io::CppToPg<T>::GetOid(types));
+        param_types_.push_back(io::CppToPg<T>::GetOid(types));
     }
 
     template <typename T>
     void WriteNullable(const UserTypes& types, const T& arg, std::true_type) {
         using NullDetector = io::traits::GetSetNull<T>;
         if (NullDetector::IsNull(arg)) {
-            param_formats.push_back(io::kPgBinaryDataFormat);
-            param_lengths.push_back(io::kPgNullBufferSize);
-            param_buffers.push_back(nullptr);
+            param_formats_.push_back(io::kPgBinaryDataFormat);
+            param_lengths_.push_back(io::kPgNullBufferSize);
+            param_buffers_.push_back(nullptr);
         } else {
             WriteNullable(types, arg, std::false_type{});
         }
@@ -188,15 +190,15 @@ class DynamicQueryParameters {
 
     template <typename T>
     void WriteNullable(const UserTypes& types, const T& arg, std::false_type) {
-        param_formats.push_back(io::kPgBinaryDataFormat);
-        auto& buffer = parameters.emplace_back();
+        param_formats_.push_back(io::kPgBinaryDataFormat);
+        auto& buffer = parameters_.emplace_back();
         io::WriteBuffer(types, buffer, arg);
         auto size = buffer.size();
-        param_lengths.push_back(size);
+        param_lengths_.push_back(size);
         if (size == 0) {
-            param_buffers.push_back(empty_buffer);
+            param_buffers_.push_back(empty_buffer);
         } else {
-            param_buffers.push_back(buffer.data());
+            param_buffers_.push_back(buffer.data());
         }
     }
 
@@ -207,11 +209,11 @@ class DynamicQueryParameters {
 
     static constexpr const char* empty_buffer = "";
 
-    ParameterList parameters;  // TODO Replace with a single buffer
-    OidList param_types;
-    std::vector<const char*> param_buffers;
-    IntList param_lengths;
-    IntList param_formats;
+    ParameterList parameters_;  // TODO Replace with a single buffer
+    OidList param_types_;
+    std::vector<const char*> param_buffers_;
+    IntList param_lengths_;
+    IntList param_formats_;
 };
 
 }  // namespace storages::postgres::detail
diff --git a/postgresql/include/userver/storages/postgres/detail/typed_rows.hpp b/postgresql/include/userver/storages/postgres/detail/typed_rows.hpp
index 7883ddf50b83..3f98f4fdcea1 100644
--- a/postgresql/include/userver/storages/postgres/detail/typed_rows.hpp
+++ b/postgresql/include/userver/storages/postgres/detail/typed_rows.hpp
@@ -15,7 +15,7 @@ class TypedResultSet;
 
 namespace detail {
 
-template <typename T, typename ExtractionTag, IteratorDirection direction = IteratorDirection::kForward>
+template <typename T, typename ExtractionTag, IteratorDirection Direction = IteratorDirection::kForward>
 class ConstTypedRowIterator : private Row {
 public:
     //@{
@@ -71,11 +71,11 @@ class ConstTypedRowIterator : private Row {
     }
 
     difference_type operator-(const ConstTypedRowIterator& rhs) const {
-        return this->Distance(rhs) * static_cast<int>(direction);
+        return this->Distance(rhs) * static_cast<int>(Direction);
     }
 
     ConstTypedRowIterator operator[](difference_type index) const {
-        return *this + index * static_cast<int>(direction);
+        return *this + index * static_cast<int>(Direction);
     }
 
     ConstTypedRowIterator& operator+=(difference_type distance) { return DoAdvance(distance); }
@@ -98,7 +98,7 @@ class ConstTypedRowIterator : private Row {
 
     ConstTypedRowIterator(detail::ResultWrapperPtr res, size_type row) : Row{std::move(res), row} {}
     ConstTypedRowIterator& DoAdvance(difference_type distance) {
-        this->Advance(distance * static_cast<int>(direction));
+        this->Advance(distance * static_cast<int>(Direction));
         return *this;
     }
 };
diff --git a/postgresql/include/userver/storages/postgres/io/array_types.hpp b/postgresql/include/userver/storages/postgres/io/array_types.hpp
index b676fe97519f..d73426d35fd7 100644
--- a/postgresql/include/userver/storages/postgres/io/array_types.hpp
+++ b/postgresql/include/userver/storages/postgres/io/array_types.hpp
@@ -205,8 +205,8 @@ struct ArrayBinaryParser : BufferParserBase<Container> {
         return std::inserter(value, value.end());
     }
 
-    template <typename T, std::size_t n>
-    auto GetInserter(std::array<T, n>& array) {
+    template <typename T, std::size_t N>
+    auto GetInserter(std::array<T, N>& array) {
         return array.begin();
     }
 
diff --git a/postgresql/include/userver/storages/postgres/io/bitstring.hpp b/postgresql/include/userver/storages/postgres/io/bitstring.hpp
index 9e9d88769646..e3a28e42c1c6 100644
--- a/postgresql/include/userver/storages/postgres/io/bitstring.hpp
+++ b/postgresql/include/userver/storages/postgres/io/bitstring.hpp
@@ -296,17 +296,17 @@ struct BufferFormatter<std::bitset<N>> : detail::BufferFormatterBase<std::bitset
     }
 };
 
-template <typename BitContainer, postgres::detail::BitContainerInterface kContainerInterface>
+template <typename BitContainer, postgres::detail::BitContainerInterface ContainerInterface>
 struct CppToSystemPg<
-    postgres::detail::BitStringRefWrapper<BitContainer, kContainerInterface, postgres::BitStringType::kBitVarying>>
+    postgres::detail::BitStringRefWrapper<BitContainer, ContainerInterface, postgres::BitStringType::kBitVarying>>
     : PredefinedOid<PredefinedOids::kVarbit> {};
 template <typename BitContainer>
 struct CppToSystemPg<postgres::BitStringWrapper<BitContainer, postgres::BitStringType::kBitVarying>>
     : PredefinedOid<PredefinedOids::kVarbit> {};
 
-template <typename BitContainer, postgres::detail::BitContainerInterface kContainerInterface>
+template <typename BitContainer, postgres::detail::BitContainerInterface ContainerInterface>
 struct CppToSystemPg<
-    postgres::detail::BitStringRefWrapper<BitContainer, kContainerInterface, postgres::BitStringType::kBit>>
+    postgres::detail::BitStringRefWrapper<BitContainer, ContainerInterface, postgres::BitStringType::kBit>>
     : PredefinedOid<PredefinedOids::kBit> {};
 template <typename BitContainer>
 struct CppToSystemPg<postgres::BitStringWrapper<BitContainer, postgres::BitStringType::kBit>>
diff --git a/postgresql/include/userver/storages/postgres/io/enum_types.hpp b/postgresql/include/userver/storages/postgres/io/enum_types.hpp
index f92c29405e7b..6ce39f613d2c 100644
--- a/postgresql/include/userver/storages/postgres/io/enum_types.hpp
+++ b/postgresql/include/userver/storages/postgres/io/enum_types.hpp
@@ -10,6 +10,7 @@
 #include <userver/storages/postgres/io/buffer_io.hpp>
 #include <userver/storages/postgres/io/buffer_io_base.hpp>
 #include <userver/storages/postgres/io/pg_types.hpp>
+#include <userver/storages/postgres/io/transform_io.hpp>
 #include <userver/storages/postgres/io/type_mapping.hpp>
 #include <userver/storages/postgres/io/user_types.hpp>
 #include <userver/utils/trivial_map_fwd.hpp>
@@ -205,12 +206,41 @@ struct EnumFormatter : BufferFormatterBase<Enum> {
     }
 };
 
+template <typename Enum>
+struct EnumConverter {
+    using PostgresType = std::string;
+    using UserType = Enum;
+
+    Enum operator()(const PostgresType& db_data) const { return Parse(db_data, formats::parse::To<Enum>()); }
+
+    PostgresType operator()(const Enum& user_data) const { return ToString(user_data); }
+};
+
+template <typename>
+auto HasParseImpl(...) -> std::false_type;
+
+template <typename Enum>
+auto HasParseImpl(int)
+    -> decltype(Parse(std::declval<std::string_view>(), std::declval<formats::parse::To<Enum>>()), std::true_type{});
+
+template <typename Enum>
+struct HasParse : decltype(storages::postgres::io::detail::HasParseImpl<Enum>(0)) {};
+
+template <typename>
+auto HasToStringImpl(...) -> std::false_type;
+
+template <typename Enum>
+auto HasToStringImpl(int) -> decltype(ToString(std::declval<Enum>()), std::true_type{});
+
+template <typename Enum>
+struct HasToString : decltype(storages::postgres::io::detail::HasToStringImpl<Enum>(0)) {};
+
 }  // namespace detail
 
 namespace traits {
 
 template <typename T>
-struct Input<T, std::enable_if_t<!detail::kCustomParserDefined<T> && std::is_enum<T>() && IsMappedToUserType<T>()>> {
+struct Input<T, std::enable_if_t<std::is_enum<T>() && !detail::kCustomParserDefined<T> && IsMappedToUserType<T>()>> {
     using type = io::detail::EnumParser<T>;
 };
 
@@ -221,10 +251,34 @@ struct ParserBufferCategory<io::detail::EnumParser<T>>
 template <typename T>
 struct Output<
     T,
-    std::enable_if_t<!detail::kCustomFormatterDefined<T> && std::is_enum<T>() && IsMappedToUserType<T>()>> {
+    std::enable_if_t<std::is_enum<T>() && !detail::kCustomFormatterDefined<T> && IsMappedToUserType<T>()>> {
     using type = io::detail::EnumFormatter<T>;
 };
 
+// Specialization for enum parsing using ToString function
+// Allows C++ enums to be stored as PostgreSQL text when they have ToString support
+// but are not mapped to a specific PostgreSQL enum type via CppToUserPg
+template <typename Enum>
+struct Input<
+    Enum,
+    std::enable_if_t<
+        std::is_enum<Enum>() && !detail::kCustomParserDefined<Enum> && !IsMappedToUserType<Enum>() &&
+        storages::postgres::io::detail::HasToString<Enum>::value>> {
+    using type = TransformParser<Enum, std::string, storages::postgres::io::detail::EnumConverter<Enum>>;
+};
+
+// Specialization for enum formatting using Parse functions
+// Allows C++ enums to be converted from PostgreSQL text when they have Parse support
+// but are not mapped to a specific PostgreSQL enum type via CppToUserPg
+template <typename Enum>
+struct Output<
+    Enum,
+    std::enable_if_t<
+        std::is_enum<Enum>() && !detail::kCustomFormatterDefined<Enum> && !IsMappedToUserType<Enum>() &&
+        storages::postgres::io::detail::HasParse<Enum>::value>> {
+    using type = TransformFormatter<Enum, std::string, storages::postgres::io::detail::EnumConverter<Enum>>;
+};
+
 }  // namespace traits
 
 }  // namespace storages::postgres::io
diff --git a/postgresql/include/userver/storages/postgres/io/range_types.hpp b/postgresql/include/userver/storages/postgres/io/range_types.hpp
index e35a53c2288d..7b953c9b6df8 100644
--- a/postgresql/include/userver/storages/postgres/io/range_types.hpp
+++ b/postgresql/include/userver/storages/postgres/io/range_types.hpp
@@ -50,7 +50,7 @@ class Range {
     Range() = default;
 
     /// Unbounded range
-    Range(UnboundedType, UnboundedType) noexcept : data{RangeData{}} {}
+    Range(UnboundedType, UnboundedType) noexcept : data_{RangeData{}} {}
 
     /// Bounded range
     template <typename U, typename = std::enable_if_t<std::is_convertible_v<std::decay_t<U>, T>>>
@@ -76,32 +76,32 @@ class Range {
 
     bool operator!=(const Range& rhs) const { return !(*this == rhs); }
 
-    bool Empty() const { return !data; }
+    bool Empty() const { return !data_; }
 
     /// Make the range empty
-    void Clear() { data.reset(); }
+    void Clear() { data_.reset(); }
 
-    bool HasLowerBound() const { return !!data && data->HasBound(RangeBound::kLower); }
-    bool HasUpperBound() const { return !!data && data->HasBound(RangeBound::kUpper); }
+    bool HasLowerBound() const { return !!data_ && data_->HasBound(RangeBound::kLower); }
+    bool HasUpperBound() const { return !!data_ && data_->HasBound(RangeBound::kUpper); }
 
     /// Get the lower bound.
     const OptionalValue& GetLowerBound() const {
-        if (!!data) {
-            return data->GetOptionalValue(RangeBound::kLower);
+        if (!!data_) {
+            return data_->GetOptionalValue(RangeBound::kLower);
         }
         return kNoValue;
     }
 
     /// Get the upper bound.
     const OptionalValue& GetUpperBound() const {
-        if (!!data) {
-            return data->GetOptionalValue(RangeBound::kUpper);
+        if (!!data_) {
+            return data_->GetOptionalValue(RangeBound::kUpper);
         }
         return kNoValue;
     }
 
-    bool IsLowerBoundIncluded() const { return !!data && data->IsBoundIncluded(RangeBound::kLower); }
-    bool IsUpperBoundIncluded() const { return !!data && data->IsBoundIncluded(RangeBound::kUpper); }
+    bool IsLowerBoundIncluded() const { return !!data_ && data_->IsBoundIncluded(RangeBound::kLower); }
+    bool IsUpperBoundIncluded() const { return !!data_ && data_->IsBoundIncluded(RangeBound::kUpper); }
 
 private:
     template <typename U>
@@ -168,11 +168,11 @@ class Range {
 
     template <typename U>
     static std::optional<RangeData> ConvertData(const Range<U>& rhs) {
-        if (!rhs.data) return {};
-        return RangeData{ConvertBound(rhs.data->lower), ConvertBound(rhs.data->upper), rhs.data->bounds};
+        if (!rhs.data_) return {};
+        return RangeData{ConvertBound(rhs.data_->lower), ConvertBound(rhs.data_->upper), rhs.data_->bounds};
     }
 
-    std::optional<RangeData> data;
+    std::optional<RangeData> data_;
 
     static const inline OptionalValue kNoValue{};
 };
@@ -418,34 +418,34 @@ namespace storages::postgres {
 template <typename T>
 template <typename U, typename>
 Range<T>::Range(U&& lower, U&& upper, RangeBounds bounds)
-    : data{RangeData{std::forward<U>(lower), std::forward<U>(upper), bounds}} {
+    : data_{RangeData{std::forward<U>(lower), std::forward<U>(upper), bounds}} {
     if (lower == upper && bounds != RangeBound::kBoth) {
         // this will make an empty range
-        data.reset();
+        data_.reset();
     }
 }
 
 template <typename T>
 template <typename U, typename>
 Range<T>::Range(U&& lower, UnboundedType ub, RangeBounds bounds) noexcept(kNothrowValueCopy)
-    : data{RangeData{std::forward<U>(lower), ub, bounds}} {}
+    : data_{RangeData{std::forward<U>(lower), ub, bounds}} {}
 
 template <typename T>
 template <typename U, typename>
 Range<T>::Range(UnboundedType ub, U&& upper, RangeBounds bounds) noexcept(kNothrowValueCopy)
-    : data{RangeData{ub, std::forward<U>(upper), bounds}} {}
+    : data_{RangeData{ub, std::forward<U>(upper), bounds}} {}
 
 template <typename T>
 Range<T>::Range(const OptionalValue& lower, const OptionalValue& upper, RangeBounds bounds)
-    : data{RangeData{lower, upper, bounds}} {}
+    : data_{RangeData{lower, upper, bounds}} {}
 
 template <typename T>
 template <typename U, typename>
-Range<T>::Range(const Range<U>& rhs) : data{ConvertData(rhs)} {}
+Range<T>::Range(const Range<U>& rhs) : data_{ConvertData(rhs)} {}
 
 template <typename T>
 bool Range<T>::operator==(const Range& rhs) const {
-    return (Empty() && rhs.Empty()) || (data == rhs.data);
+    return (Empty() && rhs.Empty()) || (data_ == rhs.data_);
 }
 
 template <typename T>
diff --git a/postgresql/include/userver/storages/postgres/io/type_mapping.hpp b/postgresql/include/userver/storages/postgres/io/type_mapping.hpp
index 4194b1d3fae7..e7aed5630d48 100644
--- a/postgresql/include/userver/storages/postgres/io/type_mapping.hpp
+++ b/postgresql/include/userver/storages/postgres/io/type_mapping.hpp
@@ -17,7 +17,7 @@ namespace storages::postgres::io {
 template <typename T, typename Enable = USERVER_NAMESPACE::utils::void_t<>>
 struct CppToPg;
 
-template <PredefinedOids oid, typename T>
+template <PredefinedOids Oid, typename T>
 struct PgToCpp;
 
 /// Find out if a parser for a predefined Postgres type was registered.
diff --git a/postgresql/include/userver/storages/postgres/io/type_traits.hpp b/postgresql/include/userver/storages/postgres/io/type_traits.hpp
index 6b965f34138e..2d43f053d2be 100644
--- a/postgresql/include/userver/storages/postgres/io/type_traits.hpp
+++ b/postgresql/include/userver/storages/postgres/io/type_traits.hpp
@@ -58,13 +58,13 @@ template <typename T>
 using HasOutputOperator = decltype(std::declval<std::ostream&>() << std::declval<T&>());
 
 template <typename T>
-inline constexpr bool kHasOutputOperator = meta::kIsDetected<HasOutputOperator, T>;
+inline constexpr bool kHasOutputOperator = meta::IsDetected<HasOutputOperator, T>;
 
 template <typename T>
 using HasInputOperator = decltype(std::declval<std::istream&>() >> std::declval<T&>());
 
 template <typename T>
-inline constexpr bool kHasInputOperator = meta::kIsDetected<HasInputOperator, T>;
+inline constexpr bool kHasInputOperator = meta::IsDetected<HasInputOperator, T>;
 ///@}
 
 ///@{
diff --git a/postgresql/include/userver/storages/postgres/notify.hpp b/postgresql/include/userver/storages/postgres/notify.hpp
index 74c2c8d627bb..95cb6186ea1c 100644
--- a/postgresql/include/userver/storages/postgres/notify.hpp
+++ b/postgresql/include/userver/storages/postgres/notify.hpp
@@ -3,6 +3,7 @@
 /// @file userver/storages/postgres/notify.hpp
 /// @brief Asynchronous notifications
 
+#include <userver/engine/deadline.hpp>
 #include <userver/storages/postgres/options.hpp>
 #include <userver/utils/fast_pimpl.hpp>
 
diff --git a/postgresql/include/userver/storages/postgres/options.hpp b/postgresql/include/userver/storages/postgres/options.hpp
index aec71b13d6a1..c046156ceefe 100644
--- a/postgresql/include/userver/storages/postgres/options.hpp
+++ b/postgresql/include/userver/storages/postgres/options.hpp
@@ -9,6 +9,7 @@
 #include <optional>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 
 #include <userver/congestion_control/controllers/linear.hpp>
 #include <userver/storages/postgres/postgres_fwd.hpp>
diff --git a/postgresql/include/userver/storages/postgres/transaction.hpp b/postgresql/include/userver/storages/postgres/transaction.hpp
index 4abec256e34e..ee9a55f99214 100644
--- a/postgresql/include/userver/storages/postgres/transaction.hpp
+++ b/postgresql/include/userver/storages/postgres/transaction.hpp
@@ -15,6 +15,7 @@
 #include <userver/storages/postgres/postgres_fwd.hpp>
 #include <userver/storages/postgres/query.hpp>
 #include <userver/storages/postgres/result_set.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -406,6 +407,7 @@ class Transaction {
 
     std::string name_;
     detail::ConnectionPtr conn_;
+    USERVER_NAMESPACE::utils::trx_tracker::TransactionLock trx_lock_;
 };
 
 template <typename Container>
diff --git a/postgresql/pq-extra/pq_workaround.h b/postgresql/pq-extra/pq_workaround.h
index 5b2ca1878277..1653861c9e2f 100644
--- a/postgresql/pq-extra/pq_workaround.h
+++ b/postgresql/pq-extra/pq_workaround.h
@@ -18,10 +18,10 @@ extern int PQXisBusy(PGconn* conn, const PGresult* description);
 /// for prepared statements. The description doesn't change, hence no need to do
 /// that unconditionally. See
 /// https://www.postgresql.org/message-id/82c438b4-d91c-9009-65fc-593124d5a277%40yandex.ru
-extern int PQXsendQueryPrepared(PGconn* conn, const char* stmtName, int nParams,
-                                const char* const* paramValues,
-                                const int* paramLengths,
-                                const int* paramFormats, int resultFormat,
+extern int PQXsendQueryPrepared(PGconn* conn, const char* stmt_name, int n_params,
+                                const char* const* param_values,
+                                const int* param_lengths,
+                                const int* param_formats, int result_format,
                                 PGresult* description);
 
 extern int PQXpipelinePutSync(PGconn* conn);
diff --git a/postgresql/src/storages/postgres/component.cpp b/postgresql/src/storages/postgres/component.cpp
index 66339f64e39c..be603d8563e3 100644
--- a/postgresql/src/storages/postgres/component.cpp
+++ b/postgresql/src/storages/postgres/component.cpp
@@ -290,15 +290,21 @@ additionalProperties: false
         defaultDescription: engine::current_task::GetBlockingTaskProcessor()
     max_replication_lag:
         type: string
-        description: replication lag limit for usable slaves
+        description: |
+            replication lag limit for usable replicas. If a replica's lag exceeds this value, it stops receiving
+            new requests
         defaultDescription: 60s
     min_pool_size:
         type: integer
-        description: number of connections created initially
+        description: |
+            number of connections created initially by this component instance to each of the provided PostgreSQL
+            hosts. Connections are kept even without requests
         defaultDescription: 4
     max_pool_size:
         type: integer
-        description: limit of connections count
+        description: |
+            maximum number of connections that can be created by this component instance to each of the provided
+            PostgreSQL hosts for "connlimit_mode: manual". Should not be less than `min_pool_size`
         defaultDescription: 15
     sync-start:
         type: boolean
@@ -387,7 +393,9 @@ additionalProperties: false
                       - random-delay
     max_queue_size:
         type: integer
-        description: maximum number of clients waiting for a connection
+        description: |
+            maximum number of clients waiting for a connection. storages::postgres::PoolError is thrown if a new
+            request exceeds this limit
         defaultDescription: 200
     pipeline_enabled:
         type: boolean
@@ -395,7 +403,8 @@ additionalProperties: false
         defaultDescription: false
     connecting_limit:
         type: integer
-        description: limit for concurrent establishing connections number per pool (0 - unlimited)
+        description: |
+            limit for concurrent establishing connections number per PostgreSQL host (0 - unlimited)
         defaultDescription: 0
     connlimit_mode:
         type: string
diff --git a/postgresql/src/storages/postgres/congestion_control/sensor.cpp b/postgresql/src/storages/postgres/congestion_control/sensor.cpp
index be151e2f3708..e308f61aca4e 100644
--- a/postgresql/src/storages/postgres/congestion_control/sensor.cpp
+++ b/postgresql/src/storages/postgres/congestion_control/sensor.cpp
@@ -11,12 +11,12 @@ Sensor::Sensor(detail::ConnectionPool& pool) : pool_(pool) {}
 Sensor::Data Sensor::GetCurrent() {
     const auto& stats = pool_.GetStatistics();
     auto new_timeouts = stats.transaction.execute_timeout + stats.connection.error_timeout;
-    auto diff_timeouts = new_timeouts - last_timeouted_queries;
-    last_timeouted_queries = new_timeouts;
+    auto diff_timeouts = new_timeouts - last_timeouted_queries_;
+    last_timeouted_queries_ = new_timeouts;
 
     auto new_total = stats.transaction.total;
-    auto diff_total = new_total - last_total_queries;
-    last_total_queries = new_total;
+    auto diff_total = new_total - last_total_queries_;
+    last_total_queries_ = new_total;
     if (diff_total == 0) diff_total = 1;
 
     auto timeout_rate = static_cast<double>(diff_timeouts) / diff_total;
diff --git a/postgresql/src/storages/postgres/congestion_control/sensor.hpp b/postgresql/src/storages/postgres/congestion_control/sensor.hpp
index 6b56a48a8cc1..358650848c49 100644
--- a/postgresql/src/storages/postgres/congestion_control/sensor.hpp
+++ b/postgresql/src/storages/postgres/congestion_control/sensor.hpp
@@ -22,8 +22,8 @@ class Sensor final : public congestion_control::v2::Sensor {
 
 private:
     detail::ConnectionPool& pool_;
-    std::size_t last_total_queries{0};
-    std::size_t last_timeouted_queries{0};
+    std::size_t last_total_queries_{0};
+    std::size_t last_timeouted_queries_{0};
 };
 
 }  // namespace cc
diff --git a/postgresql/src/storages/postgres/detail/cancel.cpp b/postgresql/src/storages/postgres/detail/cancel.cpp
index beba91506918..35ba7dcbc7f2 100644
--- a/postgresql/src/storages/postgres/detail/cancel.cpp
+++ b/postgresql/src/storages/postgres/detail/cancel.cpp
@@ -19,7 +19,7 @@
 
 using ACCEPT_TYPE_ARG3 = socklen_t;
 
-struct pg_sockaddr_storage {
+struct PgSockaddrStorage {
     union {
         struct sockaddr sa; /* get the system-dependent fields */
         int64_t ss_align;   /* ensures struct is properly aligned */
@@ -29,7 +29,7 @@ struct pg_sockaddr_storage {
 
 // NOLINTNEXTLINE(modernize-use-using)
 typedef struct {
-    struct pg_sockaddr_storage addr;
+    struct PgSockaddrStorage addr;
     ACCEPT_TYPE_ARG3 salen;
 } SockAddr;
 
@@ -42,9 +42,9 @@ struct pg_cancel {
 // NOLINTNEXTLINE(modernize-use-using)
 typedef struct CancelRequestPacket {
     /* Note that each field is stored in network byte order! */
-    uint32_t cancelRequestCode; /* code to identify a cancel request */
-    uint32_t backendPID;        /* PID of client's backend */
-    uint32_t cancelAuthCode;    /* secret key to authorize cancel */
+    uint32_t cancel_request_code; /* code to identify a cancel request */
+    uint32_t backend_pid;         /* PID of client's backend */
+    uint32_t cancel_auth_code;    /* secret key to authorize cancel */
 } CancelRequestPacket;
 
 struct CancelPacket {
@@ -68,9 +68,9 @@ void Cancel(PGcancel* cn, engine::Deadline deadline) {
 
     CancelPacket cp{};
     cp.packetlen = sizeof(cp);
-    cp.cp.cancelRequestCode = static_cast<uint32_t>(htonl(CANCEL_REQUEST_CODE));
-    cp.cp.backendPID = htonl(cn->be_pid);
-    cp.cp.cancelAuthCode = htonl(cn->be_key);
+    cp.cp.cancel_request_code = static_cast<uint32_t>(htonl(CANCEL_REQUEST_CODE));
+    cp.cp.backend_pid = htonl(cn->be_pid);
+    cp.cp.cancel_auth_code = htonl(cn->be_key);
 
     auto ret = tmp_sock.SendAll(&cp, sizeof(cp), deadline);
     if (ret != sizeof(cp)) throw CommandError("SendAll()");
diff --git a/postgresql/src/storages/postgres/detail/connection.hpp b/postgresql/src/storages/postgres/detail/connection.hpp
index 79db902712cf..df2ed566dac8 100644
--- a/postgresql/src/storages/postgres/detail/connection.hpp
+++ b/postgresql/src/storages/postgres/detail/connection.hpp
@@ -10,6 +10,7 @@
 #include <userver/engine/task/task_processor_fwd.hpp>
 #include <userver/error_injection/settings.hpp>
 #include <userver/testsuite/postgres_control.hpp>
+#include <userver/tracing/scope_time.hpp>
 #include <userver/utils/statistics/min_max_avg.hpp>
 #include <userver/utils/strong_typedef.hpp>
 
diff --git a/postgresql/src/storages/postgres/detail/connection_impl.cpp b/postgresql/src/storages/postgres/detail/connection_impl.cpp
index cb4649b81806..7642b826c47a 100644
--- a/postgresql/src/storages/postgres/detail/connection_impl.cpp
+++ b/postgresql/src/storages/postgres/detail/connection_impl.cpp
@@ -59,7 +59,7 @@ class CountExecute {
 public:
     CountExecute(Connection::Statistics& stats) : stats_(stats) {
         ++stats_.execute_total;
-        exec_begin_time = SteadyClock::now();
+        exec_begin_time_ = SteadyClock::now();
     }
 
     ~CountExecute() {
@@ -67,7 +67,7 @@ class CountExecute {
         if (!completed_) {
             ++stats_.error_execute_total;
         }
-        stats_.sum_query_duration += now - exec_begin_time;
+        stats_.sum_query_duration += now - exec_begin_time_;
         stats_.last_execute_finish = now;
     }
 
@@ -79,7 +79,7 @@ class CountExecute {
 private:
     Connection::Statistics& stats_;
     bool completed_{false};
-    SteadyClock::time_point exec_begin_time;
+    SteadyClock::time_point exec_begin_time_;
 };
 
 class CountPortalBind {
@@ -909,7 +909,7 @@ ResultSet ConnectionImpl::ExecuteCommand(
     PGresult* description_ptr_to_send = nullptr;
     if (IsOmitDescribeInExecuteEnabled()) {
         description_ptr_to_read = &prepared_info.description;
-        description_ptr_to_send = description_ptr_to_read->pimpl_->handle_.get();
+        description_ptr_to_send = description_ptr_to_read->pimpl_->handle.get();
     }
 
     scope.Reset(scopes::kExec);
@@ -950,7 +950,7 @@ void ConnectionImpl::AddIntoPipeline(
 
     SetStatementTimeout(cc);
 
-    PGresult* description_to_send = IsOmitDescribeInExecuteEnabled() ? description.pimpl_->handle_.get() : nullptr;
+    PGresult* description_to_send = IsOmitDescribeInExecuteEnabled() ? description.pimpl_->handle.get() : nullptr;
     conn_wrapper_.SendPreparedQuery(prepared_statement_name, params, scope, description_to_send);
 
     conn_wrapper_.PutPipelineSync();
@@ -964,7 +964,7 @@ ConnectionImpl::GatherPipeline(TimeoutDuration timeout, const std::vector<Result
     std::vector<const PGresult*> native_descriptions(descriptions.size(), nullptr);
     if (IsOmitDescribeInExecuteEnabled()) {
         for (std::size_t i = 0; i < descriptions.size(); ++i) {
-            native_descriptions[i] = descriptions[i].pimpl_->handle_.get();
+            native_descriptions[i] = descriptions[i].pimpl_->handle.get();
         }
     }
 
@@ -1102,7 +1102,7 @@ ResultSet ConnectionImpl::WaitResult(
     tracing::ScopeTime& scope,
     const ResultSet* description_ptr
 ) {
-    const PGresult* description = description_ptr ? description_ptr->pimpl_->handle_.get() : nullptr;
+    const PGresult* description = description_ptr ? description_ptr->pimpl_->handle.get() : nullptr;
 
     const ScopeGuard guard([this]() { in_transaction_ = IsInTransaction(); });
 
diff --git a/postgresql/src/storages/postgres/detail/result_wrapper.cpp b/postgresql/src/storages/postgres/detail/result_wrapper.cpp
index 418eaa8ce1e3..7fd34abc97ed 100644
--- a/postgresql/src/storages/postgres/detail/result_wrapper.cpp
+++ b/postgresql/src/storages/postgres/detail/result_wrapper.cpp
@@ -146,15 +146,15 @@ struct ResultWrapper::CachedFieldBufferCategories final {
     boost::container::small_vector<io::BufferCategory, 16> data;
 };
 
-ResultWrapper::ResultWrapper(ResultHandle&& res) : handle_{std::move(res)} { UASSERT(handle_); }
+ResultWrapper::ResultWrapper(ResultHandle&& res) : handle{std::move(res)} { UASSERT(handle); }
 
 ResultWrapper::~ResultWrapper() = default;
 
 void ResultWrapper::FillBufferCategories(const UserTypes& types) {
-    buffer_categories_.clear();
+    buffer_categories.clear();
 
     const auto n_fields = FieldCount();
-    buffer_categories_.reserve(n_fields);
+    buffer_categories.reserve(n_fields);
 
     const auto oid_fn = [this](auto f_no) { return GetFieldTypeOid(f_no); };
     const auto name_fn = [this](auto f_no) { return GetFieldName(f_no); };
@@ -170,39 +170,39 @@ void ResultWrapper::FillBufferCategories(const UserTypes& types) {
     // performed without preserving paths, and iff it fails the second attempt
     // re-runs the process from scratch with all the info it needs,
     // and is guaranteed to throw.
-    if (!AddTypeBufferCategories<NoopTypeNameScope>(n_fields, oid_fn, name_fn, types, buffer_categories_)) {
-        buffer_categories_.clear();
-        AddTypeBufferCategories<TypeNameScope>(n_fields, oid_fn, name_fn, types, buffer_categories_);
+    if (!AddTypeBufferCategories<NoopTypeNameScope>(n_fields, oid_fn, name_fn, types, buffer_categories)) {
+        buffer_categories.clear();
+        AddTypeBufferCategories<TypeNameScope>(n_fields, oid_fn, name_fn, types, buffer_categories);
         UINVARIANT(false, "Should be unreachable");
     }
 
-    cached_buffer_categories_->data.resize(n_fields);
+    cached_buffer_categories->data.resize(n_fields);
     for (std::size_t f_no = 0; f_no < n_fields; ++f_no) {
         const auto data_type = GetFieldTypeOid(f_no);
-        const auto f = buffer_categories_.find(data_type);
+        const auto f = buffer_categories.find(data_type);
 
-        cached_buffer_categories_->data[f_no] =
-            (f == buffer_categories_.end() ? io::BufferCategory::kNoParser : f->second);
+        cached_buffer_categories->data[f_no] =
+            (f == buffer_categories.end() ? io::BufferCategory::kNoParser : f->second);
     }
 }
 
-ExecStatusType ResultWrapper::GetStatus() const { return PQresultStatus(handle_.get()); }
+ExecStatusType ResultWrapper::GetStatus() const { return PQresultStatus(handle.get()); }
 
-std::size_t ResultWrapper::RowCount() const { return PQntuples(handle_.get()); }
+std::size_t ResultWrapper::RowCount() const { return PQntuples(handle.get()); }
 
-std::size_t ResultWrapper::FieldCount() const { return PQnfields(handle_.get()); }
+std::size_t ResultWrapper::FieldCount() const { return PQnfields(handle.get()); }
 
-const io::TypeBufferCategory& ResultWrapper::GetTypeBufferCategories() const { return buffer_categories_; }
+const io::TypeBufferCategory& ResultWrapper::GetTypeBufferCategories() const { return buffer_categories; }
 
 void ResultWrapper::SetTypeBufferCategories(const ResultWrapper& description) {
-    buffer_categories_ = description.buffer_categories_;
-    cached_buffer_categories_ = description.cached_buffer_categories_;
+    buffer_categories = description.buffer_categories;
+    cached_buffer_categories = description.cached_buffer_categories;
 }
 
-std::string ResultWrapper::CommandStatus() const { return PQcmdStatus(handle_.get()); }
+std::string ResultWrapper::CommandStatus() const { return PQcmdStatus(handle.get()); }
 
 std::size_t ResultWrapper::RowsAffected() const {
-    auto* str = PQcmdTuples(handle_.get());
+    auto* str = PQcmdTuples(handle.get());
     if (str) {
         char* endptr = nullptr;
         auto val = std::strtoll(str, &endptr, 10);
@@ -219,13 +219,13 @@ std::size_t ResultWrapper::RowsAffected() const {
 }
 
 std::size_t ResultWrapper::IndexOfName(USERVER_NAMESPACE::utils::zstring_view name) const {
-    auto n = PQfnumber(handle_.get(), name.c_str());
+    auto n = PQfnumber(handle.get(), name.c_str());
     if (n < 0) return ResultSet::npos;
     return n;
 }
 
 std::string_view ResultWrapper::GetFieldName(std::size_t col) const {
-    auto* name = PQfname(handle_.get(), col);
+    auto* name = PQfname(handle.get(), col);
     if (name) {
         return {name};
     }
@@ -237,26 +237,26 @@ FieldDescription ResultWrapper::GetFieldDescription(std::size_t col) const {
         col,
         GetFieldTypeOid(col),
         std::string{GetFieldName(col)},
-        PQftable(handle_.get(), col),
-        PQftablecol(handle_.get(), col),
-        PQfsize(handle_.get(), col),
-        PQfmod(handle_.get(), col)};
+        PQftable(handle.get(), col),
+        PQftablecol(handle.get(), col),
+        PQfsize(handle.get(), col),
+        PQfmod(handle.get(), col)};
 }
 
-bool ResultWrapper::IsFieldNull(std::size_t row, std::size_t col) const { return PQgetisnull(handle_.get(), row, col); }
+bool ResultWrapper::IsFieldNull(std::size_t row, std::size_t col) const { return PQgetisnull(handle.get(), row, col); }
 
-Oid ResultWrapper::GetFieldTypeOid(std::size_t col) const { return PQftype(handle_.get(), col); }
+Oid ResultWrapper::GetFieldTypeOid(std::size_t col) const { return PQftype(handle.get(), col); }
 
 io::BufferCategory ResultWrapper::GetFieldBufferCategory(std::size_t col) const {
-    return cached_buffer_categories_->data[col];
+    return cached_buffer_categories->data[col];
 }
 
 std::size_t ResultWrapper::GetFieldLength(std::size_t row, std::size_t col) const {
-    return PQgetlength(handle_.get(), row, col);
+    return PQgetlength(handle.get(), row, col);
 }
 
 io::FieldBuffer ResultWrapper::GetFieldBuffer(std::size_t row, std::size_t col) const {
-    if (PQfformat(handle_.get(), col) != io::kPgBinaryDataFormat) {
+    if (PQfformat(handle.get(), col) != io::kPgBinaryDataFormat) {
         throw ResultSetError{
             fmt::format("Column with index {} has text format\n", col) +
             logging::stacktrace_cache::to_string(boost::stacktrace::stacktrace{})};
@@ -265,11 +265,11 @@ io::FieldBuffer ResultWrapper::GetFieldBuffer(std::size_t row, std::size_t col)
         IsFieldNull(row, col),
         GetFieldBufferCategory(col),
         GetFieldLength(row, col),
-        reinterpret_cast<const std::uint8_t*>(PQgetvalue(handle_.get(), row, col))};
+        reinterpret_cast<const std::uint8_t*>(PQgetvalue(handle.get(), row, col))};
 }
 
 std::string ResultWrapper::GetErrorMessage() const {
-    const char* msg = PQresultErrorMessage(handle_.get());
+    const char* msg = PQresultErrorMessage(handle.get());
     return {msg ? msg : "no error message"};
 }
 
@@ -286,7 +286,7 @@ std::string ResultWrapper::GetMessageSeverityString() const {
 }
 
 Message::Severity ResultWrapper::GetMessageSeverity() const {
-    return Message::SeverityFromString(GetMachineReadableSeverity(handle_.get()));
+    return Message::SeverityFromString(GetMachineReadableSeverity(handle.get()));
 }
 
 std::string ResultWrapper::GetSqlCode() const { return GetMessageField(PG_DIAG_SQLSTATE).value(); }
@@ -310,7 +310,7 @@ std::string ResultWrapper::GetMessageConstraint() const {
 }
 
 std::optional<std::string> ResultWrapper::GetMessageField(int fieldcode) const {
-    const char* res = PQresultErrorField(handle_.get(), fieldcode);
+    const char* res = PQresultErrorField(handle.get(), fieldcode);
     if (res == nullptr) {
         return std::nullopt;
     }
@@ -320,7 +320,7 @@ std::optional<std::string> ResultWrapper::GetMessageField(int fieldcode) const {
 logging::LogExtra ResultWrapper::GetMessageLogExtra() const {
     logging::LogExtra log_extra;
 
-    auto severity = GetMachineReadableSeverity(handle_.get());
+    auto severity = GetMachineReadableSeverity(handle.get());
     if (!severity.empty()) {
         log_extra.Extend(kSeverityLogExtraKey, std::string{severity});
     }
diff --git a/postgresql/src/storages/postgres/detail/result_wrapper.hpp b/postgresql/src/storages/postgres/detail/result_wrapper.hpp
index 541c76cde132..08a688940b61 100644
--- a/postgresql/src/storages/postgres/detail/result_wrapper.hpp
+++ b/postgresql/src/storages/postgres/detail/result_wrapper.hpp
@@ -71,11 +71,11 @@ class ResultWrapper {
     logging::LogExtra GetMessageLogExtra() const;
     //@}
 
-    ResultHandle handle_;
-    io::TypeBufferCategory buffer_categories_;
+    ResultHandle handle;
+    io::TypeBufferCategory buffer_categories;
 
     struct CachedFieldBufferCategories;
-    USERVER_NAMESPACE::utils::FastPimpl<CachedFieldBufferCategories, 88, 8> cached_buffer_categories_;
+    USERVER_NAMESPACE::utils::FastPimpl<CachedFieldBufferCategories, 88, 8> cached_buffer_categories;
 };
 
 inline ResultWrapper::ResultHandle MakeResultHandle(PGresult* pg_res) { return {pg_res, &PQclear}; }
diff --git a/postgresql/src/storages/postgres/detail/statement_stats_storage.hpp b/postgresql/src/storages/postgres/detail/statement_stats_storage.hpp
index 58c3f1b15c25..07b5e1d021a7 100644
--- a/postgresql/src/storages/postgres/detail/statement_stats_storage.hpp
+++ b/postgresql/src/storages/postgres/detail/statement_stats_storage.hpp
@@ -40,8 +40,8 @@ class StatementStatsStorage final {
 
 private:
     struct StatementEvent final {
-        StatementEvent(const std::string& statement_name_, size_t duration_, ExecutionResult result_)
-            : statement_name{statement_name_}, duration_ms{duration_}, result{result_} {}
+        StatementEvent(const std::string& statement_name, size_t duration, ExecutionResult result)
+            : statement_name{statement_name}, duration_ms{duration}, result{result} {}
 
         std::string statement_name;
         std::size_t duration_ms;
diff --git a/postgresql/src/storages/postgres/io/composite_types.cpp b/postgresql/src/storages/postgres/io/composite_types.cpp
index 36acb0e2a9be..c6291aaacc77 100644
--- a/postgresql/src/storages/postgres/io/composite_types.cpp
+++ b/postgresql/src/storages/postgres/io/composite_types.cpp
@@ -10,7 +10,7 @@ namespace {
 
 struct Record {
     // must be non-empty to be a composite type
-    int dummy_;
+    int dummy;
 };
 
 }  // namespace
diff --git a/postgresql/src/storages/postgres/io/type_mapping.cpp b/postgresql/src/storages/postgres/io/type_mapping.cpp
index e1dd6989e69a..67500705ee7e 100644
--- a/postgresql/src/storages/postgres/io/type_mapping.cpp
+++ b/postgresql/src/storages/postgres/io/type_mapping.cpp
@@ -21,8 +21,8 @@ namespace storages::postgres::io {
 namespace {
 
 struct PredefinedOidsPair {
-    PredefinedOidsPair(PredefinedOids first_, PredefinedOids second_)
-        : first(std::min(first_, second_)), second(std::max(first_, second_)) {}
+    PredefinedOidsPair(PredefinedOids l_first, PredefinedOids l_second)
+        : first(std::min(l_first, l_second)), second(std::max(l_first, l_second)) {}
 
     PredefinedOids first;
     PredefinedOids second;
diff --git a/postgresql/src/storages/postgres/notify.cpp b/postgresql/src/storages/postgres/notify.cpp
index dbe29e9865c4..f71ef0e7e2f0 100644
--- a/postgresql/src/storages/postgres/notify.cpp
+++ b/postgresql/src/storages/postgres/notify.cpp
@@ -8,12 +8,12 @@ USERVER_NAMESPACE_BEGIN
 namespace storages::postgres {
 
 struct NotifyScope::Impl {
-    detail::ConnectionPtr conn_;
-    std::string channel_;
-    OptionalCommandControl cmd_ctl_;
+    detail::ConnectionPtr conn;
+    std::string channel;
+    OptionalCommandControl cmd_ctl;
 
     Impl(detail::ConnectionPtr conn, std::string_view channel, OptionalCommandControl cmd_ctl)
-        : conn_{std::move(conn)}, channel_{channel}, cmd_ctl_{cmd_ctl} {
+        : conn{std::move(conn)}, channel{channel}, cmd_ctl{cmd_ctl} {
         Listen();
     }
 
@@ -26,26 +26,26 @@ struct NotifyScope::Impl {
     Impl& operator=(const Impl&) = delete;
 
     Notification WaitNotify(engine::Deadline deadline) {
-        UINVARIANT(conn_, "Called WaitNotify on empty NotifyScope");
-        return conn_->WaitNotify(deadline);
+        UINVARIANT(conn, "Called WaitNotify on empty NotifyScope");
+        return conn->WaitNotify(deadline);
     }
 
 private:
     void Listen() {
-        UASSERT(conn_);
-        LOG_DEBUG() << "Start listening on channel '" << channel_ << "'";
-        conn_->Listen(channel_, cmd_ctl_);
+        UASSERT(conn);
+        LOG_DEBUG() << "Start listening on channel '" << channel << "'";
+        conn->Listen(channel, cmd_ctl);
     }
 
     void Unlisten() {
-        if (!conn_) return;
+        if (!conn) return;
         try {
-            LOG_DEBUG() << "Stop listening on channel '" << channel_ << "'";
-            conn_->Unlisten(channel_, cmd_ctl_);
+            LOG_DEBUG() << "Stop listening on channel '" << channel << "'";
+            conn->Unlisten(channel, cmd_ctl);
         } catch (const std::exception& e) {
             LOG_LIMITED_ERROR() << "Exception while executing unlisten: " << e;
             // Will be closed to avoid unsolicited notifications in the future
-            conn_->MarkAsBroken();
+            conn->MarkAsBroken();
         }
     }
 };
diff --git a/postgresql/src/storages/postgres/portal.cpp b/postgresql/src/storages/postgres/portal.cpp
index 983981ef5aed..73a789035f29 100644
--- a/postgresql/src/storages/postgres/portal.cpp
+++ b/postgresql/src/storages/postgres/portal.cpp
@@ -9,12 +9,12 @@ USERVER_NAMESPACE_BEGIN
 namespace storages::postgres {
 
 struct Portal::Impl {
-    detail::Connection* conn_{nullptr};
-    OptionalCommandControl cmd_ctl_;
-    detail::Connection::StatementId statement_id_;
-    PortalName name_;
-    std::size_t fetched_so_far_{0};
-    bool done_{false};
+    detail::Connection* conn{nullptr};
+    OptionalCommandControl cmd_ctl;
+    detail::Connection::StatementId statement_id;
+    PortalName name;
+    std::size_t fetched_so_far{0};
+    bool done{false};
 
     Impl(
         detail::Connection* conn,
@@ -23,10 +23,10 @@ struct Portal::Impl {
         const detail::QueryParameters& params,
         OptionalCommandControl cmd_ctl
     )
-        : conn_{conn}, cmd_ctl_{std::move(cmd_ctl)}, name_{name} {
-        if (conn_) {
-            if (!cmd_ctl_) {
-                cmd_ctl_ = conn_->GetQueryCmdCtl(query.GetOptionalNameView());
+        : conn{conn}, cmd_ctl{std::move(cmd_ctl)}, name{name} {
+        if (conn) {
+            if (!cmd_ctl) {
+                cmd_ctl = conn->GetQueryCmdCtl(query.GetOptionalNameView());
             }
             Bind(query.GetStatementView(), params);
         }
@@ -40,28 +40,28 @@ struct Portal::Impl {
 
     void Swap(Impl& rhs) noexcept {
         using std::swap;
-        swap(conn_, rhs.conn_);
-        swap(cmd_ctl_, rhs.cmd_ctl_);
-        swap(statement_id_, rhs.statement_id_);
-        swap(name_, rhs.name_);
-        swap(fetched_so_far_, rhs.fetched_so_far_);
-        swap(done_, rhs.done_);
+        swap(conn, rhs.conn);
+        swap(cmd_ctl, rhs.cmd_ctl);
+        swap(statement_id, rhs.statement_id);
+        swap(name, rhs.name);
+        swap(fetched_so_far, rhs.fetched_so_far);
+        swap(done, rhs.done);
     }
 
     void Bind(USERVER_NAMESPACE::utils::zstring_view statement, const detail::QueryParameters& params) {
-        statement_id_ = conn_->PortalBind(statement, name_.GetUnderlying(), params, cmd_ctl_);
+        statement_id = conn->PortalBind(statement, name.GetUnderlying(), params, cmd_ctl);
     }
 
     ResultSet Fetch(std::uint32_t n_rows) {
-        if (!done_) {
-            UASSERT(conn_);
-            auto res = conn_->PortalExecute(statement_id_, name_.GetUnderlying(), n_rows, cmd_ctl_);
+        if (!done) {
+            UASSERT(conn);
+            auto res = conn->PortalExecute(statement_id, name.GetUnderlying(), n_rows, cmd_ctl);
             auto fetched = res.Size();
             // TODO: check command completion in result TAXICOMMON-4505
             if (!n_rows || fetched != n_rows) {
-                done_ = true;
+                done = true;
             }
-            fetched_so_far_ += fetched;
+            fetched_so_far += fetched;
             return res;
         } else {
             // TODO Specific exception
@@ -94,8 +94,8 @@ Portal& Portal::operator=(Portal&&) noexcept = default;
 
 ResultSet Portal::Fetch(std::uint32_t n_rows) { return pimpl_->Fetch(n_rows); }
 
-bool Portal::Done() const { return pimpl_->done_; }
-std::size_t Portal::FetchedSoFar() const { return pimpl_->fetched_so_far_; }
+bool Portal::Done() const { return pimpl_->done; }
+std::size_t Portal::FetchedSoFar() const { return pimpl_->fetched_so_far; }
 
 bool Portal::IsSupportedByDriver() noexcept {
 #ifndef USERVER_NO_LIBPQ_PATCHES
diff --git a/postgresql/src/storages/postgres/query_queue.cpp b/postgresql/src/storages/postgres/query_queue.cpp
index 29c7498c1e5b..6859f15c1bf2 100644
--- a/postgresql/src/storages/postgres/query_queue.cpp
+++ b/postgresql/src/storages/postgres/query_queue.cpp
@@ -4,6 +4,7 @@
 
 #include <storages/postgres/detail/connection.hpp>
 #include <userver/storages/postgres/exceptions.hpp>
+#include <userver/tracing/span.hpp>
 #include <userver/utils/assert.hpp>
 #include <userver/utils/scope_guard.hpp>
 
diff --git a/postgresql/src/storages/postgres/tests/cluster_pgtest.cpp b/postgresql/src/storages/postgres/tests/cluster_pgtest.cpp
index 033b95063778..201973217489 100644
--- a/postgresql/src/storages/postgres/tests/cluster_pgtest.cpp
+++ b/postgresql/src/storages/postgres/tests/cluster_pgtest.cpp
@@ -11,6 +11,7 @@
 #include <userver/storages/postgres/dsn.hpp>
 #include <userver/storages/postgres/exceptions.hpp>
 #include <userver/utils/statistics/metrics_storage.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -343,6 +344,60 @@ UTEST_F(PostgreCluster, TransactionTimeouts) {
     }
 }
 
+utils::statistics::Rate GetTriggers() { return utils::trx_tracker::GetStatistics().triggers; }
+
+UTEST_F(PostgreCluster, TransactionTracker) {
+    testsuite::TestsuiteTasks testsuite_tasks{true};
+    auto cluster = CreateCluster(GetDsnListFromEnv(), GetTaskProcessor(), 1, testsuite_tasks);
+
+    const utils::trx_tracker::impl::GlobalEnabler enabler;
+
+    {
+        // Commit
+        utils::trx_tracker::ResetStatistics();
+        auto trx = cluster.Begin(pg::Transaction::RW);
+        utils::trx_tracker::CheckNoTransactions();
+        trx.Commit();
+        utils::trx_tracker::CheckNoTransactions();
+        EXPECT_EQ(GetTriggers(), 1);
+    }
+    {
+        // Rollback
+        utils::trx_tracker::ResetStatistics();
+        auto trx = cluster.Begin(pg::Transaction::RW);
+        utils::trx_tracker::CheckNoTransactions();
+        trx.Rollback();
+        utils::trx_tracker::CheckNoTransactions();
+        EXPECT_EQ(GetTriggers(), 1);
+    }
+    {
+        // Rollback on destruction
+        utils::trx_tracker::ResetStatistics();
+        {
+            auto trx = cluster.Begin(pg::Transaction::RW);
+            utils::trx_tracker::CheckNoTransactions();
+        }
+        utils::trx_tracker::CheckNoTransactions();
+        EXPECT_EQ(GetTriggers(), 1);
+    }
+    {
+        // Trx with empty ConnectionPtr
+        utils::trx_tracker::ResetStatistics();
+
+        {
+            auto empty_trx = storages::postgres::Transaction(storages::postgres::detail::ConnectionPtr(nullptr));
+            utils::trx_tracker::CheckNoTransactions();
+        }
+
+        utils::trx_tracker::ResetStatistics();
+        auto trx = cluster.Begin(pg::Transaction::RW);
+        utils::trx_tracker::CheckNoTransactions();
+        trx.Commit();
+        utils::trx_tracker::CheckNoTransactions();
+        EXPECT_EQ(GetTriggers(), 1);
+    }
+}
+
 UTEST_F(PostgreCluster, NonTransactionExecuteWithParameterStore) {
     testsuite::TestsuiteTasks testsuite_tasks{true};
     auto cluster = CreateCluster(GetDsnListFromEnv(), GetTaskProcessor(), 1, testsuite_tasks);
diff --git a/postgresql/src/storages/postgres/tests/composite_types_pgtest.cpp b/postgresql/src/storages/postgres/tests/composite_types_pgtest.cpp
index ff39a0647f9a..122747b82a3a 100644
--- a/postgresql/src/storages/postgres/tests/composite_types_pgtest.cpp
+++ b/postgresql/src/storages/postgres/tests/composite_types_pgtest.cpp
@@ -88,24 +88,24 @@ struct FooBarWithOptionalFields {
 using FooBarOpt = std::optional<FooBar>;
 
 class FooClass {
-    int i{};
-    std::string s;
-    double d{};
-    std::vector<int> a;
-    std::vector<std::string> v;
+    int i_{};
+    std::string s_;
+    double d_{};
+    std::vector<int> a_;
+    std::vector<std::string> v_;
 
 public:
     FooClass() = default;
-    explicit FooClass(int x) : i(x), s(std::to_string(x)), d(x), a{i}, v{s} {}
+    explicit FooClass(int x) : i_(x), s_(std::to_string(x)), d_(x), a_{i_}, v_{s_} {}
 
     // Only non-const version of Introspect() is used by the uPostgres driver
-    auto Introspect() { return std::tie(i, s, d, a, v); }
+    auto Introspect() { return std::tie(i_, s_, d_, a_, v_); }
 
-    auto GetI() const { return i; }
-    auto GetS() const { return s; }
-    auto GetD() const { return d; }
-    auto GetA() const { return a; }
-    auto GetV() const { return v; }
+    auto GetI() const { return i_; }
+    auto GetS() const { return s_; }
+    auto GetD() const { return d_; }
+    auto GetA() const { return a_; }
+    auto GetV() const { return v_; }
 };
 
 using FooTuple = std::tuple<int, std::string, double, std::vector<int>, std::vector<std::string>>;
diff --git a/postgresql/src/storages/postgres/tests/connection_pgtest.cpp b/postgresql/src/storages/postgres/tests/connection_pgtest.cpp
index 8eee0dc57c4a..00310d964869 100644
--- a/postgresql/src/storages/postgres/tests/connection_pgtest.cpp
+++ b/postgresql/src/storages/postgres/tests/connection_pgtest.cpp
@@ -16,10 +16,10 @@ namespace pg = storages::postgres;
 
 namespace static_test {
 
-struct no_input_operator {};
-static_assert(!pg::io::traits::kHasInputOperator<no_input_operator>, "Test input metafunction");
+struct NoInputOperator {};
+static_assert(!pg::io::traits::kHasInputOperator<NoInputOperator>, "Test input metafunction");
 static_assert(pg::io::traits::kHasInputOperator<int>, "Test input metafunction");
-static_assert(!pg::io::traits::kHasParser<no_input_operator>, "Test has parser metafunction");
+static_assert(!pg::io::traits::kHasParser<NoInputOperator>, "Test has parser metafunction");
 static_assert(pg::io::traits::kHasParser<int>, "Test has parser metafunction");
 
 }  // namespace static_test
diff --git a/postgresql/src/storages/postgres/tests/connlimit_watchdog_pgtest.cpp b/postgresql/src/storages/postgres/tests/connlimit_watchdog_pgtest.cpp
index 9d93ad69d17c..5ae8bba377cd 100644
--- a/postgresql/src/storages/postgres/tests/connlimit_watchdog_pgtest.cpp
+++ b/postgresql/src/storages/postgres/tests/connlimit_watchdog_pgtest.cpp
@@ -144,7 +144,7 @@ UTEST_F(Watchdog, AllPermutations) {
     static_assert(
         (&pg::ConnlimitWatchdog::StepV1) && (&pg::ConnlimitWatchdog::StepV2),
         "Do not remove old versions of StepV*, because there may be users that still use it and they may update "
-        "userver one day. So we need to make sure that the update (and a rollback) will be successfull."
+        "userver one day. So we need to make sure that the update (and a rollback) will be successful."
     );
     // Fill the table by two rows.
     EXPECT_EQ(kTestsuiteConnlimit, DoStepV1());
diff --git a/postgresql/src/storages/postgres/tests/enums_pgtest.cpp b/postgresql/src/storages/postgres/tests/enums_pgtest.cpp
index ce375b3aa7be..f7625ee99869 100644
--- a/postgresql/src/storages/postgres/tests/enums_pgtest.cpp
+++ b/postgresql/src/storages/postgres/tests/enums_pgtest.cpp
@@ -30,6 +30,14 @@ select  'red'::__pgtest.rainbow as red,
         'cyan'::__pgtest.rainbow as cyan
 )~";
 
+const std::string kCreateAnimalsEnumType = R"~(
+-- /// [Animals enum type postgres]
+CREATE TYPE __pgtest.animals AS enum (
+  'cat', 'dog', 'bird', 'fish'
+)
+-- /// [Animals enum type postgres]
+)~";
+
 }  // anonymous namespace
 
 /*! [User enum type cpp] */
@@ -296,4 +304,56 @@ UTEST_P(PostgreConnection, GeneratedEnumRoundtrip) {
     UEXPECT_NO_THROW(GetConn()->Execute(kDropTestSchema)) << "Drop schema";
 }
 
+/// [Autogenerated user enum type]
+enum class GeneratedAnimals { kCat, kDog, kBird, kFish };
+
+GeneratedAnimals Parse(std::string_view value, formats::parse::To<GeneratedAnimals>);
+std::string ToString(GeneratedAnimals value);
+
+template <>
+struct storages::postgres::io::CppToSystemPg<GeneratedAnimals>
+    : storages::postgres::io::PredefinedOid<storages::postgres::io::PredefinedOids::kText> {};
+/// [Autogenerated user enum type]
+
+static constexpr USERVER_NAMESPACE::utils::TrivialBiMap kGeneratedAnimalsMap{[](auto selector) {
+    return selector()
+        .Case("cat", GeneratedAnimals::kCat)
+        .Case("dog", GeneratedAnimals::kDog)
+        .Case("bird", GeneratedAnimals::kBird)
+        .Case("fish", GeneratedAnimals::kFish);
+}};
+
+GeneratedAnimals Parse(std::string_view value, formats::parse::To<GeneratedAnimals>) {
+    const auto result = kGeneratedAnimalsMap.TryFind(value);
+    if (!result) {
+        throw std::runtime_error("Unknown value: " + std::string(value));
+    }
+    return *result;
+}
+
+std::string ToString(GeneratedAnimals value) { return std::string{*kGeneratedAnimalsMap.TryFind(value)}; }
+
+UTEST_P(PostgreConnection, AutogeneratedEnumToText) {
+    CheckConnection(GetConn());
+    ASSERT_FALSE(GetConn()->IsReadOnly()) << "Expect a read-write connection";
+
+    UASSERT_NO_THROW(GetConn()->Execute(kDropTestSchema)) << "Drop schema";
+    UASSERT_NO_THROW(GetConn()->Execute(kCreateTestSchema)) << "Create schema";
+
+    pg::ResultSet res{nullptr};
+    UEXPECT_NO_THROW(res = GetConn()->Execute("SELECT $1", GeneratedAnimals::kCat));
+    EXPECT_EQ("cat", res[0][0].As<std::string>());
+
+    UEXPECT_NO_THROW(res = GetConn()->Execute("SELECT 'dog'::text"));
+    EXPECT_EQ(res[0][0].As<GeneratedAnimals>(), GeneratedAnimals::kDog);
+
+    UEXPECT_NO_THROW(res = GetConn()->Execute("SELECT 'unknown_value'::text"));
+    UEXPECT_THROW(res[0][0].As<GeneratedAnimals>(), std::runtime_error);
+
+    UEXPECT_NO_THROW(GetConn()->Execute(kCreateAnimalsEnumType)) << "Successfully create an enumeration type";
+    UEXPECT_THROW(res = GetConn()->Execute("SELECT 'cat'::__pgtest.animals"), storages::postgres::NoBinaryParser);
+
+    UEXPECT_NO_THROW(GetConn()->Execute(kDropTestSchema)) << "Drop schema";
+}
+
 USERVER_NAMESPACE_END
diff --git a/postgresql/src/storages/postgres/tests/query_params_test.cpp b/postgresql/src/storages/postgres/tests/query_params_test.cpp
index 28feb61533d3..c96a5bfd1dfa 100644
--- a/postgresql/src/storages/postgres/tests/query_params_test.cpp
+++ b/postgresql/src/storages/postgres/tests/query_params_test.cpp
@@ -13,10 +13,10 @@ namespace static_test {
 
 namespace tt = io::traits;
 
-struct no_output_operator {};
-static_assert(!tt::kHasOutputOperator<no_output_operator>, "Test output metafunction");
+struct NoOutputOperator {};
+static_assert(!tt::kHasOutputOperator<NoOutputOperator>, "Test output metafunction");
 static_assert(tt::kHasOutputOperator<int>, "Test output metafunction");
-static_assert(!tt::kHasFormatter<no_output_operator>, "Test has formatter metafunction");
+static_assert(!tt::kHasFormatter<NoOutputOperator>, "Test has formatter metafunction");
 
 static_assert(tt::kHasFormatter<std::optional<int>>, "Test has formatter metafunction");
 
diff --git a/postgresql/src/storages/postgres/tests/util_pgtest.cpp b/postgresql/src/storages/postgres/tests/util_pgtest.cpp
index 34655371a1e0..6d7b506c3f4e 100644
--- a/postgresql/src/storages/postgres/tests/util_pgtest.cpp
+++ b/postgresql/src/storages/postgres/tests/util_pgtest.cpp
@@ -151,7 +151,7 @@ concurrent::BackgroundTaskStorageCore& PostgreSQLBase::GetTaskStorage() {
     return bts;
 }
 
-PostgreConnection::PostgreConnection() : conn(MakeConnection(GetDsnFromEnv(), GetTaskProcessor(), GetParam())) {}
+PostgreConnection::PostgreConnection() : conn_(MakeConnection(GetDsnFromEnv(), GetTaskProcessor(), GetParam())) {}
 
 PostgreConnection::~PostgreConnection() {
     // force connection cleanup to avoid leaving detached tasks behind
diff --git a/postgresql/src/storages/postgres/tests/util_pgtest.hpp b/postgresql/src/storages/postgres/tests/util_pgtest.hpp
index 1525d9dc0f3a..8c7b34d59252 100644
--- a/postgresql/src/storages/postgres/tests/util_pgtest.hpp
+++ b/postgresql/src/storages/postgres/tests/util_pgtest.hpp
@@ -98,10 +98,10 @@ class PostgreConnection : public PostgreSQLBase,
     PostgreConnection();
     ~PostgreConnection() override;
 
-    storages::postgres::detail::ConnectionPtr& GetConn() { return conn; }
+    storages::postgres::detail::ConnectionPtr& GetConn() { return conn_; }
 
 private:
-    storages::postgres::detail::ConnectionPtr conn;
+    storages::postgres::detail::ConnectionPtr conn_;
 };
 
 USERVER_NAMESPACE_END
diff --git a/postgresql/src/storages/postgres/transaction.cpp b/postgresql/src/storages/postgres/transaction.cpp
index dc1c26c04bd3..e2b832b0ec2b 100644
--- a/postgresql/src/storages/postgres/transaction.cpp
+++ b/postgresql/src/storages/postgres/transaction.cpp
@@ -22,6 +22,7 @@ Transaction::Transaction(
     : conn_{std::move(conn)} {
     if (conn_) {
         conn_->Begin(options, trx_start_time, trx_cmd_ctl);
+        trx_lock_.Lock();
     }
 }
 
@@ -132,6 +133,7 @@ void Transaction::Commit() {
         // in case of exception inside commit let it fly and don't release the
         // connection holder to allow for rolling back later
         conn_ = detail::ConnectionPtr{nullptr};
+        trx_lock_.Unlock();
     } else {
         LOG_LIMITED_ERROR() << "Commit after transaction finished" << logging::LogExtra::Stacktrace();
         throw NotInTransaction("Transaction handle is not valid");
@@ -142,6 +144,7 @@ void Transaction::Rollback() {
     auto conn = std::move(conn_);
     if (conn) {
         conn->Rollback();
+        trx_lock_.Unlock();
     } else {
         LOG_LIMITED_WARNING() << "Rollback after transaction finished" << logging::LogExtra::Stacktrace();
     }
diff --git a/rabbitmq/CMakeLists.txt b/rabbitmq/CMakeLists.txt
index 5d7829d85ddb..a67b39d2b9b7 100644
--- a/rabbitmq/CMakeLists.txt
+++ b/rabbitmq/CMakeLists.txt
@@ -12,6 +12,7 @@ userver_module(
     LINK_LIBRARIES_PRIVATE amqpcpp
     DBTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_rmqtest.cpp"
     DBTEST_DATABASES rabbitmq
+    DEPENDS core
 )
 
 _userver_directory_install(
diff --git a/rabbitmq/src/tests/invalid_auth_rmqtest.cpp b/rabbitmq/src/tests/invalid_auth_rmqtest.cpp
index c8de1dafbee6..5f67988ee93b 100644
--- a/rabbitmq/src/tests/invalid_auth_rmqtest.cpp
+++ b/rabbitmq/src/tests/invalid_auth_rmqtest.cpp
@@ -1,5 +1,7 @@
 #include "utils_rmqtest.hpp"
 
+#include <userver/engine/task/current_task.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 UTEST(InvalidAuth, Basic) {
diff --git a/rabbitmq/src/tests/outage_rmqtest.cpp b/rabbitmq/src/tests/outage_rmqtest.cpp
index 8f12af02fcdb..b79eaeb246b2 100644
--- a/rabbitmq/src/tests/outage_rmqtest.cpp
+++ b/rabbitmq/src/tests/outage_rmqtest.cpp
@@ -1,5 +1,7 @@
 #include "utils_rmqtest.hpp"
 
+#include <userver/engine/task/current_task.hpp>
+
 USERVER_NAMESPACE_BEGIN
 
 namespace {
diff --git a/rabbitmq/src/tests/publish_consume_rmqtest.cpp b/rabbitmq/src/tests/publish_consume_rmqtest.cpp
index 75c60c146baa..5ecdb44e0f96 100644
--- a/rabbitmq/src/tests/publish_consume_rmqtest.cpp
+++ b/rabbitmq/src/tests/publish_consume_rmqtest.cpp
@@ -2,6 +2,10 @@
 
 #include <optional>
 
+#include <userver/concurrent/variable.hpp>
+#include <userver/engine/condition_variable.hpp>
+#include <userver/engine/mutex.hpp>
+#include <userver/engine/single_consumer_event.hpp>
 #include <userver/engine/sleep.hpp>
 #include <userver/utils/uuid4.hpp>
 
diff --git a/rabbitmq/src/tests/utils_rmqtest.cpp b/rabbitmq/src/tests/utils_rmqtest.cpp
index da74dc73a973..e0b7fea807e1 100644
--- a/rabbitmq/src/tests/utils_rmqtest.cpp
+++ b/rabbitmq/src/tests/utils_rmqtest.cpp
@@ -1,5 +1,7 @@
 #include "utils_rmqtest.hpp"
 
+#include <userver/engine/task/current_task.hpp>
+#include <userver/logging/log.hpp>
 #include <userver/utils/assert.hpp>
 #include <userver/utils/from_string.hpp>
 #include <userver/utils/uuid4.hpp>
diff --git a/redis/CMakeLists.txt b/redis/CMakeLists.txt
index 2dcfe79de52e..cd4b0c1c1993 100644
--- a/redis/CMakeLists.txt
+++ b/redis/CMakeLists.txt
@@ -12,6 +12,7 @@ userver_module(
     DBTEST_DATABASES redis redis-cluster
     UBENCH_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/benchmark"
     UBENCH_DATABASES redis
+    DEPENDS core
     GENERATE_DYNAMIC_CONFIGS
 )
 
diff --git a/redis/functional_tests/cluster_auto_topology_pubsub/tests/test_redis_pubsub.py b/redis/functional_tests/cluster_auto_topology_pubsub/tests/test_redis_pubsub.py
index 83811b890af4..f4ac0917ed89 100644
--- a/redis/functional_tests/cluster_auto_topology_pubsub/tests/test_redis_pubsub.py
+++ b/redis/functional_tests/cluster_auto_topology_pubsub/tests/test_redis_pubsub.py
@@ -402,6 +402,7 @@ async def test_cluster_failover_pubsub(service_client, redis_cluster_topology):
 
 
 # kill all replicas
+@pytest.mark.skip(reason='Too many flaps. TAXICOMMON-10712')
 async def test_cluster_failover_pubsub2(
     service_client,
     redis_cluster_topology,
diff --git a/redis/functional_tests/integration_tests/tests/conftest.py b/redis/functional_tests/integration_tests/tests/conftest.py
index 154e3512a303..dad39392af63 100644
--- a/redis/functional_tests/integration_tests/tests/conftest.py
+++ b/redis/functional_tests/integration_tests/tests/conftest.py
@@ -18,12 +18,13 @@ def service_env(redis_sentinels, redis_cluster_nodes, redis_cluster_replicas, re
         )
     ]
 
+    # All the `sentinels` accept host and port. For example `'sentinels': [{'host': '192.168.1.7','port': 6379}]`
     secdist_config = {
         'redis_settings': {
             'redis-cluster': {
                 'password': '',
                 'sentinels': redis_cluster_nodes,
-                'shards': cluster_shards,
+                'shards': cluster_shards,  # For example, it can be [{"name": "shard0"}, {"name": "shard1"}]
             },
             'redis-sentinel': {
                 'password': '',
diff --git a/redis/functional_tests/metrics/redis_service.cpp b/redis/functional_tests/metrics/redis_service.cpp
index 41f21906ca43..01081fd98874 100644
--- a/redis/functional_tests/metrics/redis_service.cpp
+++ b/redis/functional_tests/metrics/redis_service.cpp
@@ -45,7 +45,7 @@ class KeyValue final : public server::handlers::HttpHandlerBase {
     storages::redis::SubscribeClientPtr subscribe_client_;
     storages::redis::SubscriptionToken subscription_token_;
     storages::redis::CommandControl redis_cc_{};
-    std::atomic_int values_posted{0};
+    std::atomic_int values_posted_{0};
 };
 
 KeyValue::KeyValue(const components::ComponentConfig& config, const components::ComponentContext& context)
@@ -57,7 +57,7 @@ KeyValue::KeyValue(const components::ComponentConfig& config, const components::
     subscription_token_ =
         subscribe_client_->Subscribe(kPostChannel, [&](const std::string& channel, const std::string& message) {
             LOG_INFO() << channel << ": " << message;
-            ++values_posted;
+            ++values_posted_;
         });
 }
 
diff --git a/redis/include/userver/storages/redis/client.hpp b/redis/include/userver/storages/redis/client.hpp
index ae9aff5d31c9..e2bb76bace91 100644
--- a/redis/include/userver/storages/redis/client.hpp
+++ b/redis/include/userver/storages/redis/client.hpp
@@ -16,6 +16,7 @@
 #include <userver/storages/redis/request.hpp>
 #include <userver/storages/redis/request_eval.hpp>
 #include <userver/storages/redis/request_evalsha.hpp>
+#include <userver/storages/redis/request_generic.hpp>
 #include <userver/storages/redis/transaction.hpp>
 
 USERVER_NAMESPACE_BEGIN
@@ -107,6 +108,22 @@ class Client {
             EvalShaCommon(std::move(script_hash), std::move(keys), std::move(args), command_control)};
     }
 
+    /// @brief Execute a custom Redis command.
+    /// @param key_index Index of the key in the args vector used to determine the shard
+    ///
+    /// Sample usage:
+    /// @snippet redis/src/storages/redis/client_cluster_redistest.cpp  Sample generic command usage
+    template <typename ReplyType>
+    RequestGeneric<ReplyType> GenericCommand(
+        std::string command,
+        std::vector<std::string> args,
+        size_t key_index,
+        const CommandControl& command_control
+    ) {
+        return RequestGeneric<ReplyType>{
+            GenericCommon(std::move(command), std::move(args), key_index, command_control)};
+    }
+
     /// @brief Load the script to the server for further execution via EvalSha() member function.
     ///
     /// Sample usage:
@@ -131,11 +148,17 @@ class Client {
 
     virtual RequestExpire Expire(std::string key, std::chrono::seconds ttl, const CommandControl& command_control) = 0;
 
+    virtual RequestExpire
+    Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options, const CommandControl& command_control) = 0;
+
     virtual RequestGeoadd Geoadd(std::string key, GeoaddArg point_member, const CommandControl& command_control) = 0;
 
     virtual RequestGeoadd
     Geoadd(std::string key, std::vector<GeoaddArg> point_members, const CommandControl& command_control) = 0;
 
+    virtual RequestGeopos
+    Geopos(std::string key, std::vector<std::string> members, const CommandControl& command_control) = 0;
+
     virtual RequestGeoradius Georadius(
         std::string key,
         Longitude lon,
@@ -517,6 +540,12 @@ class Client {
         std::vector<std::string> args,
         const CommandControl& command_control
     ) = 0;
+    virtual RequestGenericCommon GenericCommon(
+        std::string command,
+        std::vector<std::string> args,
+        size_t key_index,
+        const CommandControl& command_control
+    ) = 0;
 };
 
 std::string CreateTmpKey(const std::string& key, std::string prefix);
diff --git a/redis/include/userver/storages/redis/command_options.hpp b/redis/include/userver/storages/redis/command_options.hpp
index 048b4931a572..1cc4b017a359 100644
--- a/redis/include/userver/storages/redis/command_options.hpp
+++ b/redis/include/userver/storages/redis/command_options.hpp
@@ -174,7 +174,7 @@ class ScanOptionsGeneric {
     std::optional<Count> count_;
 };
 
-template <ScanTag scan_tag>
+template <ScanTag TScanTag>
 using ScanOptionsTmpl [[deprecated("Just use ScanOptionsGeneric")]] = ScanOptionsGeneric;
 
 using ScanOptions = ScanOptionsGeneric;
@@ -190,6 +190,29 @@ struct SetOptions {
     Exist exist = Exist::kSetAlways;
 };
 
+struct ExpireOptions {
+    enum class Exist { kSetAlways, kSetIfNotExist, kSetIfExist };
+    enum class Compare { kNone, kGreaterThan, kLessThan };
+
+    ExpireOptions() = default;
+    constexpr ExpireOptions(Exist exist, Compare compare = Compare::kNone) : exist(exist), compare(compare) {
+        if (exist == Exist::kSetIfNotExist && compare != Compare::kNone) {
+            // @see https://redis-docs.ru/commands/expire/
+            throw std::invalid_argument("When exist is kSetIfNotExist, compare must be kNone");
+        }
+    }
+
+    constexpr ExpireOptions(Compare compare, Exist exist = Exist::kSetAlways) : exist(exist), compare(compare) {
+        if (exist == Exist::kSetIfNotExist && compare != Compare::kNone) {
+            // @see https://redis-docs.ru/commands/expire/
+            throw std::invalid_argument("When exist is kSetIfNotExist, compare must be kNone");
+        }
+    }
+
+    Exist exist = Exist::kSetAlways;
+    Compare compare = Compare::kNone;
+};
+
 struct ScoreOptions {
     bool withscores = false;
 };
diff --git a/redis/include/userver/storages/redis/component.hpp b/redis/include/userver/storages/redis/component.hpp
index c50e4a40ec74..ab9e7439baf7 100644
--- a/redis/include/userver/storages/redis/component.hpp
+++ b/redis/include/userver/storages/redis/component.hpp
@@ -100,6 +100,7 @@ namespace components {
 ///     "some_name_of_your_database": {
 ///       "password": "the_password_of_your_database",
 ///       "sentinel_password": "the_password_for_sentinels_if_any",
+///       "secure_connection": false,
 ///       "sentinels": [
 ///         {"host": "the_host1_of_your_database", "port": 11564}
 ///       ],
diff --git a/redis/include/userver/storages/redis/parse_reply.hpp b/redis/include/userver/storages/redis/parse_reply.hpp
index db572195b944..a2fe0916ff8b 100644
--- a/redis/include/userver/storages/redis/parse_reply.hpp
+++ b/redis/include/userver/storages/redis/parse_reply.hpp
@@ -66,6 +66,9 @@ ParseReplyDataArray(ReplyData&& array_data, const std::string& request_descripti
 std::vector<GeoPoint>
 ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<GeoPoint>>);
 
+std::vector<std::optional<Point>>
+ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::optional<Point>>>);
+
 std::string Parse(ReplyData&& reply_data, const std::string& request_description, To<std::string>);
 
 double Parse(ReplyData&& reply_data, const std::string& request_description, To<double>);
@@ -91,6 +94,8 @@ bool Parse(ReplyData&& reply_data, const std::string& request_description, To<st
 
 void Parse(ReplyData&& reply_data, const std::string& request_description, To<StatusPong, void>);
 
+Point Parse(ReplyData&& reply_data, const std::string& request_description, To<Point>);
+
 SetReply Parse(ReplyData&& reply_data, const std::string& request_description, To<SetReply>);
 
 std::unordered_set<std::string>
diff --git a/redis/include/userver/storages/redis/request.hpp b/redis/include/userver/storages/redis/request.hpp
index 99efd0acc4b6..fc7566a81f8c 100644
--- a/redis/include/userver/storages/redis/request.hpp
+++ b/redis/include/userver/storages/redis/request.hpp
@@ -21,7 +21,7 @@ USERVER_NAMESPACE_BEGIN
 
 namespace storages::redis {
 
-template <ScanTag scan_tag>
+template <ScanTag TScanTag>
 class RequestScanData;
 
 /// @brief Valkey or Redis future for a non-scan and non-eval responses.
@@ -56,9 +56,12 @@ class [[nodiscard]] Request final {
     template <typename T1, typename T2>
     friend class RequestEvalSha;
 
-    template <ScanTag scan_tag>
+    template <ScanTag TScanTag>
     friend class RequestScanData;
 
+    template <typename T1>
+    friend class RequestGeneric;
+
 private:
     ReplyPtr GetRaw() { return impl_->GetRaw(); }
 
@@ -69,12 +72,12 @@ class [[nodiscard]] Request final {
 ///
 /// Member functions of classes storages::redis::Client and storages::redis::Transaction that do send SCAN-like request
 /// to the Redis return this type or storages::redis::ScanRequest.
-template <ScanTag scan_tag>
+template <ScanTag TScanTag>
 class ScanRequest final {
 public:
-    using ReplyElem = typename ScanReplyElem<scan_tag>::type;
+    using ReplyElem = typename ScanReplyElem<TScanTag>::type;
 
-    explicit ScanRequest(std::unique_ptr<RequestScanDataBase<scan_tag>>&& impl) : impl_(std::move(impl)) {}
+    explicit ScanRequest(std::unique_ptr<RequestScanDataBase<TScanTag>>&& impl) : impl_(std::move(impl)) {}
 
     template <typename T = std::vector<ReplyElem>>
     T GetAll(std::string request_description) {
@@ -154,7 +157,7 @@ class ScanRequest final {
 
     friend class Iterator;
 
-    std::unique_ptr<RequestScanDataBase<scan_tag>> impl_;
+    std::unique_ptr<RequestScanDataBase<TScanTag>> impl_;
 };
 
 /// @name Valkey/Redis futures aliases
@@ -165,6 +168,7 @@ using RequestDbsize = Request<size_t>;
 using RequestDecr = Request<int64_t>;
 using RequestDel = Request<size_t>;
 using RequestUnlink = Request<size_t>;
+using RequestGenericCommon = Request<ReplyData>;
 using RequestEvalCommon = Request<ReplyData>;
 using RequestEvalShaCommon = Request<ReplyData>;
 using RequestScriptLoad = Request<std::string>;
@@ -172,6 +176,7 @@ using RequestExec = Request<ReplyData, void>;
 using RequestExists = Request<size_t>;
 using RequestExpire = Request<ExpireReply>;
 using RequestGeoadd = Request<size_t>;
+using RequestGeopos = Request<std::vector<std::optional<Point>>>;
 using RequestGeoradius = Request<std::vector<GeoPoint>>;
 using RequestGeosearch = Request<std::vector<GeoPoint>>;
 using RequestGet = Request<std::optional<std::string>>;
diff --git a/redis/include/userver/storages/redis/request_data_base.hpp b/redis/include/userver/storages/redis/request_data_base.hpp
index 4803095e5967..6629a731c74d 100644
--- a/redis/include/userver/storages/redis/request_data_base.hpp
+++ b/redis/include/userver/storages/redis/request_data_base.hpp
@@ -32,10 +32,10 @@ class RequestDataBase {
     virtual engine::impl::ContextAccessor* TryGetContextAccessor() noexcept = 0;
 };
 
-template <ScanTag scan_tag>
+template <ScanTag TScanTag>
 class RequestScanDataBase {
 public:
-    using ReplyElem = typename ScanReplyElem<scan_tag>::type;
+    using ReplyElem = typename ScanReplyElem<TScanTag>::type;
 
     virtual ~RequestScanDataBase() = default;
 
diff --git a/redis/include/userver/storages/redis/request_generic.hpp b/redis/include/userver/storages/redis/request_generic.hpp
new file mode 100644
index 000000000000..cc90c4c88fac
--- /dev/null
+++ b/redis/include/userver/storages/redis/request_generic.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+/// @file
+/// @brief @copybrief storages::redis::RequestGeneric
+
+#include <userver/storages/redis/parse_reply.hpp>
+#include <userver/storages/redis/reply.hpp>
+#include <userver/storages/redis/request.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace storages::redis {
+
+/// @brief Redis future for generic command responses.
+/// Can be used to request custom modules commands or unsupported yet commands
+template <typename ReplyType>
+class [[nodiscard]] RequestGeneric final {
+public:
+    explicit RequestGeneric(RequestGenericCommon&& request) : request_(std::move(request)) {}
+
+    void Wait() { request_.Wait(); }
+
+    void IgnoreResult() const { request_.IgnoreResult(); }
+
+    ReplyType Get(const std::string& request_description = {}) {
+        return impl::ParseReply<ReplyType, ReplyType>(request_.GetRaw(), request_description);
+    }
+
+    /// @cond
+    /// Internal helper for WaitAny/WaitAll
+    engine::impl::ContextAccessor* TryGetContextAccessor() noexcept { return request_.TryGetContextAccessor(); }
+    /// @endcond
+
+private:
+    RequestGenericCommon request_;
+};
+
+}  // namespace storages::redis
+
+USERVER_NAMESPACE_END
diff --git a/redis/include/userver/storages/redis/transaction.hpp b/redis/include/userver/storages/redis/transaction.hpp
index ad3c70136abc..fc5082d19503 100644
--- a/redis/include/userver/storages/redis/transaction.hpp
+++ b/redis/include/userver/storages/redis/transaction.hpp
@@ -65,10 +65,14 @@ class Transaction {
 
     virtual RequestExpire Expire(std::string key, std::chrono::seconds ttl) = 0;
 
+    virtual RequestExpire Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options) = 0;
+
     virtual RequestGeoadd Geoadd(std::string key, GeoaddArg point_member) = 0;
 
     virtual RequestGeoadd Geoadd(std::string key, std::vector<GeoaddArg> point_members) = 0;
 
+    virtual RequestGeopos Geopos(std::string key, std::vector<std::string> members) = 0;
+
     virtual RequestGeoradius Georadius(
         std::string key,
         Longitude lon,
diff --git a/redis/include/userver/storages/redis/ttl_reply.hpp b/redis/include/userver/storages/redis/ttl_reply.hpp
index a6e12dc5b2d2..1acf10bae483 100644
--- a/redis/include/userver/storages/redis/ttl_reply.hpp
+++ b/redis/include/userver/storages/redis/ttl_reply.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <chrono>
 #include <cstdint>
 #include <string>
 
@@ -24,7 +25,8 @@ class TtlReply final {
 
     bool KeyExists() const;
     bool KeyHasExpiration() const;
-    size_t GetExpireSeconds() const;
+    [[deprecated("Use GetExpire() instead")]] size_t GetExpireSeconds() const { return GetExpire().count(); }
+    std::chrono::seconds GetExpire() const;
 
 private:
     int64_t value_;
diff --git a/redis/src/storages/redis/client_impl.cpp b/redis/src/storages/redis/client_impl.cpp
index b861a70899d5..1a5d45917ab9 100644
--- a/redis/src/storages/redis/client_impl.cpp
+++ b/redis/src/storages/redis/client_impl.cpp
@@ -63,17 +63,17 @@ Request<ScanReplyTmpl<ScanTag::kScan>> ClientImpl::MakeScanRequestNoKey(
     );
 }
 
-template <ScanTag scan_tag>
-Request<ScanReplyTmpl<scan_tag>> ClientImpl::MakeScanRequestWithKey(
+template <ScanTag TScanTag>
+Request<ScanReplyTmpl<TScanTag>> ClientImpl::MakeScanRequestWithKey(
     std::string key,
     size_t shard,
-    typename ScanReplyTmpl<scan_tag>::Cursor cursor,
+    typename ScanReplyTmpl<TScanTag>::Cursor cursor,
     ScanOptionsGeneric options,
     const CommandControl& command_control
 ) {
     CmdArgs cmd_args{
-        kScanCommandName<scan_tag>, std::move(key), cursor.GetValue(), options.ExtractMatch(), options.ExtractCount()};
-    return CreateRequest<Request<ScanReplyTmpl<scan_tag>>>(
+        kScanCommandName<TScanTag>, std::move(key), cursor.GetValue(), options.ExtractMatch(), options.ExtractCount()};
+    return CreateRequest<Request<ScanReplyTmpl<TScanTag>>>(
         MakeRequest(std::move(cmd_args), shard, false, GetCommandControl(command_control))
     );
 }
@@ -181,6 +181,18 @@ RequestEvalShaCommon ClientImpl::EvalShaCommon(
     ));
 }
 
+RequestGenericCommon ClientImpl::GenericCommon(
+    std::string command,
+    std::vector<std::string> args,
+    size_t key_index,
+    const CommandControl& command_control
+) {
+    size_t shard = ShardByKey(args.at(key_index), command_control);
+    return CreateRequest<RequestGenericCommon>(
+        MakeRequest(CmdArgs{command, std::move(args)}, shard, true, GetCommandControl(command_control))
+    );
+}
+
 RequestScriptLoad ClientImpl::ScriptLoad(std::string script, size_t shard, const CommandControl& command_control) {
     return CreateRequest<RequestScriptLoad>(
         MakeRequest(CmdArgs{"script", "load", std::move(script)}, shard, true, GetCommandControl(command_control))
@@ -209,6 +221,18 @@ RequestExpire ClientImpl::Expire(std::string key, std::chrono::seconds ttl, cons
     );
 }
 
+RequestExpire ClientImpl::Expire(
+    std::string key,
+    std::chrono::seconds ttl,
+    ExpireOptions options,
+    const CommandControl& command_control
+) {
+    const auto shard = ShardByKey(key, command_control);
+    return CreateRequest<RequestExpire>(MakeRequest(
+        CmdArgs{"expire", std::move(key), ttl.count(), options}, shard, true, GetCommandControl(command_control)
+    ));
+}
+
 RequestGeoadd ClientImpl::Geoadd(std::string key, GeoaddArg point_member, const CommandControl& command_control) {
     auto shard = ShardByKey(key, command_control);
     return CreateRequest<RequestGeoadd>(MakeRequest(
@@ -224,6 +248,16 @@ ClientImpl::Geoadd(std::string key, std::vector<GeoaddArg> point_members, const
     ));
 }
 
+RequestGeopos
+ClientImpl::Geopos(std::string key, std::vector<std::string> members, const CommandControl& command_control) {
+    if (members.empty())
+        return CreateDummyRequest<RequestGeopos>(std::make_shared<Reply>("geopos", ReplyData::Array{}));
+    const auto shard = ShardByKey(key, command_control);
+    return CreateRequest<RequestGeopos>(MakeRequest(
+        CmdArgs{"geopos", std::move(key), std::move(members)}, shard, false, GetCommandControl(command_control)
+    ));
+}
+
 RequestGeoradius ClientImpl::Georadius(
     std::string key,
     Longitude lon,
@@ -702,11 +736,11 @@ ScanRequest<ScanTag::kScan> ClientImpl::Scan(size_t shard, ScanOptions options,
     ));
 }
 
-template <ScanTag scan_tag>
-ScanRequest<scan_tag>
+template <ScanTag TScanTag>
+ScanRequest<TScanTag>
 ClientImpl::ScanTmpl(std::string key, ScanOptionsGeneric options, const CommandControl& command_control) {
     auto shard = ShardByKey(key, command_control);
-    return ScanRequest<scan_tag>(std::make_unique<RequestScanData<scan_tag>>(
+    return ScanRequest<TScanTag>(std::make_unique<RequestScanData<TScanTag>>(
         shared_from_this(), std::move(key), shard, std::move(options), command_control
     ));
 }
diff --git a/redis/src/storages/redis/client_impl.hpp b/redis/src/storages/redis/client_impl.hpp
index 10eaf1d81e22..e6ecbe673cfb 100644
--- a/redis/src/storages/redis/client_impl.hpp
+++ b/redis/src/storages/redis/client_impl.hpp
@@ -45,11 +45,11 @@ class ClientImpl final : public Client, public std::enable_shared_from_this<Clie
         const CommandControl& command_control
     );
 
-    template <ScanTag scan_tag>
-    Request<ScanReplyTmpl<scan_tag>> MakeScanRequestWithKey(
+    template <ScanTag TScanTag>
+    Request<ScanReplyTmpl<TScanTag>> MakeScanRequestWithKey(
         std::string key,
         size_t shard,
-        typename ScanReplyTmpl<scan_tag>::Cursor cursor,
+        typename ScanReplyTmpl<TScanTag>::Cursor cursor,
         ScanOptionsGeneric options,
         const CommandControl& command_control
     );
@@ -89,6 +89,12 @@ class ClientImpl final : public Client, public std::enable_shared_from_this<Clie
         std::vector<std::string> args,
         const CommandControl& command_control
     ) override;
+    RequestGenericCommon GenericCommon(
+        std::string command,
+        std::vector<std::string> args,
+        size_t key_index,
+        const CommandControl& command_control
+    ) override;
     RequestScriptLoad ScriptLoad(std::string script, size_t shard, const CommandControl& command_control) override;
 
     RequestExists Exists(std::string key, const CommandControl& command_control) override;
@@ -97,11 +103,21 @@ class ClientImpl final : public Client, public std::enable_shared_from_this<Clie
 
     RequestExpire Expire(std::string key, std::chrono::seconds ttl, const CommandControl& command_control) override;
 
+    RequestExpire Expire(
+        std::string key,
+        std::chrono::seconds ttl,
+        ExpireOptions options,
+        const CommandControl& command_control
+    ) override;
+
     RequestGeoadd Geoadd(std::string key, GeoaddArg point_member, const CommandControl& command_control) override;
 
     RequestGeoadd Geoadd(std::string key, std::vector<GeoaddArg> point_members, const CommandControl& command_control)
         override;
 
+    RequestGeopos Geopos(std::string key, std::vector<std::string> members, const CommandControl& command_control)
+        override;
+
     RequestGeoradius Georadius(
         std::string key,
         Longitude lon,
@@ -255,8 +271,8 @@ class ClientImpl final : public Client, public std::enable_shared_from_this<Clie
 
     ScanRequest<ScanTag::kScan> Scan(size_t shard, ScanOptions options, const CommandControl& command_control) override;
 
-    template <ScanTag scan_tag>
-    ScanRequest<scan_tag> ScanTmpl(std::string key, ScanOptionsGeneric options, const CommandControl& command_control);
+    template <ScanTag TScanTag>
+    ScanRequest<TScanTag> ScanTmpl(std::string key, ScanOptionsGeneric options, const CommandControl& command_control);
 
     RequestScard Scard(std::string key, const CommandControl& command_control) override;
 
diff --git a/redis/src/storages/redis/client_redistest.cpp b/redis/src/storages/redis/client_redistest.cpp
index dd4e30e3aed7..bf68672c03be 100644
--- a/redis/src/storages/redis/client_redistest.cpp
+++ b/redis/src/storages/redis/client_redistest.cpp
@@ -7,6 +7,9 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
+using storages::redis::ExpireOptions;
+using storages::redis::ExpireReply;
+
 /// [Sample Redis Client usage]
 void RedisClientSampleUsage(storages::redis::Client& client) {
     client.Rpush("sample_list", "a", {}).Get();
@@ -238,6 +241,23 @@ UTEST_F(RedisClientTest, EvalSha) {
     EXPECT_EQ(result_array[0], "key1");
 }
 
+UTEST_F(RedisClientTest, Generic) {
+    auto client = GetClient();
+    const storages::redis::CommandControl kCommandControl{};
+    constexpr size_t kKeyIndex = 0;
+    UEXPECT_NO_THROW(client->GenericCommand<void>("set", {"key0", "foo"}, kKeyIndex, kCommandControl).Wait());
+    EXPECT_EQ(client->GenericCommand<std::string>("get", {"key0"}, kKeyIndex, kCommandControl).Get(), "foo");
+    EXPECT_EQ(
+        client->GenericCommand<int64_t>("LPUSH", {"list", "1", "2", "3", "4"}, kKeyIndex, kCommandControl).Get(), 4
+    );
+    const std::vector<std::string> kExpected{"4", "3", "2", "1"};
+    EXPECT_EQ(
+        client->GenericCommand<std::vector<std::string>>("LRANGE", {"list", "0", "-1"}, kKeyIndex, kCommandControl)
+            .Get(),
+        kExpected
+    );
+}
+
 UTEST_F(RedisClientTest, Exists) {
     auto client = GetClient();
     client->Set("key1", "Hello", {}).Get();
@@ -253,11 +273,124 @@ UTEST_F(RedisClientTest, Expire) {
     EXPECT_EQ(
         client->Expire("mykey", std::chrono::seconds(10), {}).Get(), storages::redis::ExpireReply::kTimeoutWasSet
     );
-    EXPECT_EQ(client->Ttl("mykey", {}).Get().GetExpireSeconds(), 10);
+    EXPECT_EQ(client->Ttl("mykey", {}).Get().GetExpire().count(), 10);
     client->Set("mykey", "Hello World", {}).Get();
     EXPECT_FALSE(client->Ttl("mykey", {}).Get().KeyHasExpiration());
 }
 
+struct RedisExpireOptionsTestCase {
+    std::optional<int> initial_expire;
+    int new_expire;
+    ExpireOptions options;
+    storages::redis::ExpireReply expected_reply;
+};
+
+class RedisExpireOptionsTest : public RedisClientTest,
+                               public ::testing::WithParamInterface<RedisExpireOptionsTestCase> {};
+
+UTEST_P(RedisExpireOptionsTest, ExpireOptionsTest) {
+    const Version since{7, 0, 0};
+    if (!CheckVersion(since)) GTEST_SKIP() << SkipMsgByVersion("Expire options", since);
+
+    auto client = GetClient();
+    auto [initial_expire, new_expire, options, expected_reply] = GetParam();
+
+    client->Set("mykey", "Hello", {}).Get();
+    if (initial_expire.has_value()) {
+        client->Expire("mykey", std::chrono::seconds(initial_expire.value()), {}).Get();
+    }
+    EXPECT_EQ(client->Expire("mykey", std::chrono::seconds(new_expire), options, {}).Get(), expected_reply);
+
+    switch (expected_reply) {
+        case ExpireReply::kKeyDoesNotExist:
+            if (initial_expire.has_value()) {
+                EXPECT_EQ(client->Ttl("mykey", {}).Get().GetExpire().count(), initial_expire.value());
+            } else {
+                EXPECT_FALSE(client->Ttl("mykey", {}).Get().KeyHasExpiration());
+            }
+            break;
+        case ExpireReply::kTimeoutWasSet:
+            EXPECT_EQ(client->Ttl("mykey", {}).Get().GetExpire().count(), new_expire);
+            break;
+    }
+}
+
+INSTANTIATE_UTEST_SUITE_P(
+    RedisClientTest,
+    RedisExpireOptionsTest,
+    testing::Values(
+        // initial_expire, new_expire, options, expected_reply
+        RedisExpireOptionsTestCase{
+            std::nullopt,
+            10,
+            ExpireOptions(ExpireOptions::Compare::kGreaterThan),
+            ExpireReply::kKeyDoesNotExist},
+        RedisExpireOptionsTestCase{
+            9,
+            10,
+            ExpireOptions(ExpireOptions::Compare::kGreaterThan),
+            ExpireReply::kTimeoutWasSet},
+        RedisExpireOptionsTestCase{
+            11,
+            10,
+            ExpireOptions(ExpireOptions::Compare::kGreaterThan),
+            ExpireReply::kKeyDoesNotExist},
+
+        RedisExpireOptionsTestCase{
+            std::nullopt,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan),
+            ExpireReply::kTimeoutWasSet},
+        RedisExpireOptionsTestCase{
+            std::nullopt,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan, ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kKeyDoesNotExist},
+        RedisExpireOptionsTestCase{
+            19,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan),
+            ExpireReply::kKeyDoesNotExist},
+        RedisExpireOptionsTestCase{
+            21,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan),
+            ExpireReply::kTimeoutWasSet},
+
+        RedisExpireOptionsTestCase{
+            std::nullopt,
+            30,
+            ExpireOptions(ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kKeyDoesNotExist},
+        RedisExpireOptionsTestCase{
+            29,
+            30,
+            ExpireOptions(ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kTimeoutWasSet},
+        RedisExpireOptionsTestCase{
+            31,
+            30,
+            ExpireOptions(ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kTimeoutWasSet},
+
+        RedisExpireOptionsTestCase{
+            std::nullopt,
+            40,
+            ExpireOptions(ExpireOptions::Exist::kSetIfNotExist),
+            ExpireReply::kTimeoutWasSet},
+        RedisExpireOptionsTestCase{
+            39,
+            40,
+            ExpireOptions(ExpireOptions::Exist::kSetIfNotExist),
+            ExpireReply::kKeyDoesNotExist},
+        RedisExpireOptionsTestCase{
+            41,
+            40,
+            ExpireOptions(ExpireOptions::Exist::kSetIfNotExist),
+            ExpireReply::kKeyDoesNotExist}
+    )
+);
+
 UTEST_F(RedisClientTest, Georadius) {
     auto client = GetClient();
     client->Geoadd("Sicily", {{13.361389, 38.115556, "Palermo"}, {15.087269, 37.502669, "Catania"}}, {}).Get();
@@ -279,6 +412,22 @@ UTEST_F(RedisClientTest, Georadius) {
     EXPECT_EQ(result[1].dist, 56.4413);
 }
 
+UTEST_F(RedisClientTest, Geopos) {
+    auto client = GetClient();
+    client->Geoadd("Sicily", {{13.1, 38.2, "Palermo"}, {15.3, 37.4, "Catania"}}, {}).Get();
+    const auto result =
+        client->Geopos("Sicily", std::vector<std::string>{"Palermo", "Catania", "NonExisting"}, {}).Get();
+    const auto kGeoTolerance = 1e-5;
+    EXPECT_EQ(result.size(), 3);
+    EXPECT_TRUE(result[0].has_value());
+    EXPECT_TRUE(result[1].has_value());
+    EXPECT_FALSE(result[2].has_value());
+    EXPECT_NEAR(result[0].value().lon, 13.1, kGeoTolerance);
+    EXPECT_NEAR(result[0].value().lat, 38.2, kGeoTolerance);
+    EXPECT_NEAR(result[1].value().lon, 15.3, kGeoTolerance);
+    EXPECT_NEAR(result[1].value().lat, 37.4, kGeoTolerance);
+}
+
 UTEST_F(RedisClientTest, Getset) {
     auto client = GetClient();
     EXPECT_EQ(client->Incr("key", {}).Get(), 1);
@@ -524,7 +673,7 @@ UTEST_F(RedisClientTest, Pexpire) {
     EXPECT_EQ(
         client->Pexpire("key", std::chrono::milliseconds{1999}, {}).Get(), storages::redis::ExpireReply::kTimeoutWasSet
     );
-    EXPECT_EQ(client->Ttl("key", {}).Get().GetExpireSeconds(), 2);
+    EXPECT_EQ(client->Ttl("key", {}).Get().GetExpire().count(), 2);
 }
 
 UTEST_F(RedisClientTest, Ping) {
@@ -610,7 +759,7 @@ UTEST_F(RedisClientTest, Setex) {
     auto client = GetClient();
 
     EXPECT_NO_THROW(client->Setex("key", std::chrono::seconds{10}, "value", {}).Get());
-    EXPECT_EQ(client->Ttl("key", {}).Get().GetExpireSeconds(), 10);
+    EXPECT_EQ(client->Ttl("key", {}).Get().GetExpire().count(), 10);
 }
 
 UTEST_F(RedisClientTest, Sismember) {
diff --git a/redis/src/storages/redis/impl/cluster_sentinel_impl.cpp b/redis/src/storages/redis/impl/cluster_sentinel_impl.cpp
index dc5525c9e9f1..783e8354cf0f 100644
--- a/redis/src/storages/redis/impl/cluster_sentinel_impl.cpp
+++ b/redis/src/storages/redis/impl/cluster_sentinel_impl.cpp
@@ -130,13 +130,13 @@ std::shared_ptr<const std::vector<std::string>> MakeShardNames() {
     return std::make_shared<const std::vector<std::string>>(std::move(shard_names));
 }
 
-void InvokeCommand(CommandPtr command, ReplyPtr&& reply) {
+void InvokeCommand(CommandPtr command, ReplyPtr&& reply, const logging::LogExtra& log_extra) {
     UASSERT(reply);
 
     if (reply->server_id.IsAny()) {
         reply->server_id = CommandControlImpl{command->control}.force_server_id;
     }
-    LOG_DEBUG() << "redis_request( " << CommandSpecialPrinter{command}
+    LOG_DEBUG() << log_extra << "redis_request( " << CommandSpecialPrinter{command}
                 << " ):" << (reply->status == ReplyStatus::kOk ? '+' : '-') << ":" << reply->time * 1000.0
                 << " cc: " << command->control.ToString() << command->GetLogExtra();
     ++command->invoke_counter;
@@ -144,10 +144,11 @@ void InvokeCommand(CommandPtr command, ReplyPtr&& reply) {
         command->callback(command, reply);
     } catch (const std::exception& ex) {
         UASSERT(!engine::current_task::IsTaskProcessorThread());
-        LOG_WARNING() << "exception in command->callback, cmd=" << reply->cmd << " " << ex << command->GetLogExtra();
+        LOG_WARNING() << log_extra << "exception in command->callback, cmd=" << reply->cmd << " " << ex
+                      << command->GetLogExtra();
     } catch (...) {
         UASSERT(!engine::current_task::IsTaskProcessorThread());
-        LOG_WARNING() << "exception in command->callback, cmd=" << reply->cmd << command->GetLogExtra();
+        LOG_WARNING() << log_extra << "exception in command->callback, cmd=" << reply->cmd << command->GetLogExtra();
     }
 }
 
@@ -239,7 +240,8 @@ class ClusterTopologyHolder final : public TopologyHolderBase {
           is_topology_received_(false),
           update_cluster_slots_flag_(false),
           connection_security_(connection_security) {
-        LOG_DEBUG() << "Created ClusterTopologyHolder, shard_group_name=" << shard_group_name_;
+        log_extra_.Extend("shard_group_name", shard_group_name_);
+        LOG_DEBUG() << log_extra_ << "Created ClusterTopologyHolder";
     }
 
     ~ClusterTopologyHolder() override = default;
@@ -261,7 +263,7 @@ class ClusterTopologyHolder final : public TopologyHolderBase {
         sentinels_ = std::make_shared<Shard>(std::move(shard_options));
 
         sentinels_->SignalInstanceStateChange().connect([this](ServerId id, Redis::State state) {
-            LOG_TRACE() << "Signaled server " << id.GetDescription() << " state=" << StateToString(state);
+            LOG_TRACE() << log_extra_ << "Signaled server " << id.GetDescription() << " state=" << StateToString(state);
             if (state != Redis::State::kInit) sentinels_process_state_update_watch_.Send();
         });
         sentinels_->SignalInstanceReady().connect([this](ServerId, bool /*readonly*/) {
@@ -400,6 +402,7 @@ class ClusterTopologyHolder final : public TopologyHolderBase {
     std::shared_ptr<engine::ev::ThreadPool> redis_thread_pool_;
 
     const std::string shard_group_name_;
+    logging::LogExtra log_extra_;
     concurrent::Variable<Password, std::mutex> password_;
     std::shared_ptr<const std::vector<std::string>> shards_names_;
     const std::vector<ConnectionInfo> conns_;
@@ -533,7 +536,7 @@ void ClusterTopologyHolder::ExploreNodes() {
         std::unordered_set<HostPort> host_ports_to_create;
 
         if (ParseClusterNodesResponse(reply, host_ports) != ClusterNodesResponseStatus::kOk) {
-            LOG_WARNING() << "Failed to parse CLUSTER NODES response";
+            LOG_WARNING() << log_extra_ << "Failed to parse CLUSTER NODES response";
             return;
         }
 
@@ -624,7 +627,7 @@ void ClusterSentinelImpl::ProcessWaitingCommands() {
         waiting_commands.swap(commands_);
     }
     if (!waiting_commands.empty()) {
-        LOG_INFO() << "ProcessWaitingCommands client=" << client_name_ << " shard_group_name=" << shard_group_name_
+        LOG_INFO() << log_extra_ << "ProcessWaitingCommands client=" << client_name_
                    << " waiting_commands.size()=" << waiting_commands.size();
     }
 
@@ -640,7 +643,7 @@ void ClusterSentinelImpl::ProcessWaitingCommands() {
                     ReplyStatus::kTimeoutError
                 );
                 statistics_internal_.redis_not_ready++;
-                InvokeCommand(command, std::move(reply));
+                InvokeCommand(command, std::move(reply), log_extra_);
             }
         } else {
             AsyncCommand(scommand, kDefaultPrevInstanceIdx);
@@ -665,7 +668,7 @@ void ClusterSentinelImpl::ProcessWaitingCommandsOnStop() {
                 ReplyStatus::kTimeoutError
             );
             statistics_internal_.redis_not_ready++;
-            InvokeCommand(command, std::move(reply));
+            InvokeCommand(command, std::move(reply), log_extra_);
         }
     }
 }
@@ -679,12 +682,13 @@ std::shared_ptr<RedisConnectionHolder> ClusterTopologyHolder::CreateRedisInstanc
     const auto buffering_settings_ptr = commands_buffering_settings_.Lock();
     const auto replication_monitoring_settings_ptr = monitoring_settings_.Lock();
     const auto retry_budget_settings_ptr = retry_budget_settings_.Lock();
-    LOG_DEBUG() << "Create new redis instance " << host_port;
+    LOG_DEBUG() << log_extra_ << "Create new redis instance " << host_port;
     auto creation_settings = RedisConnectionHolder::makeDefaultRedisCreationSettings();
     creation_settings.connection_security = connection_security_;
     return RedisConnectionHolder::Create(
         ev_thread_,
         redis_thread_pool_,
+        shard_group_name_,
         host,
         port,
         GetPassword(),
@@ -707,7 +711,7 @@ std::shared_ptr<utils::FastScopeGuard<Callback>> MakeSharedScopeGuard(Callback c
 
 void ClusterTopologyHolder::UpdateClusterTopology() {
     if (!is_nodes_received_) {
-        LOG_DEBUG() << "Skip updating cluster topology: no nodes yet";
+        LOG_DEBUG() << log_extra_ << "Skip updating cluster topology: no nodes yet";
         return;
     };
     if (update_cluster_slots_flag_.exchange(true)) return;
@@ -719,24 +723,26 @@ void ClusterTopologyHolder::UpdateClusterTopology() {
     /// ...
     ProcessGetClusterHostsRequest(
         shards_names_,
-        GetClusterHostsRequest(*sentinels_, GetPassword()),
+        GetClusterHostsRequest(*sentinels_, GetPassword(), shard_group_name_),
         [this, reset{std::move(reset_update_cluster_slots_)}](
             ClusterShardHostInfos shard_infos, size_t requests_sent, size_t responses_parsed, bool is_non_cluster_error
         ) {
-            LOG_DEBUG() << "Parsing response from cluster slots: shard_infos.size(): " << shard_infos.size()
+            LOG_DEBUG() << log_extra_
+                        << "Parsing response from cluster slots: shard_infos.size(): " << shard_infos.size()
                         << ", requests_sent=" << requests_sent << ", responses_parsed=" << responses_parsed;
             const auto deferred = utils::FastScopeGuard([&]() noexcept { ++cluster_slots_call_counter_; });
             if (is_non_cluster_error) {
-                LOG_DEBUG() << "Non cluster error: shard_infos.size(): " << shard_infos.size();
+                LOG_DEBUG() << log_extra_ << "Non cluster error: shard_infos.size(): " << shard_infos.size();
                 throw std::runtime_error("Redis must be in cluster mode");
             }
             if (shard_infos.empty()) {
-                LOG_WARNING() << "Received empty topology";
+                LOG_WARNING() << log_extra_ << "Received empty topology";
                 return;
             }
 
             if (!CheckQuorum(requests_sent, responses_parsed)) {
-                LOG_WARNING() << "Too many 'cluster slots' requests failed: requests_sent=" << requests_sent
+                LOG_WARNING() << log_extra_
+                              << "Too many 'cluster slots' requests failed: requests_sent=" << requests_sent
                               << " responses_parsed=" << responses_parsed;
                 return;
             }
@@ -747,6 +753,11 @@ void ClusterTopologyHolder::UpdateClusterTopology() {
                     /// Nothing new here so do nothing
                     return;
                 }
+
+                if (temp_read_ptr->GetShardInfos().size() != shard_infos.size()) {
+                    LOG_WARNING() << log_extra_ << "Significant change of Redis cluster topology. From "
+                                  << temp_read_ptr->GetShardInfos().size() << " shards count to " << shard_infos.size();
+                }
             }
 
             auto topology = ClusterTopology(
@@ -756,6 +767,33 @@ void ClusterTopologyHolder::UpdateClusterTopology() {
                 redis_thread_pool_,
                 nodes_
             );
+
+            LOG_INFO() << log_extra_ << [&infos_list = topology.GetShardInfos()](auto& out) {
+                out << "New Redis cluster topology: ";
+                bool first_info_record = true;
+                for (const auto& info : infos_list) {
+                    if (!first_info_record) {
+                        out << "; ";
+                    }
+
+                    const auto& [host, port] = info.master.HostPort();
+                    out << "[" << host << "]:" << port << " master with replicas ";
+                    bool first_replica_record = true;
+                    for (const auto& replica_info : info.slaves) {
+                        const auto& [host, port] = replica_info.HostPort();
+                        if (!first_replica_record) {
+                            out << ", ";
+                        }
+
+                        out << "[" << host << "]:" << port;
+                        first_replica_record = false;
+                    }
+
+                    out << " for slots " << info.slot_intervals;
+                    first_info_record = false;
+                }
+            };
+
             /// Run in ev_thread because topology_.Assign can free some old
             /// topologies with their related redis connections, and these
             /// connections must be freed on "sentinel" thread.
@@ -765,14 +803,14 @@ void ClusterTopologyHolder::UpdateClusterTopology() {
                     topology_.Assign(std::move(topology));
                     signal_topology_changed_(new_shards_count);
                 } catch (const rcu::MissingKeyException& e) {
-                    LOG_WARNING() << "Failed to update cluster topology: " << e;
+                    LOG_WARNING() << log_extra_ << "Failed to update cluster topology: " << e;
                     return;
                 }
                 is_topology_received_ = true;
                 { const std::lock_guard lock{mutex_}; }  // do not lose the notify
                 cv_.NotifyAll();
 
-                LOG_DEBUG() << "Cluster topology updated to version" << current_topology_version_.load();
+                LOG_DEBUG() << log_extra_ << "Cluster topology updated to version" << current_topology_version_.load();
             });
         }
     );
@@ -818,16 +856,17 @@ ClusterSentinelImpl::ClusterSentinelImpl(
       redis_thread_pool_(redis_thread_pool),
       client_name_(client_name),
       dynamic_config_source_(std::move(dynamic_config_source)) {
+    log_extra_.Extend("shard_group_name", shard_group_name_);
     if (!key_shard) {
         topology_holder_ = std::make_unique<ClusterTopologyHolder>(
-            ev_thread_, redis_thread_pool, shard_group_name, password, shards, conns, connection_security
+            ev_thread_, redis_thread_pool, shard_group_name_, password, shards, conns, connection_security
         );
     } else {
-        LOG_DEBUG() << "Construct Standalone topology holder";
+        LOG_DEBUG() << log_extra_ << "Construct Standalone topology holder";
         UASSERT_MSG(conns.size() == 1, "In standalone mode we expect exactly one redis node to connect!");
         // TODO: TAXICOMMON-10376 experiment with providing kClusterDatabaseIndex other than 0 for standalone mode
         topology_holder_ = std::make_unique<StandaloneTopologyHolder>(
-            ev_thread_, redis_thread_pool, password, kClusterDatabaseIndex, conns.front()
+            ev_thread_, redis_thread_pool, shard_group_name, password, kClusterDatabaseIndex, conns.front()
         );
     }
 }
@@ -868,7 +907,7 @@ void ClusterSentinelImpl::WaitConnectedOnce(RedisWaitConnected wait_connected) {
         if (wait_connected.throw_on_fail)
             throw ClientNotConnectedException(msg);
         else {
-            LOG_WARNING() << msg << ", starting with not ready Redis client";
+            LOG_WARNING() << log_extra_ << msg << ", starting with not ready Redis client";
         }
     }
 }
@@ -898,7 +937,7 @@ void ClusterSentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t p
     if (!AdjustDeadline(scommand, dynamic_config_source_.GetSnapshot())) {
         auto reply =
             std::make_shared<Reply>("", ReplyData::CreateError("Deadline propagation"), ReplyStatus::kTimeoutError);
-        InvokeCommand(scommand.command, std::move(reply));
+        InvokeCommand(scommand.command, std::move(reply), log_extra_);
         return;
     }
 
@@ -923,7 +962,7 @@ void ClusterSentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t p
                 && ccommand->args.GetCommandCount() == 1 && !ccommand->args.begin()->IsSubscribeCommand();
 
             if (error_moved) {
-                LOG_DEBUG() << "MOVED c.instance_idx:" << ccommand->instance_idx << " shard: " << shard
+                LOG_DEBUG() << log_extra_ << "MOVED c.instance_idx:" << ccommand->instance_idx << " shard: " << shard
                             << " movedto:" << ParseMovedShard(reply->data.GetError()) << " args:" << ccommand->args;
                 this->topology_holder_->SendUpdateClusterTopology();
             }
@@ -939,14 +978,14 @@ void ClusterSentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t p
                 const size_t new_shard = shard;
                 size_t retries_left = cc.max_retries - 1;
                 if (error_ask || error_moved) {
-                    LOG_DEBUG() << "Got error '" << reply->data.GetError() << "' reply, cmd=" << reply->cmd
-                                << ", server=" << reply->server_id.GetDescription();
+                    LOG_DEBUG() << log_extra_ << "Got error '" << reply->data.GetError()
+                                << "' reply, cmd=" << reply->cmd << ", server=" << reply->server_id.GetDescription();
                     const auto& host_port = ParseMovedShard(reply->data.GetError());
                     command->counter++;
                     if (!command->redirected || (error_ask && !command->asking)) ++retries_left;
                     moved_to_instance = topology_holder_->GetRedisInstance(host_port);
                     if (!moved_to_instance) {
-                        LOG_WARNING() << "moved to unknown host " << host_port;
+                        LOG_WARNING() << log_extra_ << "moved to unknown host " << host_port;
                         /// Can we do something else?? We don't have client for this
                         /// redis instance
                         return;
@@ -991,7 +1030,7 @@ void ClusterSentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t p
             const std::chrono::duration<double> time = now - start;
             reply->time = time.count();
             command->args = std::move(ccommand->args);
-            InvokeCommand(command, std::move(reply));
+            InvokeCommand(command, std::move(reply), log_extra_);
             ccommand->args = std::move(command->args);
         },
         command->control,
@@ -1019,7 +1058,7 @@ size_t ClusterSentinelImpl::ShardByKey(const std::string& key) const {
 
 void ClusterSentinelImpl::Start() {
     Init();
-    LOG_DEBUG() << "Created ClusterSentinelImpl, shard_group_name=" << shard_group_name_;
+    LOG_DEBUG() << log_extra_ << "Created ClusterSentinelImpl";
 
     topology_holder_->Start();
     process_waiting_commands_timer_->Start();
diff --git a/redis/src/storages/redis/impl/cluster_sentinel_impl.hpp b/redis/src/storages/redis/impl/cluster_sentinel_impl.hpp
index 165a51ab54c1..6edd5885dfc4 100644
--- a/redis/src/storages/redis/impl/cluster_sentinel_impl.hpp
+++ b/redis/src/storages/redis/impl/cluster_sentinel_impl.hpp
@@ -79,6 +79,7 @@ class ClusterSentinelImpl : public SentinelImplBase {
     std::unique_ptr<TopologyHolderBase> topology_holder_;
 
     const std::string shard_group_name_;
+    logging::LogExtra log_extra_;
     const std::vector<ConnectionInfo> conns_;
 
     std::shared_ptr<engine::ev::ThreadPool> redis_thread_pool_;
diff --git a/redis/src/storages/redis/impl/cluster_subscription_storage.cpp b/redis/src/storages/redis/impl/cluster_subscription_storage.cpp
index 0ae15244671e..3669773b764f 100644
--- a/redis/src/storages/redis/impl/cluster_subscription_storage.cpp
+++ b/redis/src/storages/redis/impl/cluster_subscription_storage.cpp
@@ -26,7 +26,7 @@ void SubscribeImplImpl(
     SubscriptionId id
 ) {
     const auto& channel = channel_name.channel;
-    const std::lock_guard lock{storage_impl.mutex_};
+    const std::lock_guard lock{storage_impl.mutex};
     auto find_res = map.find(channel);
     if (find_res == map.end()) {
         const size_t selected_shard_idx = ClusterTopology::kUnknownShard;
@@ -70,19 +70,19 @@ ClusterSubscriptionStorage::~ClusterSubscriptionStorage() = default;
 void ClusterSubscriptionStorage::SetShardsCount(size_t shards_count) { storage_impl_.SetShardsCount(shards_count); }
 
 void ClusterSubscriptionStorage::SetSubscribeCallback(CommandCb cb) {
-    storage_impl_.subscribe_callback_ = std::move(cb);
+    storage_impl_.subscribe_callback = std::move(cb);
 }
 
 void ClusterSubscriptionStorage::SetUnsubscribeCallback(CommandCb cb) {
-    storage_impl_.unsubscribe_callback_ = std::move(cb);
+    storage_impl_.unsubscribe_callback = std::move(cb);
 }
 
 void ClusterSubscriptionStorage::SetShardedSubscribeCallback(ShardedCommandCb cb) {
-    storage_impl_.sharded_subscribe_callback_ = std::move(cb);
+    storage_impl_.sharded_subscribe_callback = std::move(cb);
 }
 
 void ClusterSubscriptionStorage::SetShardedUnsubscribeCallback(ShardedCommandCb cb) {
-    storage_impl_.sharded_unsubscribe_callback_ = std::move(cb);
+    storage_impl_.sharded_unsubscribe_callback = std::move(cb);
 }
 
 SubscriptionToken ClusterSubscriptionStorage::Subscribe(
@@ -122,7 +122,7 @@ RawPubsubClusterStatistics ClusterSubscriptionStorage::GetStatistics() const {
     RawPubsubClusterStatistics ret;
     /// We need only one shard's stats because GetShardStatistics() for ClusterSubscriptionStorage returns shared stats
     /// for all real shards.
-    const std::lock_guard lock{storage_impl_.mutex_};
+    const std::lock_guard lock{storage_impl_.mutex};
     if (storage_impl_.GetShardsCount(lock) > 0) ret.by_shard.push_back(storage_impl_.GetShardStatistics(0, lock));
     return ret;
 }
@@ -141,7 +141,7 @@ void ClusterSubscriptionStorage::RequestRebalance(size_t /*shard_idx*/, ServerWe
 
 void ClusterSubscriptionStorage::DoRebalance(size_t shard_idx, ServerWeights weights) {
     /// Rebalances subscriptions between instances of shard
-    const std::lock_guard lock{storage_impl_.mutex_};
+    const std::lock_guard lock{storage_impl_.mutex};
     if (shard_idx >= storage_impl_.GetShardsCount(lock) && shard_idx != ClusterTopology::kUnknownShard) {
         throw std::runtime_error(
             "requested rebalance for non-existing shard (" + std::to_string(shard_idx) +
@@ -158,9 +158,7 @@ void ClusterSubscriptionStorage::SubscribeImpl(
     SubscriptionId id
 ) {
     const ChannelName channel_name(channel, /*pattern=*/false, /*sharded=*/false);
-    SubscribeImplImpl<ChannelInfo>(
-        storage_impl_, storage_impl_.callback_map_, channel_name, std::move(cb), control, id
-    );
+    SubscribeImplImpl<ChannelInfo>(storage_impl_, storage_impl_.callback_map, channel_name, std::move(cb), control, id);
 }
 
 void ClusterSubscriptionStorage::SsubscribeImpl(
@@ -171,7 +169,7 @@ void ClusterSubscriptionStorage::SsubscribeImpl(
 ) {
     const ChannelName channel_name(channel, /*pattern=*/false, /*sharded=*/true);
     SubscribeImplImpl<ChannelInfo>(
-        storage_impl_, storage_impl_.sharded_callback_map_, channel_name, std::move(cb), control, id
+        storage_impl_, storage_impl_.sharded_callback_map, channel_name, std::move(cb), control, id
     );
 }
 
@@ -183,7 +181,7 @@ void ClusterSubscriptionStorage::PsubscribeImpl(
 ) {
     const ChannelName channel_name(pattern, /*pattern=*/true, /*sharded=*/false);
     SubscribeImplImpl<PChannelInfo>(
-        storage_impl_, storage_impl_.pattern_callback_map_, channel_name, std::move(cb), control, id
+        storage_impl_, storage_impl_.pattern_callback_map, channel_name, std::move(cb), control, id
     );
 }
 
diff --git a/redis/src/storages/redis/impl/cluster_subscription_storage_test.cpp b/redis/src/storages/redis/impl/cluster_subscription_storage_test.cpp
index 35b9ebefab15..a34106a56e32 100644
--- a/redis/src/storages/redis/impl/cluster_subscription_storage_test.cpp
+++ b/redis/src/storages/redis/impl/cluster_subscription_storage_test.cpp
@@ -25,7 +25,7 @@ class SubscriptionTest : public ::testing::Test {
     static void TearDownTestSuite() {}
 
     void SetUp() override {
-        storage_ = std::make_shared<storages::redis::impl::ClusterSubscriptionStorage>(kShardsCount);
+        storage_ = std::make_shared<storages::redis::impl::ClusterSubscriptionStorage>(kShardsCount_);
         auto sharded_subscribe_callback = [&](const std::string& /*channel*/, storages::redis::impl::CommandPtr cmd) {
             ASSERT_TRUE(cmd->control.force_server_id);
             const auto& host = cmd->control.force_server_id->GetDescription();
@@ -79,19 +79,19 @@ class SubscriptionTest : public ::testing::Test {
             );
             const storages::redis::ReplyPtr reply =
                 std::make_shared<storages::redis::Reply>(command, std::move(reply_data));
-            reply->server_id = server_ids[0];
+            reply->server_id = server_ids_[0];
             cmd->callback({}, reply);
         }
         cmds_.clear();
     }
 
-    void Rebalance(size_t shard) { storage_->DoRebalance(shard, weights); }
+    void Rebalance(size_t shard) { storage_->DoRebalance(shard, weights_); }
 
     const auto& GetSubscriptionsByHost() const { return subscriptions_by_host_; }
     const auto& GetShardedSubscriptionsByHost() const { return ssubscriptions_by_host_; }
 
 private:
-    const std::vector<storages::redis::ServerId> server_ids = std::vector{
+    const std::vector<storages::redis::ServerId> server_ids_ = std::vector{
         MakeServerId("host0"),
         MakeServerId("host1"),
         MakeServerId("host2"),
@@ -101,17 +101,17 @@ class SubscriptionTest : public ::testing::Test {
     };
 
     /// Which hosts do we have
-    const storages::redis::impl::ClusterSubscriptionStorage::ServerWeights weights = {
-        {server_ids[0], 1},
-        {server_ids[1], 1},
-        {server_ids[2], 1},
-        {server_ids[3], 1},
-        {server_ids[4], 1},
-        {server_ids[5], 1},
+    const storages::redis::impl::ClusterSubscriptionStorage::ServerWeights weights_ = {
+        {server_ids_[0], 1},
+        {server_ids_[1], 1},
+        {server_ids_[2], 1},
+        {server_ids_[3], 1},
+        {server_ids_[4], 1},
+        {server_ids_[5], 1},
 
     };
 
-    const size_t kShardsCount = 3;
+    const size_t kShardsCount_ = 3;
     std::shared_ptr<storages::redis::impl::ClusterSubscriptionStorage> storage_;
     std::unordered_map<std::string, size_t> subscriptions_by_host_;
     std::unordered_map<std::string, size_t> ssubscriptions_by_host_;
diff --git a/redis/src/storages/redis/impl/cmd_args.cpp b/redis/src/storages/redis/impl/cmd_args.cpp
index 12d9e8378897..5a55d0e2b192 100644
--- a/redis/src/storages/redis/impl/cmd_args.cpp
+++ b/redis/src/storages/redis/impl/cmd_args.cpp
@@ -141,6 +141,30 @@ void CmdWithArgs::PutArg(const SetOptions& arg) {
         args_.emplace_back("XX");
 }
 
+void CmdWithArgs::PutArg(const ExpireOptions& arg) {
+    switch (arg.exist) {
+        case ExpireOptions::Exist::kSetIfExist:
+            args_.emplace_back("XX");
+            break;
+        case ExpireOptions::Exist::kSetIfNotExist:
+            args_.emplace_back("NX");
+            break;
+        case ExpireOptions::Exist::kSetAlways:
+            break;
+    };
+
+    switch (arg.compare) {
+        case ExpireOptions::Compare::kGreaterThan:
+            args_.emplace_back("GT");
+            break;
+        case ExpireOptions::Compare::kLessThan:
+            args_.emplace_back("LT");
+            break;
+        case ExpireOptions::Compare::kNone:
+            break;
+    };
+}
+
 void CmdWithArgs::PutArg(const ZaddOptions& arg) {
     if (arg.exist == ZaddOptions::Exist::kAddIfNotExist)
         args_.emplace_back("NX");
diff --git a/redis/src/storages/redis/impl/cmd_args.hpp b/redis/src/storages/redis/impl/cmd_args.hpp
index 1cdbc1b98a2d..790ef559d46b 100644
--- a/redis/src/storages/redis/impl/cmd_args.hpp
+++ b/redis/src/storages/redis/impl/cmd_args.hpp
@@ -146,6 +146,7 @@ class CmdWithArgs {
     void PutArg(const ScoreOptions& arg);
     void PutArg(const RangeOptions& arg);
     void PutArg(const RangeScoreOptions& arg);
+    void PutArg(const ExpireOptions& arg);
 
     template <typename Arg>
     typename std::enable_if<std::is_arithmetic<Arg>::value, void>::type PutArg(const Arg& arg) {
diff --git a/redis/src/storages/redis/impl/command.cpp b/redis/src/storages/redis/impl/command.cpp
index a2739d044ee9..05cfa4132220 100644
--- a/redis/src/storages/redis/impl/command.cpp
+++ b/redis/src/storages/redis/impl/command.cpp
@@ -21,7 +21,7 @@ std::string ToLower(std::string_view str) {
 }  // namespace
 
 Command::Command(
-    CmdArgs&& _args,
+    CmdArgs&& l_args,
     ReplyCallback callback,
     CommandControl control,
     int counter,
@@ -30,7 +30,7 @@ Command::Command(
     bool redirected,
     bool read_only
 )
-    : args(std::move(_args)),
+    : args(std::move(l_args)),
       callback(std::move(callback)),
       log_extra(PrepareLogExtra()),
       control(control),
diff --git a/redis/src/storages/redis/impl/command.hpp b/redis/src/storages/redis/impl/command.hpp
index 9efe6b0710c1..c827e43e5335 100644
--- a/redis/src/storages/redis/impl/command.hpp
+++ b/redis/src/storages/redis/impl/command.hpp
@@ -15,7 +15,7 @@ using ReplyCallback = std::function<void(const CommandPtr& cmd, ReplyPtr reply)>
 
 struct Command {
     Command(
-        CmdArgs&& _args,
+        CmdArgs&& args,
         ReplyCallback callback,
         CommandControl control,
         int counter,
diff --git a/redis/src/storages/redis/impl/redis.cpp b/redis/src/storages/redis/impl/redis.cpp
index 9f12c8511b78..87a584ccfc5d 100644
--- a/redis/src/storages/redis/impl/redis.cpp
+++ b/redis/src/storages/redis/impl/redis.cpp
@@ -99,7 +99,8 @@ class Redis::RedisImpl : public std::enable_shared_from_this<Redis::RedisImpl> {
         const std::shared_ptr<engine::ev::ThreadPool>& thread_pool,
         const engine::ev::ThreadControl& thread_control,
         Redis& redis_obj,
-        const RedisCreationSettings& redis_settings
+        const RedisCreationSettings& redis_settings,
+        const std::string& shard_group_name
     );
     ~RedisImpl();
 
@@ -216,6 +217,7 @@ class Redis::RedisImpl : public std::enable_shared_from_this<Redis::RedisImpl> {
     SSLContextPtr ssl_context_;
 #endif
     std::atomic<State> state_{State::kInit};
+    std::string shard_group_name_;
     std::string host_;
     uint16_t port_ = 0;
     std::string server_;
@@ -269,9 +271,13 @@ std::string_view StateToString(RedisState state) {
     return state_str ? *state_str : "unknown";
 }
 
-Redis::Redis(const std::shared_ptr<engine::ev::ThreadPool>& thread_pool, const RedisCreationSettings& redis_settings)
+Redis::Redis(
+    const std::shared_ptr<engine::ev::ThreadPool>& thread_pool,
+    const RedisCreationSettings& redis_settings,
+    const std::string& shard_group_name
+)
     : thread_control_(thread_pool->NextThread()) {
-    impl_ = std::make_shared<RedisImpl>(thread_pool, thread_control_, *this, redis_settings);
+    impl_ = std::make_shared<RedisImpl>(thread_pool, thread_control_, *this, redis_settings, shard_group_name);
 }
 
 Redis::~Redis() {
@@ -331,21 +337,25 @@ Redis::RedisImpl::RedisImpl(
     const std::shared_ptr<engine::ev::ThreadPool>& thread_pool,
     const engine::ev::ThreadControl& thread_control,
     Redis& redis_obj,
-    const RedisCreationSettings& redis_settings
+    const RedisCreationSettings& redis_settings,
+    const std::string& shard_group_name
 )
     : redis_obj_(&redis_obj),
       ev_thread_control_(thread_control),
       thread_pool_(thread_pool),
+      shard_group_name_(shard_group_name),
       send_readonly_(redis_settings.send_readonly),
       connection_security_(redis_settings.connection_security),
       server_id_(ServerId::Generate()),
       retry_budget_(utils::RetryBudgetSettings{100, 0.1, false}) {
     SetCommandsBufferingSettings(CommandsBufferingSettings{});
-    LOG_DEBUG() << "RedisImpl() server_id=" << GetServerId().GetId();
+    log_extra_.Extend("shard_group_name", shard_group_name_);
+    log_extra_.Extend("server_id", GetServerId().GetId());
+    LOG_DEBUG() << "RedisImpl()" << log_extra_;
 }
 
 Redis::RedisImpl::~RedisImpl() {
-    LOG_DEBUG() << "~RedisImpl() server_id=" << GetServerId().GetId() << " server=" << GetServer();
+    LOG_DEBUG() << log_extra_ << "~RedisImpl() server=" << GetServer();
     server_id_.RemoveDescription();
 }
 
@@ -396,7 +406,8 @@ void Redis::RedisImpl::Connect(
     for (const auto& host : host_addrs)
         if (Connect(host, port, password, database_index)) return;
 
-    LOG_ERROR() << "error async connect to Redis server (host addrs =" << host_addrs << ", port=" << port << ")";
+    LOG_ERROR() << log_extra_ << "error async connect to Redis server (host addrs =" << host_addrs << ", port=" << port
+                << ")";
     SetState(State::kInitError);
 }
 
@@ -409,7 +420,6 @@ bool Redis::RedisImpl::Connect(const std::string& host, int port, const Password
     host_ = host;
     port_ = port;
     log_extra_.Extend("redis_server", GetServer());
-    log_extra_.Extend("server_id", GetServerId().GetId());
     password_ = password;
     database_index_ = database_index;
     LOG_INFO() << log_extra_ << "Async connect to Redis server=" << GetServer();
@@ -420,7 +430,7 @@ bool Redis::RedisImpl::Connect(const std::string& host, int port, const Password
     context_->data = this;
 
     if (context_->err) {
-        LOG_WARNING() << "error after redisAsyncConnect (host=" << host << ", port=" << port
+        LOG_WARNING() << log_extra_ << "error after redisAsyncConnect (host=" << host << ", port=" << port
                       << "): " << context_->errstr;
         redisAsyncFree(context_);
         context_ = nullptr;
@@ -429,10 +439,10 @@ bool Redis::RedisImpl::Connect(const std::string& host, int port, const Password
 
     ev_thread_control_.RunInEvLoopBlocking([this, &host]() {
         bool err = false;
-        auto CheckError = [&err, &host](int status, const std::string& name) {
+        auto CheckError = [&err, &host, this](int status, const std::string& name) {
             if (status != REDIS_OK) {
                 err = true;
-                LOG_ERROR() << "error in " << name << " with host " << host;
+                LOG_ERROR() << log_extra_ << "error in " << name << " with host " << host;
             }
         };
         if (!err) Attach();
@@ -488,6 +498,7 @@ void Redis::RedisImpl::InvokeCommand(const CommandPtr& command, ReplyPtr&& reply
     reply->server_id = server_id_;
     reply->log_extra.Extend("redis_server", server_);
     reply->log_extra.Extend("reply_status", ToString(reply->status));
+    reply->log_extra.Extend("shard_group_name", shard_group_name_);
 
     if (reply->IsLoggableError()) LogSocketErrorReply(command, reply);
 
@@ -500,7 +511,7 @@ void Redis::RedisImpl::InvokeCommand(const CommandPtr& command, ReplyPtr&& reply
     try {
         command->callback(command, reply);
     } catch (const std::exception& ex) {
-        LOG_WARNING() << "exception in callback handler (" << command->args << ") " << ex;
+        LOG_WARNING() << log_extra_ << "exception in callback handler (" << command->args << ") " << ex;
     }
 
     if (need_disconnect) Disconnect();
@@ -534,7 +545,7 @@ bool Redis::RedisImpl::WatchCommandTimerEnabled(const CommandsBufferingSettings&
 
 bool Redis::RedisImpl::AsyncCommand(const CommandPtr& command) {
     LOG_DEBUG() << "AsyncCommand for server_id=" << GetServerId().GetId()
-                << " server=" << GetServerId().GetDescription() << " cmd=" << command->args;
+                << " server=" << GetServerId().GetDescription() << " cmd=" << command->args << log_extra_;
     {
         const std::lock_guard<std::mutex> lock(command_mutex_);
         if (destroying_) return false;
@@ -551,7 +562,7 @@ void Redis::RedisImpl::OnTimerPing(struct ev_loop*, ev_timer* w, int) noexcept {
     try {
         impl->OnTimerPingImpl();
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnTimerPingImpl() failed: " << ex;
+        LOG_ERROR() << "OnTimerPingImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -561,7 +572,7 @@ void Redis::RedisImpl::OnTimerInfo(struct ev_loop*, ev_timer* w, int) noexcept {
     try {
         impl->OnTimerInfoImpl();
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnTimerInfoImpl() failed: " << ex;
+        LOG_ERROR() << "OnTimerInfoImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -571,7 +582,7 @@ void Redis::RedisImpl::OnCommandTimeout(struct ev_loop*, ev_timer* w, int) noexc
     try {
         impl->OnCommandTimeoutImpl(w);
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnCommandTimeoutImpl() failed: " << ex;
+        LOG_ERROR() << "OnCommandTimeoutImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -649,12 +660,13 @@ inline void Redis::RedisImpl::OnTimerInfoImpl() {
         CmdArgs{"INFO", "REPLICATION"},
         [this](const CommandPtr&, ReplyPtr reply) {
             if (!*reply) {
-                LOG_DEBUG() << "Failed to get INFO for server_id=" << GetServerId().GetId() << ", host=" << GetHost();
+                LOG_DEBUG() << "Failed to get INFO for server_id=" << GetServerId().GetId() << ", host=" << GetHost()
+                            << log_extra_;
                 return;
             }
             if (!reply->data.IsString()) {
                 LOG_DEBUG() << "Failed to get INFO for server_id=" << GetServerId().GetId() << ", host=" << GetHost()
-                            << ". reply data is not an string but " << reply->data.GetTypeString();
+                            << ". reply data is not an string but " << reply->data.GetTypeString() << log_extra_;
                 return;
             }
             const auto& value = reply->data.GetString();
@@ -719,14 +731,14 @@ void Redis::RedisImpl::OnConnectTimeout(struct ev_loop*, ev_timer* w, int) noexc
     try {
         impl->OnConnectTimeoutImpl();
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnConnectTimeoutImpl() failed: " << ex;
+        LOG_ERROR() << "OnConnectTimeoutImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
 void Redis::RedisImpl::OnConnectTimeoutImpl() {
     ev_thread_control_.Stop(connect_timer_);
 
-    LOG_WARNING() << "connect() to redis timeouted, server_id=" << GetServerId().GetId() << " server=" << GetServer();
+    LOG_WARNING() << "connect() to redis timeouted" << log_extra_;
     Disconnect();
 }
 
@@ -753,7 +765,8 @@ void Redis::RedisImpl::SetState(State state) {
     if (state == state_) return;
 
     if (IsFinalState(state_)) {
-        LOG_INFO() << "skipped SetState() from " << StateToString(state_) << " to " << StateToString(state);
+        LOG_INFO() << log_extra_ << "skipped SetState() from " << StateToString(state_) << " to "
+                   << StateToString(state);
         return;
     }
     LOG(StateChangeToLogLevel(state_, state))
@@ -839,7 +852,7 @@ void Redis::RedisImpl::CommandLoopOnTimer(struct ev_loop*, ev_timer* w, int) noe
     try {
         impl->CommandLoopImpl();
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "CommandLoopImpl() failed: " << ex;
+        LOG_ERROR() << "CommandLoopImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -867,7 +880,7 @@ void Redis::RedisImpl::OnConnect(const redisAsyncContext* c, int status) noexcep
     try {
         impl->OnConnectImpl(status);
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnConnectImpl() failed: " << ex;
+        LOG_ERROR() << "OnConnectImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -877,7 +890,7 @@ void Redis::RedisImpl::OnDisconnect(const redisAsyncContext* c, int status) noex
     try {
         impl->OnDisconnectImpl(status);
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnDisconnectImpl() failed: " << ex;
+        LOG_ERROR() << "OnDisconnectImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -901,7 +914,7 @@ void Redis::RedisImpl::OnConnectImpl(int status) {
 
     const int keep_alive_status = redisEnableKeepAlive(&context_->c);
     if (keep_alive_status != REDIS_OK) {
-        LOG_ERROR() << "redisEnableKeepAlive() failed. Hiredis errstr='"
+        LOG_ERROR() << log_extra_ << "redisEnableKeepAlive() failed. Hiredis errstr='"
                     << (keep_alive_status == REDIS_ERR ? context_->errstr : "") << '\'';
         Disconnect();
         return;
@@ -912,7 +925,7 @@ void Redis::RedisImpl::OnConnectImpl(int status) {
 
 void Redis::RedisImpl::OnDisconnectImpl(int status) {
     if (status == REDIS_ERR) {
-        LOG_LIMITED_WARNING() << "Got disconnect error from hiredis (" << context_->errstr
+        LOG_LIMITED_WARNING() << log_extra_ << "Got disconnect error from hiredis (" << context_->errstr
                               << "). For more information look in server logs ("
                                  "https://wiki.yandex-team.ru/taxi/backend/userver/redis/"
                                  "#logiservera).";
@@ -928,13 +941,13 @@ bool Redis::RedisImpl::InitSecureConnection() {
         redisSSLContextError ssl_error{};
         ssl_context_.reset(redisCreateSSLContext(nullptr, nullptr, nullptr, nullptr, nullptr, &ssl_error));
         if (!ssl_context_) {
-            LOG_ERROR() << "redisCreateSSLContext failed: " << redisSSLContextGetError(ssl_error);
+            LOG_ERROR() << log_extra_ << "redisCreateSSLContext failed: " << redisSSLContextGetError(ssl_error);
             return false;
         }
     }
 
     if (redisInitiateSSLWithContext(&context_->c, ssl_context_.get()) != REDIS_OK) {
-        LOG_ERROR() << "redisInitiateSSLWithContext failed. Hiredis errstr='" << context_->errstr << '\''
+        LOG_ERROR() << log_extra_ << "redisInitiateSSLWithContext failed. Hiredis errstr='" << context_->errstr << '\''
                     << " server=" << server_;
         return false;
     }
@@ -985,7 +998,8 @@ void Redis::RedisImpl::SendReadOnly() {
         return;
     }
 
-    LOG_DEBUG() << "Send READONLY command to slave " << GetServerId().GetDescription() << " in cluster mode";
+    LOG_DEBUG() << log_extra_ << "Send READONLY command to slave " << GetServerId().GetDescription()
+                << " in cluster mode";
     ProcessCommand(PrepareCommand(CmdArgs{"READONLY"}, [this](const CommandPtr&, ReplyPtr reply) {
         if (*reply && reply->data.IsStatus()) {
             SelectDatabase();
@@ -1048,7 +1062,7 @@ void Redis::RedisImpl::OnRedisReply(redisAsyncContext* c, void* r, void* privdat
             // Translate to something sensible.
             impl->OnRedisReplyImpl(nullptr, privdata, REDIS_ERR_EOF, "Disconnecting");
         } else if (redis_reply && redis_reply->type == REDIS_REPLY_ERROR && c->err == REDIS_OK) {
-            // redis_reply contains error that missmatch Reply status OK.
+            // redis_reply contains error that mismatch Reply status OK.
             // Fix the status here to pass the Reply UASSERT checks.
             UASSERT_MSG(
                 !c->errstr || c->errstr[0] == '\0', fmt::format("For OK status there's an error string: {}", c->errstr)
@@ -1058,7 +1072,7 @@ void Redis::RedisImpl::OnRedisReply(redisAsyncContext* c, void* r, void* privdat
             impl->OnRedisReplyImpl(redis_reply, privdata, c->err, c->errstr);
         }
     } catch (const std::exception& ex) {
-        LOG_ERROR() << "OnRedisReplyImpl() failed: " << ex;
+        LOG_ERROR() << "OnRedisReplyImpl() failed: " << ex << impl->log_extra_;
     }
 }
 
@@ -1099,7 +1113,7 @@ void Redis::RedisImpl::OnRedisReplyImpl(redisReply* redis_reply, void* privdata,
         if (!subscriber_) --sent_count_;
 
         if (subscriber_) {
-            LOG_DEBUG() << "server_id=" << GetServerId().GetId() << " erase privdata=" << data->first
+            LOG_DEBUG() << log_extra_ << "server_id=" << GetServerId().GetId() << " erase privdata=" << data->first
                         << " unsub=" << IsUnsubscribeReply(reply);
         }
         if (!pcommand->invoke_disabled) {
diff --git a/redis/src/storages/redis/impl/redis.hpp b/redis/src/storages/redis/impl/redis.hpp
index ecf92c2bd86b..76ada1e1752e 100644
--- a/redis/src/storages/redis/impl/redis.hpp
+++ b/redis/src/storages/redis/impl/redis.hpp
@@ -26,7 +26,11 @@ class Redis {
 public:
     using State = RedisState;
 
-    Redis(const std::shared_ptr<engine::ev::ThreadPool>& thread_pool, const RedisCreationSettings& redis_settings);
+    Redis(
+        const std::shared_ptr<engine::ev::ThreadPool>& thread_pool,
+        const RedisCreationSettings& redis_settings,
+        const std::string& shard_group_name
+    );
     ~Redis();
 
     Redis(Redis&& o) = delete;
diff --git a/redis/src/storages/redis/impl/redis_connection_holder.cpp b/redis/src/storages/redis/impl/redis_connection_holder.cpp
index 914b22ca1198..29690ab0e3d5 100644
--- a/redis/src/storages/redis/impl/redis_connection_holder.cpp
+++ b/redis/src/storages/redis/impl/redis_connection_holder.cpp
@@ -10,6 +10,7 @@ RedisConnectionHolder::RedisConnectionHolder(
     EmplaceEnabler,
     const engine::ev::ThreadControl& sentinel_thread_control,
     const std::shared_ptr<engine::ev::ThreadPool>& redis_thread_pool,
+    const std::string& shard_group_name,
     const std::string& host,
     uint16_t port,
     Password password,
@@ -24,6 +25,7 @@ RedisConnectionHolder::RedisConnectionHolder(
       retry_budget_settings_(std::move(retry_budget_settings)),
       ev_thread_(sentinel_thread_control),
       redis_thread_pool_(redis_thread_pool),
+      shard_group_name_(shard_group_name),
       host_(host),
       port_(port),
       password_(std::move(password)),
@@ -42,6 +44,7 @@ RedisConnectionHolder::~RedisConnectionHolder() {
 std::shared_ptr<RedisConnectionHolder> RedisConnectionHolder::Create(
     const engine::ev::ThreadControl& sentinel_thread_control,
     const std::shared_ptr<engine::ev::ThreadPool>& redis_thread_pool,
+    const std::string& shard_group_name,
     const std::string& host,
     uint16_t port,
     Password password,
@@ -55,6 +58,7 @@ std::shared_ptr<RedisConnectionHolder> RedisConnectionHolder::Create(
         EmplaceEnabler{},
         sentinel_thread_control,
         redis_thread_pool,
+        shard_group_name,
         host,
         port,
         std::move(password),
@@ -86,7 +90,7 @@ void RedisConnectionHolder::EnsureConnected() {
 }
 
 void RedisConnectionHolder::CreateConnection() {
-    auto instance = std::make_shared<Redis>(redis_thread_pool_, redis_creation_settings_);
+    auto instance = std::make_shared<Redis>(redis_thread_pool_, redis_creation_settings_, shard_group_name_);
     UASSERT(weak_from_this().lock());
     instance->signal_state_change.connect([weak_ptr{weak_from_this()}](Redis::State state) {
         const auto ptr = weak_ptr.lock();
diff --git a/redis/src/storages/redis/impl/redis_connection_holder.hpp b/redis/src/storages/redis/impl/redis_connection_holder.hpp
index bd3ac338414c..c07d4cd04c58 100644
--- a/redis/src/storages/redis/impl/redis_connection_holder.hpp
+++ b/redis/src/storages/redis/impl/redis_connection_holder.hpp
@@ -30,6 +30,7 @@ class RedisConnectionHolder final : public std::enable_shared_from_this<RedisCon
         EmplaceEnabler,
         const engine::ev::ThreadControl& sentinel_thread_control,
         const std::shared_ptr<engine::ev::ThreadPool>& redis_thread_pool,
+        const std::string& shard_group_name,
         const std::string& host,
         uint16_t port,
         Password password,
@@ -46,6 +47,7 @@ class RedisConnectionHolder final : public std::enable_shared_from_this<RedisCon
     static std::shared_ptr<RedisConnectionHolder> Create(
         const engine::ev::ThreadControl& sentinel_thread_control,
         const std::shared_ptr<engine::ev::ThreadPool>& redis_thread_pool,
+        const std::string& shard_group_name,
         const std::string& host,
         uint16_t port,
         Password password,
@@ -77,6 +79,7 @@ class RedisConnectionHolder final : public std::enable_shared_from_this<RedisCon
     concurrent::Variable<utils::RetryBudgetSettings, std::mutex> retry_budget_settings_;
     engine::ev::ThreadControl ev_thread_;
     std::shared_ptr<engine::ev::ThreadPool> redis_thread_pool_;
+    const std::string shard_group_name_;
     const std::string host_;
     const uint16_t port_;
     const Password password_;
diff --git a/redis/src/storages/redis/impl/redis_stats.cpp b/redis/src/storages/redis/impl/redis_stats.cpp
index 6f511a61b4ff..ab3b7f65b725 100644
--- a/redis/src/storages/redis/impl/redis_stats.cpp
+++ b/redis/src/storages/redis/impl/redis_stats.cpp
@@ -31,6 +31,7 @@ const std::string_view kCommandTypes[] = {
     "expire",
     "flushdb",
     "geoadd",
+    "geopos",
     "georadius_ro",
     "geosearch",
     "get",
diff --git a/redis/src/storages/redis/impl/reply.cpp b/redis/src/storages/redis/impl/reply.cpp
index a6e5cd18e6e0..2b2a4c3ca663 100644
--- a/redis/src/storages/redis/impl/reply.cpp
+++ b/redis/src/storages/redis/impl/reply.cpp
@@ -250,7 +250,7 @@ Reply::Reply(std::string command, ReplyData&& reply_data, ReplyStatus reply_stat
     UASSERT_MSG(
         !IsOk() || !data.IsError(),
         fmt::format(
-            "For command '{}' the ReplyData contains error='{}' that missmatch Reply status kOk", cmd, data.GetError()
+            "For command '{}' the ReplyData contains error='{}' that mismatch Reply status kOk", cmd, data.GetError()
         )
     );
 }
diff --git a/redis/src/storages/redis/impl/sentinel.cpp b/redis/src/storages/redis/impl/sentinel.cpp
index 1e48fcce7f51..5cebe6bdd945 100644
--- a/redis/src/storages/redis/impl/sentinel.cpp
+++ b/redis/src/storages/redis/impl/sentinel.cpp
@@ -211,6 +211,8 @@ void Sentinel::AsyncCommand(CommandPtr command, bool master, size_t shard) {
     if (!impl_) return;
     ThrowIfCancelled();
 
+    command->log_extra.Extend("shard_group_name", shard_group_name_);
+
     if (CommandControlImpl{command->control}.force_request_to_master) {
         master = true;
     }
diff --git a/redis/src/storages/redis/impl/sentinel_impl.cpp b/redis/src/storages/redis/impl/sentinel_impl.cpp
index a97caa09f318..1c8e239faec7 100644
--- a/redis/src/storages/redis/impl/sentinel_impl.cpp
+++ b/redis/src/storages/redis/impl/sentinel_impl.cpp
@@ -85,6 +85,7 @@ SentinelImpl::SentinelImpl(
     // https://github.com/boostorg/signals2/issues/59
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
     UASSERT_MSG(key_shard_, "key_shard should be provided");
+    log_extra_.Extend("shard_group_name", shard_group_name_);
     for (size_t i = 0; i < init_shards_->size(); ++i) {
         shards_[(*init_shards_)[i]] = i;
         connected_statuses_.push_back(std::make_unique<ConnectedStatus>());
@@ -92,7 +93,8 @@ SentinelImpl::SentinelImpl(
     UpdatePassword(password);
 
     Init();
-    LOG_DEBUG() << "Created SentinelImpl, shard_group_name=" << shard_group_name_ << ", cluster_mode=false";
+    LOG_DEBUG() << log_extra_ << "Created SentinelImpl, shard_group_name=" << shard_group_name_
+                << ", cluster_mode=false";
 }
 
 SentinelImpl::~SentinelImpl() { Stop(); }
@@ -127,7 +129,7 @@ void SentinelImpl::WaitConnectedOnce(RedisWaitConnected wait_connected) {
             if (wait_connected.throw_on_fail)
                 throw ClientNotConnectedException(msg);
             else
-                LOG_ERROR() << msg << ", starting with not ready Redis client";
+                LOG_ERROR() << log_extra_ << msg << ", starting with not ready Redis client";
         }
     }
 }
@@ -149,7 +151,7 @@ void SentinelImpl::Init() {
     // https://github.com/boostorg/signals2/issues/59
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
     sentinels_->SignalInstanceStateChange().connect([this](ServerId id, Redis::State state) {
-        LOG_TRACE() << "Signaled server " << id.GetDescription() << " state=" << StateToString(state);
+        LOG_TRACE() << log_extra_ << "Signaled server " << id.GetDescription() << " state=" << StateToString(state);
         if (state != Redis::State::kInit) ev_thread_.Send(watch_state_);
     });
 }
@@ -165,8 +167,10 @@ void SentinelImpl::InitShards(
         shard_options.shard_name = shard;
         shard_options.shard_group_name = shard_group_name_;
         shard_options.cluster_mode = false;
-        shard_options.ready_change_callback = [i, shard](bool ready) {
-            LOG_INFO() << "redis: ready_callback:"
+        shard_options.ready_change_callback = [i, shard, shard_group_name{shard_group_name_}](bool ready) {
+            logging::LogExtra log_extra;
+            log_extra.Extend("shard_group_name", shard_group_name);
+            LOG_INFO() << log_extra << "redis: ready_callback:"
                        << "  shard = " << i << "  shard_name = " << shard << "  ready = " << (ready ? "true" : "false");
         };
         auto object = std::make_shared<Shard>(std::move(shard_options));
@@ -178,7 +182,8 @@ void SentinelImpl::InitShards(
         // https://github.com/boostorg/signals2/issues/59
         // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
         object->SignalInstanceReady().connect([this, i](ServerId, bool read_only) {
-            LOG_TRACE() << "Signaled kConnected to sentinel: shard_idx=" << i << ", master=" << !read_only;
+            LOG_TRACE() << log_extra_ << "Signaled kConnected to sentinel: shard_idx=" << i
+                        << ", master=" << !read_only;
             if (!read_only)
                 connected_statuses_[i]->SetMasterReady();
             else
@@ -191,22 +196,23 @@ void SentinelImpl::InitShards(
 
 namespace {
 
-void InvokeCommand(CommandPtr command, ReplyPtr&& reply) {
+void InvokeCommand(CommandPtr command, ReplyPtr&& reply, const logging::LogExtra& log_extra) {
     UASSERT(reply);
     const CommandControlImpl cc{command->control};
     if (reply->server_id.IsAny()) {
         reply->server_id = cc.force_server_id;
     }
-    LOG_DEBUG() << "redis_request( " << CommandSpecialPrinter{command}
+    LOG_DEBUG() << log_extra << "redis_request( " << CommandSpecialPrinter{command}
                 << " ):" << (reply->status == ReplyStatus::kOk ? '+' : '-') << ":" << reply->time * 1000.0
                 << " cc: " << command->control.ToString() << command->GetLogExtra();
     ++command->invoke_counter;
     try {
         command->callback(command, reply);
     } catch (const std::exception& ex) {
-        LOG_WARNING() << "exception in command->callback, cmd=" << reply->cmd << " " << ex << command->log_extra;
+        LOG_WARNING() << log_extra << "exception in command->callback, cmd=" << reply->cmd << " " << ex
+                      << command->log_extra;
     } catch (...) {
-        LOG_WARNING() << "exception in command->callback, cmd=" << reply->cmd << command->log_extra;
+        LOG_WARNING() << log_extra << "exception in command->callback, cmd=" << reply->cmd << command->log_extra;
     }
 }
 
@@ -246,7 +252,7 @@ void SentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t prev_ins
     if (!AdjustDeadline(scommand, dynamic_config_source_.GetSnapshot())) {
         auto reply =
             std::make_shared<Reply>("", ReplyData::CreateError("Deadline propagation"), ReplyStatus::kTimeoutError);
-        InvokeCommand(scommand.command, std::move(reply));
+        InvokeCommand(scommand.command, std::move(reply), log_extra_);
         return;
     }
 
@@ -304,7 +310,7 @@ void SentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t prev_ins
             const std::chrono::duration<double> time = now - start;
             reply->time = time.count();
             command->args = std::move(ccommand->args);
-            InvokeCommand(command, std::move(reply));
+            InvokeCommand(command, std::move(reply), log_extra_);
             ccommand->args = std::move(command->args);
         },
         command->control,
@@ -327,7 +333,7 @@ void SentinelImpl::AsyncCommand(const SentinelCommand& scommand, size_t prev_ins
 size_t SentinelImpl::ShardByKey(const std::string& key) const {
     UASSERT(!master_shards_.empty());
     const size_t shard = key_shard_->ShardByKey(key);
-    LOG_TRACE() << "key=" << key << " shard=" << shard;
+    LOG_TRACE() << log_extra_ << "key=" << key << " shard=" << shard;
     return shard;
 }
 
@@ -387,7 +393,7 @@ void SentinelImpl::RefreshConnectionInfo() {
         ProcessCreationOfShards(master_shards_);
         ReadSentinels();
     } catch (const std::exception& ex) {
-        LOG_WARNING() << "exception in RefreshConnectionInfo: " << ex.what();
+        LOG_WARNING() << log_extra_ << "exception in RefreshConnectionInfo: " << ex.what();
     }
 
     /* FIXME: this should be called not every check_interval_,
@@ -420,14 +426,14 @@ void SentinelImpl::Stop() {
             while (!commands_.empty()) {
                 auto command = commands_.back().command;
                 for (const auto& args : command->args) {
-                    LOG_ERROR() << fmt::format("Killing request: {}", args.GetJoinedArgs(", "));
+                    LOG_ERROR() << log_extra_ << fmt::format("Killing request: {}", args.GetJoinedArgs(", "));
                     auto reply = std::make_shared<Reply>(
                         args.GetCommandName(),
                         ReplyData::CreateError("Stopping, killing commands remaining in send queue"),
                         ReplyStatus::kEndOfFileError
                     );
                     statistics_internal_.redis_not_ready++;
-                    InvokeCommand(command, std::move(reply));
+                    InvokeCommand(command, std::move(reply), log_extra_);
                 }
                 commands_.pop_back();
             }
@@ -463,7 +469,8 @@ void SentinelImpl::ReadSentinels() {
         GetHostsRequest(*sentinels_, GetPassword()),
         [this](const ConnInfoByShard& info, size_t requests_sent, size_t responses_parsed) {
             if (!CheckQuorum(requests_sent, responses_parsed)) {
-                LOG_WARNING() << "Too many 'sentinel masters' requests failed: requests_sent=" << requests_sent
+                LOG_WARNING() << log_extra_
+                              << "Too many 'sentinel masters' requests failed: requests_sent=" << requests_sent
                               << " responses_parsed=" << responses_parsed;
                 return;
             }
@@ -489,7 +496,7 @@ void SentinelImpl::ReadSentinels() {
 
             for (size_t idx = 0; idx < shard_found.size(); idx++) {
                 if (!shard_found[idx]) {
-                    LOG_WARNING() << "Shard with name=" << (*init_shards_)[idx]
+                    LOG_WARNING() << log_extra_ << "Shard with name=" << (*init_shards_)[idx]
                                   << " was not found in 'SENTINEL MASTERS' reply for "
                                      "shard_group_name="
                                   << shard_group_name_
@@ -505,7 +512,8 @@ void SentinelImpl::ReadSentinels() {
                     GetHostsRequest(*sentinels_, shard_conn.Name(), GetPassword()),
                     [this, watcher, shard](const ConnInfoByShard& info, size_t requests_sent, size_t responses_parsed) {
                         if (!CheckQuorum(requests_sent, responses_parsed)) {
-                            LOG_WARNING() << "Too many 'sentinel slaves' requests "
+                            LOG_WARNING() << log_extra_
+                                          << "Too many 'sentinel slaves' requests "
                                              "failed: requests_sent="
                                           << requests_sent << " responses_parsed=" << responses_parsed;
                             return;
@@ -562,7 +570,7 @@ bool SentinelImpl::SetConnectionInfo(ConnInfoMap info_by_shards, std::vector<std
                 std::vector<std::string> conn_strs;
                 conn_strs.reserve(info_iterator.second.size());
                 for (const auto& conn_str : info_iterator.second) conn_strs.push_back(conn_str.Fulltext());
-                LOG_INFO() << "Redis state changed for client=" << client_name_ << " shard=" << j->first
+                LOG_INFO() << log_extra_ << "Redis state changed for client=" << client_name_ << " shard=" << j->first
                            << ", now it is " << fmt::to_string(fmt::join(conn_strs, ", "))
                            << ", connections=" << shard_ptr->InstancesSize();
                 res = true;
@@ -611,7 +619,8 @@ void SentinelImpl::ProcessWaitingCommands() {
         waiting_commands.swap(commands_);
     }
     if (!waiting_commands.empty()) {
-        LOG_INFO() << "ProcessWaitingCommands client=" << client_name_ << " shard_group_name=" << shard_group_name_
+        LOG_INFO() << log_extra_ << "ProcessWaitingCommands client=" << client_name_
+                   << " shard_group_name=" << shard_group_name_
                    << " waiting_commands.size()=" << waiting_commands.size();
     }
 
@@ -627,7 +636,7 @@ void SentinelImpl::ProcessWaitingCommands() {
                     ReplyStatus::kTimeoutError
                 );
                 statistics_internal_.redis_not_ready++;
-                InvokeCommand(command, std::move(reply));
+                InvokeCommand(command, std::move(reply), log_extra_);
             }
         } else {
             AsyncCommand(scommand, kDefaultPrevInstanceIdx);
diff --git a/redis/src/storages/redis/impl/sentinel_impl.hpp b/redis/src/storages/redis/impl/sentinel_impl.hpp
index 4b02febb31a7..eded1db3733a 100644
--- a/redis/src/storages/redis/impl/sentinel_impl.hpp
+++ b/redis/src/storages/redis/impl/sentinel_impl.hpp
@@ -192,6 +192,7 @@ class SentinelImpl : public SentinelImplBase {
     engine::ev::ThreadControl ev_thread_;
 
     const std::string shard_group_name_;
+    logging::LogExtra log_extra_;
     const std::shared_ptr<const std::vector<std::string>> init_shards_;
     std::vector<std::unique_ptr<ConnectedStatus>> connected_statuses_;
     const std::vector<ConnectionInfo> conns_;
diff --git a/redis/src/storages/redis/impl/sentinel_query.cpp b/redis/src/storages/redis/impl/sentinel_query.cpp
index 84063826ceb4..5ac7983e2108 100644
--- a/redis/src/storages/redis/impl/sentinel_query.cpp
+++ b/redis/src/storages/redis/impl/sentinel_query.cpp
@@ -223,12 +223,6 @@ std::string InstanceUpChecker::GetReason() const {
     UINVARIANT(false, "Unknown reason");
 }
 
-enum class ClusterSlotsResponseStatus {
-    kOk,
-    kFail,
-    kNonCluster,
-};
-
 std::optional<std::string> GetIpFromMeta(const ReplyData::Array& host_info_array) {
     if (host_info_array.size() < 4) return std::nullopt;
     const auto& meta = host_info_array[3];
@@ -251,35 +245,112 @@ std::string GetIpFromHostInfo(const ReplyData::Array& host_info_array) {
     return host_info_array[0].GetString();
 }
 
-ClusterSlotsResponseStatus ParseClusterSlotsResponse(const ReplyPtr& reply, ClusterSlotsResponse& res) {
+}  // namespace
+
+ClusterSlotsResponseStatus
+ParseClusterSlotsResponse(const ReplyPtr& reply, ClusterSlotsResponse& res, const std::string& shard_group_name) {
     UASSERT(reply);
-    LOG_TRACE() << "Got reply to CLUSTER SLOTS: " << reply->data.ToDebugString();
-    if (reply->IsUnknownCommandError()) return ClusterSlotsResponseStatus::kNonCluster;
-    if (reply->status != ReplyStatus::kOk || !reply->data.IsArray()) return ClusterSlotsResponseStatus::kFail;
+    auto log_extra = [&shard_group_name] { return logging::LogExtra({{"shard_group_name", shard_group_name}}); };
+
+    LOG_TRACE() << log_extra() << "Got reply to CLUSTER SLOTS: " << reply->data.ToDebugString();
+    if (reply->IsUnknownCommandError()) {
+        LOG_ERROR() << log_extra()
+                    << "Redis CLUSTER SLOTS reply contains unknown command error: " << reply->data.ToDebugString();
+        return ClusterSlotsResponseStatus::kNonCluster;
+    }
+    if (reply->status != ReplyStatus::kOk) {
+        LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply contains error: " << reply->data.ToDebugString();
+        return ClusterSlotsResponseStatus::kFail;
+    }
+    if (!reply->data.IsArray()) {
+        LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply is not an array: " << reply->data.ToDebugString();
+        return ClusterSlotsResponseStatus::kFail;
+    }
+
+    std::size_t array_index = 0;
     for (const auto& reply_interval : reply->data.GetArray()) {
-        if (!reply_interval.IsArray()) return ClusterSlotsResponseStatus::kFail;
+        if (!reply_interval.IsArray()) {
+            LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index
+                        << "] is not an array: " << reply_interval.ToDebugString();
+            return ClusterSlotsResponseStatus::kFail;
+        }
+
         const auto& array = reply_interval.GetArray();
-        if (array.size() < 3) return ClusterSlotsResponseStatus::kFail;
-        if (!array[0].IsInt() || !array[1].IsInt()) return ClusterSlotsResponseStatus::kFail;
-        for (size_t i = 2; i < array.size(); i++) {
-            if (!array[i].IsArray()) return ClusterSlotsResponseStatus::kFail;
+        if (array.size() < 3) {
+            LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index
+                        << "] is an array of size less than 3: " << reply_interval.ToDebugString();
+            return ClusterSlotsResponseStatus::kFail;
+        }
+
+        if (!array[0].IsInt()) {
+            LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index
+                        << "][0] is not an int: " << array[0].ToDebugString();
+            return ClusterSlotsResponseStatus::kFail;
+        }
+
+        if (!array[1].IsInt()) {
+            LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index
+                        << "][1] is not an int: " << array[1].ToDebugString();
+            return ClusterSlotsResponseStatus::kFail;
+        }
+
+        for (std::size_t i = 2; i < array.size(); i++) {
+            if (!array[i].IsArray()) {
+                LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index << "][" << i
+                            << "] is not an array: " << array[i].ToDebugString();
+                return ClusterSlotsResponseStatus::kFail;
+            }
+
             const auto& host_info_array = array[i].GetArray();
-            if (host_info_array.size() < 2) return ClusterSlotsResponseStatus::kFail;
-            if (!host_info_array[0].IsString() || !host_info_array[1].IsInt()) return ClusterSlotsResponseStatus::kFail;
+            if (host_info_array.size() < 2) {
+                LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index << "][" << i
+                            << "] is an array of size less than 2: " << array[i].ToDebugString();
+                return ClusterSlotsResponseStatus::kFail;
+            }
+
+            if (!host_info_array[0].IsString()) {
+                LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index << "][" << i
+                            << "][0] is not a string: " << host_info_array[0].ToDebugString();
+                return ClusterSlotsResponseStatus::kFail;
+            }
+
+            if (!host_info_array[1].IsInt()) {
+                LOG_ERROR() << log_extra() << "Redis CLUSTER SLOTS reply element[" << array_index << "][" << i
+                            << "][1] is not an int: " << host_info_array[1].ToDebugString();
+                return ClusterSlotsResponseStatus::kFail;
+            }
+
             ConnectionInfoInt conn_info{
                 {GetIpFromHostInfo(host_info_array), static_cast<int>(host_info_array[1].GetInt()), {}}};
             const SlotInterval slot_interval(array[0].GetInt(), array[1].GetInt());
-            if (i == 2)
+            if (i == 2) {
+                const bool is_master_overwritten =
+                    (!res[slot_interval].master.HostPort().first.empty() &&
+                     res[slot_interval].master.HostPort().first != "localhost" &&
+                     res[slot_interval].master.HostPort() != conn_info.HostPort());
+                if (is_master_overwritten) {
+                    const auto message = fmt::format(
+                        "Redis CLUSTER SLOTS reply element[{}][{}] overwrites master '{}' with '{}'",
+                        array_index,
+                        i,
+                        res[slot_interval].master.HostPort().first,
+                        conn_info.HostPort().first
+                    );
+                    LOG_ERROR() << log_extra() << message;
+                    UASSERT_MSG(false, message);
+                }
+
                 res[slot_interval].master = std::move(conn_info);
-            else
+            } else {
                 res[slot_interval].slaves.insert(std::move(conn_info));
+            }
         }
+
+        ++array_index;
     }
     return ClusterSlotsResponseStatus::kOk;
 }
 
-}  // namespace
-
 GetHostsContext::GetHostsContext(
     bool allow_empty,
     const Password& password,
@@ -377,6 +448,11 @@ void ProcessGetHostsRequest(GetHostsRequest request, ProcessGetHostsRequestCb ca
     }
 }
 
+logging::LogHelper& operator<<(logging::LogHelper& log, SlotInterval interval) {
+    log << '[' << interval.slot_min << ',' << interval.slot_max << ']';
+    return log;
+}
+
 void ProcessGetClusterHostsRequest(
     std::shared_ptr<const std::vector<std::string>> shard_names,
     GetClusterHostsRequest request,
@@ -384,7 +460,7 @@ void ProcessGetClusterHostsRequest(
 ) {
     auto ids = request.sentinel_shard.GetAllInstancesServerId();
     auto context = std::make_shared<GetClusterHostsContext>(
-        request.password, std::move(shard_names), std::move(callback), ids.size()
+        request.password, std::move(shard_names), request.shard_group_name, std::move(callback), ids.size()
     );
 
     for (const auto& id : ids) {
@@ -401,10 +477,12 @@ void ProcessGetClusterHostsRequest(
 GetClusterHostsContext::GetClusterHostsContext(
     Password password,
     std::shared_ptr<const std::vector<std::string>> shard_names,
+    std::string shard_group_name,
     ProcessGetClusterHostsRequestCb&& callback,
     size_t expected_responses_cnt
 )
-    : password_(std::move(password)),
+    : shard_group_name_(std::move(shard_group_name)),
+      password_(std::move(password)),
       shard_names_(std::move(shard_names)),
       callback_(std::move(callback)),
       expected_responses_cnt_(expected_responses_cnt) {}
@@ -417,7 +495,7 @@ void GetClusterHostsContext::OnAsyncCommandFailed() {
 
 void GetClusterHostsContext::OnResponse(const CommandPtr&, const ReplyPtr& reply) {
     ClusterSlotsResponse response;
-    switch (ParseClusterSlotsResponse(reply, response)) {
+    switch (ParseClusterSlotsResponse(reply, response, shard_group_name_)) {
         case ClusterSlotsResponseStatus::kOk: {
             {
                 const std::lock_guard<std::mutex> lock(mutex_);
@@ -451,6 +529,7 @@ void GetClusterHostsContext::ProcessResponsesOnce() {
         return;
     }
 
+    auto log_extra = [this] { return logging::LogExtra({{"shard_group_name", shard_group_name_}}); };
     std::set<size_t> slot_bounds;
     for (const auto& [_, response] : responses_by_id_) {
         for (const auto& [interval, _] : response) {
@@ -459,10 +538,12 @@ void GetClusterHostsContext::ProcessResponsesOnce() {
         }
     }
     if (slot_bounds.empty()) {
-        LOG_WARNING() << "Failed to process CLUSTER SLOTS replies: responses_parsed=" << responses_parsed_
+        LOG_WARNING() << log_extra()
+                      << "Failed to process CLUSTER SLOTS replies: responses_parsed=" << responses_parsed_
                       << ", no slots info found";
     } else if (*slot_bounds.begin() != 0 || *std::prev(slot_bounds.end()) != kClusterHashSlots) {
-        LOG_ERROR() << "Failed to process CLUSTER SLOTS replies: slot bounds begin=" << *slot_bounds.begin()
+        LOG_ERROR() << log_extra()
+                    << "Failed to process CLUSTER SLOTS replies: slot bounds begin=" << *slot_bounds.begin()
                     << ", end=" << *std::prev(slot_bounds.end());
     }
 
@@ -531,7 +612,8 @@ void GetClusterHostsContext::ProcessResponsesOnce() {
 
         size_t shard_index = 0;
         if (res.size() > shard_names_->size()) {
-            LOG_ERROR() << "Too many shards found: " << res.size() << ", maximum: " << shard_names_->size();
+            LOG_ERROR() << log_extra() << "Too many shards found: " << res.size()
+                        << ", maximum: " << shard_names_->size();
             res = {};
         } else {
             std::sort(res.begin(), res.end());
diff --git a/redis/src/storages/redis/impl/sentinel_query.hpp b/redis/src/storages/redis/impl/sentinel_query.hpp
index 1a610ea16a6a..ac4ad75b7ec0 100644
--- a/redis/src/storages/redis/impl/sentinel_query.hpp
+++ b/redis/src/storages/redis/impl/sentinel_query.hpp
@@ -79,13 +79,17 @@ class GetHostsContext : public std::enable_shared_from_this<GetHostsContext> {
 static constexpr size_t kClusterHashSlots = 16384;
 
 struct GetClusterHostsRequest {
-    GetClusterHostsRequest(Shard& sentinel_shard, Password password)
-        : sentinel_shard(sentinel_shard), command({"CLUSTER", "SLOTS"}), password(std::move(password)) {}
+    GetClusterHostsRequest(Shard& sentinel_shard, Password password, std::string shard_group_name)
+        : sentinel_shard(sentinel_shard),
+          command({"CLUSTER", "SLOTS"}),
+          password(std::move(password)),
+          shard_group_name(std::move(shard_group_name)) {}
 
     Shard& sentinel_shard;
     CmdArgs command;
 
     Password password;
+    std::string shard_group_name;
 };
 
 struct SlotInterval {
@@ -98,6 +102,8 @@ struct SlotInterval {
     bool operator==(const SlotInterval& r) const { return slot_min == r.slot_min && slot_max == r.slot_max; }
 };
 
+logging::LogHelper& operator<<(logging::LogHelper& log, SlotInterval interval);
+
 struct ClusterShardHostInfo {
     ConnectionInfoInt master;
     std::vector<ConnectionInfoInt> slaves;
@@ -133,6 +139,7 @@ class GetClusterHostsContext {
     GetClusterHostsContext(
         Password password,
         std::shared_ptr<const std::vector<std::string>> shard_names,
+        std::string shard_group_name,
         ProcessGetClusterHostsRequestCb&& callback,
         size_t expected_responses_cnt
     );
@@ -149,6 +156,7 @@ class GetClusterHostsContext {
     void ProcessResponses();
     void ProcessResponsesOnce();
 
+    const std::string shard_group_name_;
     const Password password_;
     const std::shared_ptr<const std::vector<std::string>> shard_names_;
     const ProcessGetClusterHostsRequestCb callback_;
@@ -162,6 +170,15 @@ class GetClusterHostsContext {
     std::map<ServerId, ClusterSlotsResponse> responses_by_id_;
 };
 
+enum class ClusterSlotsResponseStatus {
+    kOk,
+    kFail,
+    kNonCluster,
+};
+
+ClusterSlotsResponseStatus
+ParseClusterSlotsResponse(const ReplyPtr& reply, ClusterSlotsResponse& res, const std::string& shard_group_name);
+
 }  // namespace storages::redis::impl
 
 USERVER_NAMESPACE_END
diff --git a/redis/src/storages/redis/impl/sentinel_query_test.cpp b/redis/src/storages/redis/impl/sentinel_query_test.cpp
index e9e10cdf67b9..b061fe4c4a50 100644
--- a/redis/src/storages/redis/impl/sentinel_query_test.cpp
+++ b/redis/src/storages/redis/impl/sentinel_query_test.cpp
@@ -26,6 +26,196 @@ TEST(SentinelQuery, SingleBadReply) {
     EXPECT_EQ(1, called);
 }
 
+TEST(SentinelQuery, ParseReplySimpleIps) {
+    using ReplyData = storages::redis::ReplyData;
+    using Array = ReplyData::Array;
+    constexpr auto kIp1 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:aaaa";
+    constexpr auto kPort1 = 6379;
+
+    constexpr auto kIp2 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:bbbb";
+    constexpr auto kPort2 = 6380;
+
+    constexpr auto kIp3 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:cccc";
+    constexpr auto kPort3 = 6381;
+
+    constexpr auto kIp4 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:dddd";
+    constexpr auto kPort4 = 6382;
+
+    constexpr auto kIp5 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:eeee";
+    constexpr auto kPort5 = 6383;
+
+    constexpr auto kIp6 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:ffff";
+    constexpr auto kPort6 = 6384;
+
+    auto reply = std::make_shared<storages::redis::Reply>(
+        "CLUSTER SLOTS",
+        ReplyData{Array{
+            Array{
+                ReplyData{0},
+                ReplyData{5460},
+                Array{
+                    ReplyData{"klg-9.db.net"},
+                    ReplyData{kPort1},
+                    ReplyData{"92f260b22c5d1d2b1da1971c0244d268b3aaaaaa"},
+                    Array{ReplyData{"ip"}, ReplyData{kIp1}},
+                },
+                Array{
+                    ReplyData{"vla-i.db.net"},
+                    ReplyData{kPort2},
+                    ReplyData{"4732a74a0c4c9fe245eb8098ff6c2b1b22bbbbbb"},
+                    Array{ReplyData{"ip"}, ReplyData{kIp2}},
+                },
+            },
+            Array{
+                ReplyData{5461},
+                ReplyData{10922},
+                Array{
+                    ReplyData{"klg-8.db.net"},
+                    ReplyData{kPort3},
+                    ReplyData{"294e10240d74f7d7eb9e8583645f08f3bdcccccc"},
+                    Array{ReplyData{"ip"}, ReplyData{kIp3}},
+                },
+                Array{
+                    ReplyData{"vla-3.db.net"},
+                    ReplyData{kPort4},
+                    ReplyData{"4732a74a0c4c9fe245eb8098ff6c2b1b22dddddd"},
+                    Array{ReplyData{"ip"}, ReplyData{kIp4}},
+                },
+            },
+            Array{
+                ReplyData{10923},
+                ReplyData{16383},
+                Array{
+                    ReplyData{"klg-g.db.net"},
+                    ReplyData{kPort5},
+                    ReplyData{"294e10240d74f7d7eb9e8583645f08f3bd000000"},
+                    Array{ReplyData{"ip"}, ReplyData{kIp5}},
+                },
+                Array{
+                    ReplyData{"vla-e.db.net"},
+                    ReplyData{kPort6},
+                    ReplyData{"4732a74a0c4c9fe245eb8098ff6c2b1b22111111"},
+                    Array{ReplyData{"ip"}, ReplyData{kIp6}},
+                },
+            },
+        }}
+    );
+
+    namespace impl = storages::redis::impl;
+    impl::ClusterSlotsResponse response;
+    ASSERT_EQ(impl::ParseClusterSlotsResponse(reply, response, "redisdb"), impl::ClusterSlotsResponseStatus::kOk);
+
+    using Pair = std::pair<std::string, int>;
+    EXPECT_EQ(response.size(), 3);
+
+    EXPECT_EQ(response[impl::SlotInterval(0, 5460)].master.HostPort(), Pair(kIp1, kPort1));
+    ASSERT_EQ(response[impl::SlotInterval(0, 5460)].slaves.size(), 1);
+    EXPECT_EQ(response[impl::SlotInterval(0, 5460)].slaves.begin()->HostPort(), Pair(kIp2, kPort2));
+
+    EXPECT_EQ(response[impl::SlotInterval(5461, 10922)].master.HostPort(), Pair(kIp3, kPort3));
+    ASSERT_EQ(response[impl::SlotInterval(5461, 10922)].slaves.size(), 1);
+    EXPECT_EQ(response[impl::SlotInterval(5461, 10922)].slaves.begin()->HostPort(), Pair(kIp4, kPort4));
+
+    EXPECT_EQ(response[impl::SlotInterval(10923, 16383)].master.HostPort(), Pair(kIp5, kPort5));
+    ASSERT_EQ(response[impl::SlotInterval(10923, 16383)].slaves.size(), 1);
+    EXPECT_EQ(response[impl::SlotInterval(10923, 16383)].slaves.begin()->HostPort(), Pair(kIp6, kPort6));
+}
+
+TEST(SentinelQuery, ParseReplySimpleHostname) {
+    using ReplyData = storages::redis::ReplyData;
+    using Array = ReplyData::Array;
+    constexpr auto kIp1 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:aaaa";
+    constexpr auto kPort1 = 6379;
+
+    constexpr auto kIp2 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:bbbb";
+    constexpr auto kPort2 = 6380;
+
+    constexpr auto kIp3 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:cccc";
+    constexpr auto kPort3 = 6381;
+
+    constexpr auto kIp4 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:dddd";
+    constexpr auto kPort4 = 6382;
+
+    constexpr auto kIp5 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:eeee";
+    constexpr auto kPort5 = 6383;
+
+    constexpr auto kIp6 = "2a02:6b8:c2d:3d21:7a01:1405:4c4f:ffff";
+    constexpr auto kPort6 = 6384;
+
+    auto reply = std::make_shared<storages::redis::Reply>(
+        "CLUSTER SLOTS",
+        ReplyData{Array{
+            Array{
+                ReplyData{0},
+                ReplyData{5460},
+                Array{
+                    ReplyData{kIp1},
+                    ReplyData{kPort1},
+                    ReplyData{"92f260b22c5d1d2b1da1971c0244d268b3aaaaaa"},
+                    Array{ReplyData{"hostname"}, ReplyData{"klg-9.db.net"}},
+                },
+                Array{
+                    ReplyData{kIp2},
+                    ReplyData{kPort2},
+                    ReplyData{"4732a74a0c4c9fe245eb8098ff6c2b1b22bbbbbb"},
+                    Array{ReplyData{"hostname"}, ReplyData{"vla-i.db.net"}},
+                },
+            },
+            Array{
+                ReplyData{5461},
+                ReplyData{16383},
+                Array{
+                    ReplyData{kIp3},
+                    ReplyData{kPort3},
+                    ReplyData{"294e10240d74f7d7eb9e8583645f08f3bdcccccc"},
+                    Array{ReplyData{"hostname"}, ReplyData{"klg-8.db.net"}},
+                },
+                Array{
+                    ReplyData{kIp4},
+                    ReplyData{kPort4},
+                    ReplyData{"4732a74a0c4c9fe245eb8098ff6c2b1b22dddddd"},
+                    Array{ReplyData{"hostname"}, ReplyData{"vla-3.db.net"}},
+                },
+                Array{
+                    ReplyData{kIp5},
+                    ReplyData{kPort5},
+                    ReplyData{"294e10240d74f7d7eb9e8583645f08f3bd000000"},
+                    Array{ReplyData{"hostname"}, ReplyData{"klg-g.db.net"}},
+                },
+                Array{
+                    ReplyData{kIp6},
+                    ReplyData{kPort6},
+                    ReplyData{"4732a74a0c4c9fe245eb8098ff6c2b1b22111111"},
+                    Array{ReplyData{"hostname"}, ReplyData{"vla-e.db.net"}},
+                },
+            },
+        }}
+    );
+
+    namespace impl = storages::redis::impl;
+    impl::ClusterSlotsResponse response;
+    ASSERT_EQ(impl::ParseClusterSlotsResponse(reply, response, "redisdb"), impl::ClusterSlotsResponseStatus::kOk);
+
+    using Pair = std::pair<std::string, int>;
+    EXPECT_EQ(response.size(), 2);
+
+    EXPECT_EQ(response[impl::SlotInterval(0, 5460)].master.HostPort(), Pair(kIp1, kPort1));
+    ASSERT_EQ(response[impl::SlotInterval(0, 5460)].slaves.size(), 1);
+    EXPECT_EQ(response[impl::SlotInterval(0, 5460)].slaves.begin()->HostPort(), Pair(kIp2, kPort2));
+
+    EXPECT_EQ(response[impl::SlotInterval(5461, 16383)].master.HostPort(), Pair(kIp3, kPort3));
+    ASSERT_EQ(response[impl::SlotInterval(5461, 16383)].slaves.size(), 3);
+
+    std::set<Pair> host_ports = {
+        {kIp4, kPort4},
+        {kIp5, kPort5},
+        {kIp6, kPort6},
+    };
+    for (const auto& slave : response[impl::SlotInterval(5461, 16383)].slaves) {
+        EXPECT_TRUE(host_ports.extract(slave.HostPort()));
+    }
+}
+
 std::shared_ptr<storages::redis::Reply>
 GenerateReply(const std::string& ip, bool master, bool s_down, bool o_down, bool master_link_status_err) {
     std::string flags = master ? "master" : "slave";
diff --git a/redis/src/storages/redis/impl/server_test.cpp b/redis/src/storages/redis/impl/server_test.cpp
index 5391728dd56b..48eb9fd7851a 100644
--- a/redis/src/storages/redis/impl/server_test.cpp
+++ b/redis/src/storages/redis/impl/server_test.cpp
@@ -28,6 +28,7 @@ constexpr auto kCheckCount = 10;
 constexpr auto kRedisDatabaseIndex = 46;
 constexpr std::size_t kDatabaseIndex = 0;
 
+const std::string kDbName = "redis_db";
 const std::string kLocalhost = "127.0.0.1";
 
 template <typename Predicate>
@@ -140,12 +141,12 @@ struct MockSentinelServers {
 }  // namespace
 
 TEST(Redis, NoPassword) {
-    MockRedisServer server{"redis_db"};
+    MockRedisServer server{kDbName};
     auto ping_handler = server.RegisterPingHandler();
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), storages::redis::Password(""), kDatabaseIndex);
 
     EXPECT_TRUE(ping_handler->WaitForFirstReply(kSmallPeriod));
@@ -158,7 +159,7 @@ TEST(Redis, Auth) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), storages::redis::Password("password"), kDatabaseIndex);
 
     EXPECT_TRUE(auth_handler->WaitForFirstReply(kSmallPeriod));
@@ -172,7 +173,7 @@ TEST(Redis, AuthFail) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), storages::redis::Password("password"), kDatabaseIndex);
 
     EXPECT_TRUE(auth_error_handler->WaitForFirstReply(kSmallPeriod));
@@ -187,7 +188,7 @@ TEST(Redis, AuthTimeout) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), storages::redis::Password("password"), kDatabaseIndex);
 
     EXPECT_TRUE(auth_error_handler->WaitForFirstReply(sleep_period + kSmallPeriod));
@@ -421,7 +422,7 @@ TEST(Redis, Select) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), {}, kRedisDatabaseIndex);
 
     EXPECT_TRUE(select_handler->WaitForFirstReply(kSmallPeriod));
@@ -435,7 +436,7 @@ TEST(Redis, SelectFail) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), {}, kRedisDatabaseIndex);
 
     EXPECT_TRUE(select_error_handler->WaitForFirstReply(kSmallPeriod));
@@ -450,7 +451,7 @@ TEST(Redis, SelectTimeout) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), {}, kRedisDatabaseIndex);
 
     EXPECT_TRUE(select_error_handler->WaitForFirstReply(sleep_period + kSmallPeriod));
@@ -465,7 +466,7 @@ TEST(Redis, SlaveREADONLY) {
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     storages::redis::RedisCreationSettings redis_settings;
     redis_settings.send_readonly = true;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), {}, kDatabaseIndex);
 
     EXPECT_TRUE(readonly_handler->WaitForFirstReply(kSmallPeriod));
@@ -480,7 +481,7 @@ TEST(Redis, SlaveREADONLYFail) {
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     storages::redis::RedisCreationSettings redis_settings;
     redis_settings.send_readonly = true;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), {}, kDatabaseIndex);
 
     EXPECT_TRUE(readonly_handler->WaitForFirstReply(kSmallPeriod));
@@ -493,7 +494,7 @@ TEST(Redis, PingFail) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), storages::redis::Password(""), kDatabaseIndex);
 
     EXPECT_TRUE(ping_error_handler->WaitForFirstReply(kSmallPeriod));
@@ -520,7 +521,7 @@ TEST_P(RedisDisconnectingReplies, X) {
 
     auto pool = std::make_shared<storages::redis::impl::ThreadPools>(1, 1);
     const storages::redis::RedisCreationSettings redis_settings;
-    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings);
+    auto redis = std::make_shared<storages::redis::impl::Redis>(pool->GetRedisThreadPool(), redis_settings, kDbName);
     redis->Connect({kLocalhost}, server.GetPort(), storages::redis::Password(""), kDatabaseIndex);
 
     EXPECT_TRUE(ping_handler->WaitForFirstReply(kSmallPeriod));
diff --git a/redis/src/storages/redis/impl/shard.cpp b/redis/src/storages/redis/impl/shard.cpp
index 59ce528ce31a..84899b1c5166 100644
--- a/redis/src/storages/redis/impl/shard.cpp
+++ b/redis/src/storages/redis/impl/shard.cpp
@@ -10,6 +10,7 @@
 
 #include <storages/redis/impl/command.hpp>
 #include <userver/storages/redis/base.hpp>
+#include <userver/utils/assert.hpp>
 
 #include "command_control_impl.hpp"
 
@@ -18,10 +19,11 @@ USERVER_NAMESPACE_BEGIN
 namespace storages::redis::impl {
 
 ConnectionInfoInt::ConnectionInfoInt(ConnectionInfo conn_info)
-    : conn_info_(std::move(conn_info)),
-      fulltext_(fmt::format(FMT_COMPILE("{}:{}"), conn_info_.host, conn_info_.port)) {}
+    : conn_info_(std::move(conn_info)), fulltext_(fmt::format(FMT_COMPILE("{}:{}"), conn_info_.host, conn_info_.port)) {
+    UASSERT(!conn_info_.host.empty());
+}
 
-void ConnectionInfoInt::SetName(std::string name) { name_ = name; }
+void ConnectionInfoInt::SetName(std::string name) { name_ = std::move(name); }
 
 const std::string& ConnectionInfoInt::Name() const { return name_; }
 
@@ -239,8 +241,11 @@ bool Shard::AsyncCommand(CommandPtr command) {
         }
     }
 
-    LOG_LIMITED_WARNING() << "No Redis server is ready for shard_group=" << shard_group_name_
-                          << " shard=" << shard_name_ << " slave=" << command->read_only << command->GetLogExtra();
+    logging::LogExtra log_extra;
+    log_extra.Extend("shard_group_name", shard_group_name_);
+    log_extra.Extend("shard_name", shard_name_);
+    log_extra.Extend("slave", command->read_only);
+    LOG_LIMITED_WARNING() << log_extra << "No Redis server is ready" << command->GetLogExtra();
     return false;
 }
 
@@ -278,7 +283,8 @@ bool Shard::ProcessCreation(const std::shared_ptr<engine::ev::ThreadPool>& redis
                 redis_thread_pool,
                 // https://github.com/boostorg/signals2/issues/59
                 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
-                redis_settings
+                redis_settings,
+                shard_group_name_
             )};
         if (auto commands_buffering_settings = commands_buffering_settings_.Get())
             entry.instance->SetCommandsBufferingSettings(*commands_buffering_settings);
diff --git a/redis/src/storages/redis/impl/standalone_topology_holder.cpp b/redis/src/storages/redis/impl/standalone_topology_holder.cpp
index bcedb7185ac4..d6501a9c5d9c 100644
--- a/redis/src/storages/redis/impl/standalone_topology_holder.cpp
+++ b/redis/src/storages/redis/impl/standalone_topology_holder.cpp
@@ -11,12 +11,14 @@ namespace storages::redis::impl {
 StandaloneTopologyHolder::StandaloneTopologyHolder(
     const engine::ev::ThreadControl& sentinel_thread_control,
     const std::shared_ptr<engine::ev::ThreadPool>& redis_thread_pool,
+    const std::string& shard_group_name,
     const Password& password,
     std::size_t database_index,
     ConnectionInfo conn
 )
     : ev_thread_(sentinel_thread_control),
       redis_thread_pool_(redis_thread_pool),
+      shard_group_name_(shard_group_name),
       password_(std::move(password)),
       database_index_(database_index),
       conn_to_create_(conn),
@@ -154,6 +156,7 @@ std::shared_ptr<RedisConnectionHolder> StandaloneTopologyHolder::CreateRedisInst
     return RedisConnectionHolder::Create(
         ev_thread_,
         redis_thread_pool_,
+        shard_group_name_,
         info.HostPort().first,
         info.HostPort().second,
         GetPassword(),
diff --git a/redis/src/storages/redis/impl/standalone_topology_holder.hpp b/redis/src/storages/redis/impl/standalone_topology_holder.hpp
index 09808c4986da..f237e3dcd370 100644
--- a/redis/src/storages/redis/impl/standalone_topology_holder.hpp
+++ b/redis/src/storages/redis/impl/standalone_topology_holder.hpp
@@ -18,6 +18,7 @@ class StandaloneTopologyHolder final : public TopologyHolderBase {
     StandaloneTopologyHolder(
         const engine::ev::ThreadControl& sentinel_thread_control,
         const std::shared_ptr<engine::ev::ThreadPool>& redis_thread_pool,
+        const std::string& shard_group_name,
         const Password& password,
         std::size_t database_index,
         ConnectionInfo conn
@@ -71,6 +72,7 @@ class StandaloneTopologyHolder final : public TopologyHolderBase {
 
     engine::ev::ThreadControl ev_thread_;
     std::shared_ptr<engine::ev::ThreadPool> redis_thread_pool_;
+    const std::string shard_group_name_;
     concurrent::Variable<Password, std::mutex> password_;
     const std::size_t database_index_;
 
diff --git a/redis/src/storages/redis/impl/subscription_storage.cpp b/redis/src/storages/redis/impl/subscription_storage.cpp
index 490526e76a17..2e4745aa6af4 100644
--- a/redis/src/storages/redis/impl/subscription_storage.cpp
+++ b/redis/src/storages/redis/impl/subscription_storage.cpp
@@ -42,8 +42,8 @@ void SubscriptionToken::Unsubscribe() {
 
 SubscriptionToken::~SubscriptionToken() { Unsubscribe(); }
 
-SubscriptionStorageBase::RebalanceState::RebalanceState(size_t shard_idx, ServerWeights _weights)
-    : shard_idx(shard_idx), weights(std::move(_weights)) {
+SubscriptionStorageBase::RebalanceState::RebalanceState(size_t shard_idx, ServerWeights l_weights)
+    : shard_idx(shard_idx), weights(std::move(l_weights)) {
     for (const auto& weight_item : weights) {
         sum_weights += weight_item.second;
         LOG_DEBUG() << "rebalance shard=" << shard_idx << " server_id=" << weight_item.first.GetId()
@@ -60,18 +60,18 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
     RebalanceState state(shard_idx, weights);
     if (!state.sum_weights) return;
 
-    if (!callback_map_.empty() || !pattern_callback_map_.empty()) {
+    if (!callback_map.empty() || !pattern_callback_map.empty()) {
         LOG_INFO() << "Start rebalance for shard " << shard_idx;
 
         RebalanceGatherSubscriptions(
             state,
-            callback_map_,
+            callback_map,
             /*pattern=*/false,
             /*sharded=*/false
         );
         RebalanceGatherSubscriptions(
             state,
-            pattern_callback_map_,
+            pattern_callback_map,
             /*pattern=*/true,
             /*sharded=*/false
         );
@@ -79,12 +79,12 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
         RebalanceMoveSubscriptions(state);
     }
 
-    if (!sharded_callback_map_.empty()) {
+    if (!sharded_callback_map.empty()) {
         LOG_INFO() << "Start rebalance for sharded subscriptions";
         RebalanceState state(shard_idx, weights);
         RebalanceGatherSubscriptions(
             state,
-            sharded_callback_map_,
+            sharded_callback_map,
             /*pattern=*/false,
             /*sharded=*/true
         );
@@ -137,7 +137,7 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
 template <typename CallbackMap, typename PcallbackMap>
 size_t SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>::
     GetChannelsCountApprox(const std::lock_guard<std::mutex>& /*held_lock*/) const {
-    return callback_map_.size() + pattern_callback_map_.size() + sharded_callback_map_.size();
+    return callback_map.size() + pattern_callback_map.size() + sharded_callback_map.size();
 }
 
 template <typename CallbackMap, typename PcallbackMap>
@@ -145,7 +145,7 @@ RawPubsubClusterStatistics SubscriptionStorageBase::SubscriptionStorageImpl<Call
 ) const {
     RawPubsubClusterStatistics cluster_stats;
 
-    const std::lock_guard lock{mutex_};
+    const std::lock_guard lock{mutex};
     for (size_t i = 0; i < GetShardsCount(lock); i++) {
         cluster_stats.by_shard.push_back(GetShardStatistics(i, lock));
     }
@@ -161,21 +161,21 @@ PubsubShardStatistics SubscriptionStorageBase::SubscriptionStorageImpl<CallbackM
     shard_stats.shard_name = implemented_.GetShardName(shard_idx);
     shard_stats.by_channel.reserve(GetChannelsCountApprox(held_lock));
 
-    for (const auto& channel_item : callback_map_) {
+    for (const auto& channel_item : callback_map) {
         const auto& channel_info = channel_item.second;
         const auto& info = channel_info.GetInfo(shard_idx);
 
         const auto& name = channel_item.first;
         if (info.fsm) shard_stats.by_channel.emplace(name, info.GetStatistics());
     }
-    for (const auto& pattern_item : pattern_callback_map_) {
+    for (const auto& pattern_item : pattern_callback_map) {
         const auto& pattern_info = pattern_item.second;
         const auto& info = pattern_info.GetInfo(shard_idx);
 
         const auto& name = pattern_item.first;
         if (info.fsm) shard_stats.by_channel.emplace(name, info.GetStatistics());
     }
-    for (const auto& pattern_item : sharded_callback_map_) {
+    for (const auto& pattern_item : sharded_callback_map) {
         const auto& pattern_info = pattern_item.second;
         const auto& info = pattern_info.GetInfo(shard_idx);
 
@@ -191,9 +191,9 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
 ) {
     constexpr bool kNotSharded = false;
     constexpr bool kSharded = true;
-    if (DoUnsubscribe(callback_map_, subscription_id, kNotSharded)) return;
-    if (DoUnsubscribe(pattern_callback_map_, subscription_id, kNotSharded)) return;
-    if (DoUnsubscribe(sharded_callback_map_, subscription_id, kSharded)) return;
+    if (DoUnsubscribe(callback_map, subscription_id, kNotSharded)) return;
+    if (DoUnsubscribe(pattern_callback_map, subscription_id, kNotSharded)) return;
+    if (DoUnsubscribe(sharded_callback_map, subscription_id, kSharded)) return;
 
     LOG_ERROR() << "Unsubscribe called with invalid subscription_id: " << subscription_id;
 }
@@ -239,9 +239,9 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
             cmd = PrepareSubscribeCommand(channel_name, std::move(subscribe_cb), shard);
             cmd->control.force_server_id = action.server_id;
             if (channel_name.sharded)
-                sharded_subscribe_callback_(channel_name.channel, cmd);
+                sharded_subscribe_callback(channel_name.channel, cmd);
             else
-                subscribe_callback_(fsm->GetShard(), cmd);
+                subscribe_callback(fsm->GetShard(), cmd);
             break;
         }
 
@@ -249,18 +249,18 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
             cmd = PrepareUnsubscribeCommand(channel_name);
             cmd->control.force_server_id = action.server_id;
             if (channel_name.sharded)
-                sharded_unsubscribe_callback_(channel_name.channel, cmd);
+                sharded_unsubscribe_callback(channel_name.channel, cmd);
             else
-                unsubscribe_callback_(fsm->GetShard(), cmd);
+                unsubscribe_callback(fsm->GetShard(), cmd);
             break;
 
         case shard_subscriber::Action::Type::kDeleteFsm:
             if (channel_name.sharded)
-                DeleteChannel(sharded_callback_map_, channel_name, fsm);
+                DeleteChannel(sharded_callback_map, channel_name, fsm);
             else if (channel_name.pattern)
-                DeleteChannel(pattern_callback_map_, channel_name, fsm);
+                DeleteChannel(pattern_callback_map, channel_name, fsm);
             else
-                DeleteChannel(callback_map_, channel_name, fsm);
+                DeleteChannel(callback_map, channel_name, fsm);
             break;
     }
 }
@@ -277,7 +277,7 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
     event.type = event_type;
     event.server_id = server_id;
 
-    const std::lock_guard<std::mutex> lock{mutex_};
+    const std::lock_guard<std::mutex> lock{mutex};
     fsm->OnEvent(event);
     ReadActions(fsm, channel_name);
 }
@@ -320,7 +320,7 @@ bool SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
     SubscriptionId subscription_id,
     bool sharded
 ) {
-    const std::lock_guard<std::mutex> lock(mutex_);
+    const std::lock_guard<std::mutex> lock(mutex);
     for (auto& it1 : callback_map) {
         const auto& key = it1.first;
         auto& m = it1.second;
@@ -329,7 +329,7 @@ bool SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
         if (it2 != m.callbacks.end()) {
             m.callbacks.erase(it2);
             if (m.callbacks.empty()) {
-                if ((!sharded && unsubscribe_callback_) || (sharded && sharded_unsubscribe_callback_)) {
+                if ((!sharded && unsubscribe_callback) || (sharded && sharded_unsubscribe_callback)) {
                     shard_subscriber::Event event;
                     event.type = shard_subscriber::Event::Type::kUnsubscribeRequested;
 
@@ -441,8 +441,8 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
 ) {
     size_t discarded{0};
     try {
-        const std::lock_guard<std::mutex> lock{mutex_};
-        auto& m = callback_map_.at(channel);
+        const std::lock_guard<std::mutex> lock{mutex};
+        auto& m = callback_map.at(channel);
         for (const auto& it : m.callbacks) {
             try {
                 const auto result = it.second(channel, message);
@@ -476,8 +476,8 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
 ) {
     size_t discarded{0};
     try {
-        const std::lock_guard<std::mutex> lock{mutex_};
-        auto& m = pattern_callback_map_.at(pattern);
+        const std::lock_guard<std::mutex> lock{mutex};
+        auto& m = pattern_callback_map.at(pattern);
         for (const auto& it : m.callbacks) {
             try {
                 const auto result = it.second(pattern, channel, message);
@@ -510,8 +510,8 @@ void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>
 ) {
     size_t discarded{0};
     try {
-        const std::lock_guard<std::mutex> lock{mutex_};
-        auto& m = sharded_callback_map_.at(channel);
+        const std::lock_guard<std::mutex> lock{mutex};
+        auto& m = sharded_callback_map.at(channel);
         for (const auto& it : m.callbacks) {
             try {
                 const auto result = it.second(channel, message);
@@ -632,7 +632,7 @@ template <typename CallbackMap, typename PcallbackMap>
 void SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap, PcallbackMap>::SetCommandControl(
     const CommandControl& control
 ) {
-    const std::lock_guard<std::mutex> lock{mutex_};
+    const std::lock_guard<std::mutex> lock{mutex};
     common_command_control_ = control;
     common_command_control_.max_retries = 1;
 }
@@ -645,7 +645,7 @@ SubscriptionToken SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap,
 ) {
     size_t id = 0;
     {
-        const std::lock_guard<std::mutex> lock{mutex_};
+        const std::lock_guard<std::mutex> lock{mutex};
         id = GetNextSubscriptionId(lock);
     }
     SubscriptionToken token(implemented_, id);
@@ -662,7 +662,7 @@ SubscriptionToken SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap,
 ) {
     size_t id = 0;
     {
-        const std::lock_guard<std::mutex> lock{mutex_};
+        const std::lock_guard<std::mutex> lock{mutex};
         id = GetNextSubscriptionId(lock);
     }
     SubscriptionToken token(implemented_, id);
@@ -679,7 +679,7 @@ SubscriptionToken SubscriptionStorageBase::SubscriptionStorageImpl<CallbackMap,
 ) {
     size_t id = 0;
     {
-        const std::lock_guard<std::mutex> lock{mutex_};
+        const std::lock_guard<std::mutex> lock{mutex};
         id = GetNextSubscriptionId(lock);
     }
     SubscriptionToken token(implemented_, id);
@@ -699,11 +699,11 @@ const CommandControl& SubscriptionStorageBase::SubscriptionStorageImpl<CallbackM
     const ChannelName& channel_name
 ) const {
     if (channel_name.sharded) {
-        return sharded_callback_map_.at(channel_name.channel).control;
+        return sharded_callback_map.at(channel_name.channel).control;
     } else if (channel_name.pattern) {
-        return pattern_callback_map_.at(channel_name.channel).control;
+        return pattern_callback_map.at(channel_name.channel).control;
     } else {
-        return callback_map_.at(channel_name.channel).control;
+        return callback_map.at(channel_name.channel).control;
     }
 }
 
@@ -743,16 +743,16 @@ SubscriptionStorage::SubscriptionStorage(
 
 SubscriptionStorage::~SubscriptionStorage() = default;
 
-void SubscriptionStorage::SetSubscribeCallback(CommandCb cb) { storage_impl_.subscribe_callback_ = std::move(cb); }
+void SubscriptionStorage::SetSubscribeCallback(CommandCb cb) { storage_impl_.subscribe_callback = std::move(cb); }
 
-void SubscriptionStorage::SetUnsubscribeCallback(CommandCb cb) { storage_impl_.unsubscribe_callback_ = std::move(cb); }
+void SubscriptionStorage::SetUnsubscribeCallback(CommandCb cb) { storage_impl_.unsubscribe_callback = std::move(cb); }
 
 void SubscriptionStorage::SetShardedSubscribeCallback(ShardedCommandCb cb) {
-    storage_impl_.sharded_subscribe_callback_ = std::move(cb);
+    storage_impl_.sharded_subscribe_callback = std::move(cb);
 }
 
 void SubscriptionStorage::SetShardedUnsubscribeCallback(ShardedCommandCb cb) {
-    storage_impl_.sharded_unsubscribe_callback_ = std::move(cb);
+    storage_impl_.sharded_unsubscribe_callback = std::move(cb);
 }
 
 SubscriptionToken
@@ -791,7 +791,7 @@ void SubscriptionStorage::RequestRebalance(size_t shard_idx, ServerWeights weigh
 
 void SubscriptionStorage::DoRebalance(size_t shard_idx, ServerWeights weights) {
     /// Rebalances subscriptions between instances of shard
-    const std::lock_guard lock{storage_impl_.mutex_};
+    const std::lock_guard lock{storage_impl_.mutex};
     if (shard_idx >= storage_impl_.GetShardsCount(lock))
         throw std::runtime_error(
             "requested rebalance for non-existing shard (" + std::to_string(shard_idx) +
@@ -816,8 +816,8 @@ void SubscriptionStorage::SubscribeImpl(
     /// have to subscribe to every shard to be able to receive published message.
     /// In cluster mode subscribe to only one shard because we do not use
     /// previously mentioned workaround. So each instance in cluster is connected
-    const std::lock_guard<std::mutex> lock(storage_impl_.mutex_);
-    auto insert_res = storage_impl_.callback_map_.emplace(channel, ChannelInfo());
+    const std::lock_guard<std::mutex> lock(storage_impl_.mutex);
+    auto insert_res = storage_impl_.callback_map.emplace(channel, ChannelInfo());
     auto& map_iter = *insert_res.first;
     auto& channel_info = map_iter.second;
     auto& infos = channel_info.info;
@@ -850,7 +850,7 @@ void SubscriptionStorage::SubscribeImpl(
         }
     }
 
-    storage_impl_.callback_map_[channel].callbacks[id] = std::move(cb);
+    storage_impl_.callback_map[channel].callbacks[id] = std::move(cb);
 }
 
 void SubscriptionStorage::SsubscribeImpl(
@@ -868,8 +868,8 @@ void SubscriptionStorage::PsubscribeImpl(
     CommandControl control,
     SubscriptionId id
 ) {
-    const std::lock_guard<std::mutex> lock(storage_impl_.mutex_);
-    auto insert_res = storage_impl_.pattern_callback_map_.emplace(pattern, PChannelInfo());
+    const std::lock_guard<std::mutex> lock(storage_impl_.mutex);
+    auto insert_res = storage_impl_.pattern_callback_map.emplace(pattern, PChannelInfo());
     auto& map_iter = *insert_res.first;
     auto& channel_info = map_iter.second;
     auto& infos = channel_info.info;
@@ -902,7 +902,7 @@ void SubscriptionStorage::PsubscribeImpl(
         }
     }
 
-    storage_impl_.pattern_callback_map_[pattern].callbacks[id] = std::move(cb);
+    storage_impl_.pattern_callback_map[pattern].callbacks[id] = std::move(cb);
 }
 
 const std::string& SubscriptionStorage::GetShardName(size_t shard_idx) const {
diff --git a/redis/src/storages/redis/impl/subscription_storage.hpp b/redis/src/storages/redis/impl/subscription_storage.hpp
index ee5c17557fbb..1b65b95bb655 100644
--- a/redis/src/storages/redis/impl/subscription_storage.hpp
+++ b/redis/src/storages/redis/impl/subscription_storage.hpp
@@ -221,27 +221,27 @@ class SubscriptionStorageBase {
             return shards_count_;
         }
         void SetShardsCount(std::size_t shards_count) {
-            const std::lock_guard lock{mutex_};
+            const std::lock_guard lock{mutex};
             shards_count_ = shards_count;
         }
 
         void ClearCallbackMaps() {
-            const std::lock_guard lock{mutex_};
-            callback_map_.clear();
-            pattern_callback_map_.clear();
-            sharded_callback_map_.clear();
+            const std::lock_guard lock{mutex};
+            callback_map.clear();
+            pattern_callback_map.clear();
+            sharded_callback_map.clear();
         }
 
         // NOLINTBEGIN(misc-non-private-member-variables-in-classes)
-        mutable std::mutex mutex_;
-        CommandCb subscribe_callback_;
-        CommandCb unsubscribe_callback_;
-        ShardedCommandCb sharded_subscribe_callback_;
-        ShardedCommandCb sharded_unsubscribe_callback_;
-
-        CallbackMap callback_map_;
-        PcallbackMap pattern_callback_map_;
-        CallbackMap sharded_callback_map_;
+        mutable std::mutex mutex;
+        CommandCb subscribe_callback;
+        CommandCb unsubscribe_callback;
+        ShardedCommandCb sharded_subscribe_callback;
+        ShardedCommandCb sharded_unsubscribe_callback;
+
+        CallbackMap callback_map;
+        PcallbackMap pattern_callback_map;
+        CallbackMap sharded_callback_map;
         // NOLINTEND(misc-non-private-member-variables-in-classes)
 
     private:
diff --git a/redis/src/storages/redis/parse_reply.cpp b/redis/src/storages/redis/parse_reply.cpp
index 2fb77307888f..6d11d0323eb0 100644
--- a/redis/src/storages/redis/parse_reply.cpp
+++ b/redis/src/storages/redis/parse_reply.cpp
@@ -209,6 +209,22 @@ ParseReplyDataArray(ReplyData&& array_data, [[maybe_unused]] const std::string&
     return result;
 }
 
+std::vector<std::optional<Point>>
+ParseReplyDataArray(ReplyData&& array_data, const std::string& request_description, To<std::vector<std::optional<Point>>>) {
+    auto&& array = std::move(array_data).GetArray();
+    std::vector<std::optional<Point>> result;
+    result.reserve(array.size());
+
+    for (auto&& elem : array) {
+        if (elem.IsNil()) {
+            result.emplace_back(std::nullopt);
+            continue;
+        }
+        result.emplace_back(ParsePointArray(std::move(elem), request_description));
+    }
+    return result;
+}
+
 std::string Parse(ReplyData&& reply_data, const std::string& request_description, To<std::string>) {
     reply_data.ExpectString(request_description);
     return std::move(reply_data.GetString());
@@ -345,6 +361,11 @@ Parse(ReplyData&& reply_data, const std::string& request_description, To<std::un
     return result;
 }
 
+Point Parse(ReplyData&& reply_data, const std::string& request_description, To<Point>) {
+    reply_data.ExpectArray(request_description);
+    return ParsePointArray(reply_data, request_description);
+}
+
 ReplyData Parse(ReplyData&& reply_data, const std::string&, To<ReplyData>) { return std::move(reply_data); }
 
 }  // namespace storages::redis
diff --git a/redis/src/storages/redis/request_data_impl.hpp b/redis/src/storages/redis/request_data_impl.hpp
index 931e65d81ff7..8240c9d2ba44 100644
--- a/redis/src/storages/redis/request_data_impl.hpp
+++ b/redis/src/storages/redis/request_data_impl.hpp
@@ -22,19 +22,19 @@ namespace impl {
 
 void Wait(impl::Request& request);
 
-template <ScanTag scan_tag>
-storages::redis::Request<ScanReplyTmpl<scan_tag>> MakeScanRequest(
+template <ScanTag TScanTag>
+storages::redis::Request<ScanReplyTmpl<TScanTag>> MakeScanRequest(
     ClientImpl& client,
     std::string key,
     size_t shard,
-    typename ScanReplyTmpl<scan_tag>::Cursor cursor,
+    typename ScanReplyTmpl<TScanTag>::Cursor cursor,
     ScanOptionsGeneric options,
     const CommandControl& command_control
 ) {
-    if constexpr (scan_tag == ScanTag::kScan) {
+    if constexpr (TScanTag == ScanTag::kScan) {
         return client.MakeScanRequestNoKey(shard, cursor, std::move(options), command_control);
     } else {
-        return client.MakeScanRequestWithKey<scan_tag>(
+        return client.MakeScanRequestWithKey<TScanTag>(
             std::move(key), shard, cursor, std::move(options), command_control
         );
     }
@@ -124,31 +124,31 @@ class DummyRequestDataImpl final : public RequestDataBase<ReplyType> {
     ReplyPtr reply_;
 };
 
-template <ScanTag scan_tag>
-class RequestScanData final : public RequestScanDataBase<scan_tag> {
+template <ScanTag TScanTag>
+class RequestScanData final : public RequestScanDataBase<TScanTag> {
 public:
-    using ReplyElem = typename ScanReplyElem<scan_tag>::type;
+    using ReplyElem = typename ScanReplyElem<TScanTag>::type;
 
-    template <ScanTag scan_tag_param = scan_tag>
+    template <ScanTag ScanTagParam = TScanTag>
     RequestScanData(
         std::shared_ptr<ClientImpl> client,
         size_t shard,
         ScanOptionsGeneric options,
         const CommandControl& command_control,
-        std::enable_if_t<scan_tag_param == ScanTag::kScan>* = nullptr
+        std::enable_if_t<ScanTagParam == ScanTag::kScan>* = nullptr
     )
-        : RequestScanData(std::move(client), {}, shard, std::move(options), command_control, scan_tag) {}
+        : RequestScanData(std::move(client), {}, shard, std::move(options), command_control, TScanTag) {}
 
-    template <ScanTag scan_tag_param = scan_tag>
+    template <ScanTag ScanTagParam = TScanTag>
     RequestScanData(
         std::shared_ptr<ClientImpl> client,
         std::string key,
         size_t shard,
         ScanOptionsGeneric options,
         const CommandControl& command_control,
-        std::enable_if_t<scan_tag_param != ScanTag::kScan>* = nullptr
+        std::enable_if_t<ScanTagParam != ScanTag::kScan>* = nullptr
     )
-        : RequestScanData(std::move(client), std::move(key), shard, std::move(options), command_control, scan_tag) {}
+        : RequestScanData(std::move(client), std::move(key), shard, std::move(options), command_control, TScanTag) {}
 
     ReplyElem Get() override;
 
@@ -174,7 +174,7 @@ class RequestScanData final : public RequestScanDataBase<scan_tag> {
     ScanOptionsGeneric options_;
     CommandControl command_control_;
 
-    using ScanReply = ScanReplyTmpl<scan_tag>;
+    using ScanReply = ScanReplyTmpl<TScanTag>;
 
     std::unique_ptr<Request<ScanReply>> request_;
     std::unique_ptr<ScanReply> reply_;
@@ -182,8 +182,8 @@ class RequestScanData final : public RequestScanDataBase<scan_tag> {
     bool eof_{false};
 };
 
-template <ScanTag scan_tag>
-RequestScanData<scan_tag>::RequestScanData(
+template <ScanTag TScanTag>
+RequestScanData<TScanTag>::RequestScanData(
     std::shared_ptr<ClientImpl> client,
     std::string key,
     size_t shard,
@@ -197,33 +197,33 @@ RequestScanData<scan_tag>::RequestScanData(
       options_(std::move(options)),
       command_control_(command_control),
       request_(std::make_unique<Request<ScanReply>>(
-          impl::MakeScanRequest<scan_tag>(*client_, key_, shard_, {}, options_, command_control_)
+          impl::MakeScanRequest<TScanTag>(*client_, key_, shard_, {}, options_, command_control_)
       )) {}
 
-template <ScanTag scan_tag>
-typename RequestScanData<scan_tag>::ReplyElem RequestScanData<scan_tag>::Get() {
+template <ScanTag TScanTag>
+typename RequestScanData<TScanTag>::ReplyElem RequestScanData<TScanTag>::Get() {
     if (Eof()) throw RequestScan::GetAfterEofException("Trying to Get() after eof");
     UASSERT(reply_);
     UASSERT(reply_keys_index_ < reply_->GetKeys().size());
     return std::move(reply_->GetKeys()[reply_keys_index_++]);
 }
 
-template <ScanTag scan_tag>
-typename RequestScanData<scan_tag>::ReplyElem& RequestScanData<scan_tag>::Current() {
+template <ScanTag TScanTag>
+typename RequestScanData<TScanTag>::ReplyElem& RequestScanData<TScanTag>::Current() {
     if (Eof()) throw RequestScan::GetAfterEofException("Trying to call Current() after eof");
     UASSERT(reply_);
     UASSERT(reply_keys_index_ < reply_->GetKeys().size());
     return reply_->GetKeys()[reply_keys_index_];
 }
 
-template <ScanTag scan_tag>
-bool RequestScanData<scan_tag>::Eof() {
+template <ScanTag TScanTag>
+bool RequestScanData<TScanTag>::Eof() {
     CheckReply();
     return eof_;
 }
 
-template <ScanTag scan_tag>
-void RequestScanData<scan_tag>::CheckReply() {
+template <ScanTag TScanTag>
+void RequestScanData<TScanTag>::CheckReply() {
     while (!eof_ && (!reply_ || reply_keys_index_ == reply_->GetKeys().size())) {
         if (request_) {
             auto scan_reply_raw = request_->GetRaw();
@@ -240,7 +240,7 @@ void RequestScanData<scan_tag>::CheckReply() {
         reply_keys_index_ = 0;
 
         if (!eof_ && reply_->GetCursor().GetValue())
-            *request_ = impl::MakeScanRequest<scan_tag>(
+            *request_ = impl::MakeScanRequest<TScanTag>(
                 *client_, key_, shard_, reply_->GetCursor(), options_, command_control_
             );
         else
diff --git a/redis/src/storages/redis/scan_reply.hpp b/redis/src/storages/redis/scan_reply.hpp
index f1a116c11873..471d3ba46166 100644
--- a/redis/src/storages/redis/scan_reply.hpp
+++ b/redis/src/storages/redis/scan_reply.hpp
@@ -8,10 +8,10 @@ USERVER_NAMESPACE_BEGIN
 
 namespace storages::redis {
 
-template <ScanTag scan_tag>
+template <ScanTag TScanTag>
 class ScanReplyTmpl final {
 public:
-    using ReplyElem = typename ScanReplyElem<scan_tag>::type;
+    using ReplyElem = typename ScanReplyElem<TScanTag>::type;
 
     static ScanReplyTmpl Parse(ReplyData&& reply_data, const std::string& request_description);
 
@@ -42,8 +42,8 @@ class ScanReplyTmpl final {
     std::vector<ReplyElem> keys_;
 };
 
-template <ScanTag scan_tag>
-ScanReplyTmpl<scan_tag> ScanReplyTmpl<scan_tag>::Parse(ReplyData&& reply_data, const std::string& request_description) {
+template <ScanTag TScanTag>
+ScanReplyTmpl<TScanTag> ScanReplyTmpl<TScanTag>::Parse(ReplyData&& reply_data, const std::string& request_description) {
     reply_data.ExpectArray(request_description);
 
     auto& top_array = reply_data.GetArray();
diff --git a/redis/src/storages/redis/transaction_impl.cpp b/redis/src/storages/redis/transaction_impl.cpp
index f49db1abd63a..2529e153e5d7 100644
--- a/redis/src/storages/redis/transaction_impl.cpp
+++ b/redis/src/storages/redis/transaction_impl.cpp
@@ -100,6 +100,11 @@ RequestExpire TransactionImpl::Expire(std::string key, std::chrono::seconds ttl)
     return AddCmd<RequestExpire>("expire", true, std::move(key), ttl.count());
 }
 
+RequestExpire TransactionImpl::Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options) {
+    UpdateShard(key);
+    return AddCmd<RequestExpire>("expire", true, std::move(key), ttl.count(), options);
+}
+
 RequestGeoadd TransactionImpl::Geoadd(std::string key, GeoaddArg point_member) {
     UpdateShard(key);
     return AddCmd<RequestGeoadd>("geoadd", true, std::move(key), std::move(point_member));
@@ -110,6 +115,11 @@ RequestGeoadd TransactionImpl::Geoadd(std::string key, std::vector<GeoaddArg> po
     return AddCmd<RequestGeoadd>("geoadd", true, std::move(key), std::move(point_members));
 }
 
+RequestGeopos TransactionImpl::Geopos(std::string key, std::vector<std::string> members) {
+    UpdateShard(key);
+    return AddCmd<RequestGeopos>("geopos", false, std::move(key), std::move(members));
+}
+
 RequestGeoradius TransactionImpl::Georadius(
     std::string key,
     Longitude lon,
diff --git a/redis/src/storages/redis/transaction_impl.hpp b/redis/src/storages/redis/transaction_impl.hpp
index 49237517bf5b..737c1662269c 100644
--- a/redis/src/storages/redis/transaction_impl.hpp
+++ b/redis/src/storages/redis/transaction_impl.hpp
@@ -92,10 +92,14 @@ class TransactionImpl final : public Transaction {
 
     RequestExpire Expire(std::string key, std::chrono::seconds ttl) override;
 
+    RequestExpire Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options) override;
+
     RequestGeoadd Geoadd(std::string key, GeoaddArg point_member) override;
 
     RequestGeoadd Geoadd(std::string key, std::vector<GeoaddArg> point_members) override;
 
+    RequestGeopos Geopos(std::string key, std::vector<std::string> members) override;
+
     RequestGeoradius Georadius(
         std::string key,
         Longitude lon,
diff --git a/redis/src/storages/redis/transaction_redistest.cpp b/redis/src/storages/redis/transaction_redistest.cpp
index 4ce84d10a3d0..8d825f6d3d91 100644
--- a/redis/src/storages/redis/transaction_redistest.cpp
+++ b/redis/src/storages/redis/transaction_redistest.cpp
@@ -7,6 +7,9 @@ USERVER_NAMESPACE_BEGIN
 namespace {
 constexpr storages::redis::CommandControl kDefaultCc{std::chrono::milliseconds(500), std::chrono::milliseconds(500), 1};
 
+using storages::redis::ExpireOptions;
+using storages::redis::ExpireReply;
+
 class RedisClientTransactionTest : public RedisClientTest {
 public:
     auto& GetTransactionClient() {
@@ -221,11 +224,124 @@ UTEST_F(RedisClientTransactionTest, Expire) {
     auto& client = GetTransactionClient();
     Get(client->Set("mykey", "Hello"));
     EXPECT_EQ(Get(client->Expire("mykey", std::chrono::seconds(10))), storages::redis::ExpireReply::kTimeoutWasSet);
-    EXPECT_EQ(Get(client->Ttl("mykey")).GetExpireSeconds(), 10);
+    EXPECT_EQ(Get(client->Ttl("mykey")).GetExpire().count(), 10);
     Get(client->Set("mykey", "Hello World"));
     EXPECT_FALSE(Get(client->Ttl("mykey")).KeyHasExpiration());
 }
 
+struct ExpireOptionsTransactionTestCase {
+    std::optional<int> initial_expire;
+    int new_expire;
+    ExpireOptions options;
+    storages::redis::ExpireReply expected_reply;
+};
+
+class RedisExpireOptionsTransactionTest : public RedisClientTransactionTest,
+                                          public ::testing::WithParamInterface<ExpireOptionsTransactionTestCase> {};
+
+UTEST_P(RedisExpireOptionsTransactionTest, ExpireOptionsTest) {
+    const Version since{7, 0, 0};
+    if (!CheckVersion(since)) GTEST_SKIP() << SkipMsgByVersion("Expire options", since);
+
+    auto& client = GetTransactionClient();
+    auto [initial_expire, new_expire, options, expected_reply] = GetParam();
+
+    Get(client->Set("mykey", "Hello"));
+    if (initial_expire.has_value()) {
+        Get(client->Expire("mykey", std::chrono::seconds(initial_expire.value())));
+    }
+    EXPECT_EQ(Get(client->Expire("mykey", std::chrono::seconds(new_expire), options)), expected_reply);
+
+    switch (expected_reply) {
+        case ExpireReply::kKeyDoesNotExist:
+            if (initial_expire.has_value()) {
+                EXPECT_EQ(Get(client->Ttl("mykey")).GetExpire().count(), initial_expire.value());
+            } else {
+                EXPECT_FALSE(Get(client->Ttl("mykey")).KeyHasExpiration());
+            }
+            break;
+        case ExpireReply::kTimeoutWasSet:
+            EXPECT_EQ(Get(client->Ttl("mykey")).GetExpire().count(), new_expire);
+            break;
+    }
+}
+
+INSTANTIATE_UTEST_SUITE_P(
+    RedisClientTransactionTest,
+    RedisExpireOptionsTransactionTest,
+    testing::Values(
+        // initial_expire, new_expire, options, expected_reply
+        ExpireOptionsTransactionTestCase{
+            std::nullopt,
+            10,
+            ExpireOptions(ExpireOptions::Compare::kGreaterThan),
+            ExpireReply::kKeyDoesNotExist},
+        ExpireOptionsTransactionTestCase{
+            9,
+            10,
+            ExpireOptions(ExpireOptions::Compare::kGreaterThan),
+            ExpireReply::kTimeoutWasSet},
+        ExpireOptionsTransactionTestCase{
+            11,
+            10,
+            ExpireOptions(ExpireOptions::Compare::kGreaterThan),
+            ExpireReply::kKeyDoesNotExist},
+
+        ExpireOptionsTransactionTestCase{
+            std::nullopt,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan),
+            ExpireReply::kTimeoutWasSet},
+        ExpireOptionsTransactionTestCase{
+            std::nullopt,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan, ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kKeyDoesNotExist},
+        ExpireOptionsTransactionTestCase{
+            19,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan),
+            ExpireReply::kKeyDoesNotExist},
+        ExpireOptionsTransactionTestCase{
+            21,
+            20,
+            ExpireOptions(ExpireOptions::Compare::kLessThan),
+            ExpireReply::kTimeoutWasSet},
+
+        ExpireOptionsTransactionTestCase{
+            std::nullopt,
+            30,
+            ExpireOptions(ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kKeyDoesNotExist},
+        ExpireOptionsTransactionTestCase{
+            29,
+            30,
+            ExpireOptions(ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kTimeoutWasSet},
+        ExpireOptionsTransactionTestCase{
+            31,
+            30,
+            ExpireOptions(ExpireOptions::Exist::kSetIfExist),
+            ExpireReply::kTimeoutWasSet},
+
+        ExpireOptionsTransactionTestCase{
+            std::nullopt,
+            40,
+            ExpireOptions(ExpireOptions::Exist::kSetIfNotExist),
+            ExpireReply::kTimeoutWasSet},
+        ExpireOptionsTransactionTestCase{
+            39,
+            40,
+            ExpireOptions(ExpireOptions::Exist::kSetIfNotExist),
+            ExpireReply::kKeyDoesNotExist},
+        ExpireOptionsTransactionTestCase{
+            41,
+            40,
+            ExpireOptions(ExpireOptions::Exist::kSetIfNotExist),
+            ExpireReply::kKeyDoesNotExist}
+    )
+);
+
 UTEST_F(RedisClientTransactionTest, Georadius) {
     auto& client = GetTransactionClient();
     Get(client->Geoadd("Sicily", {{13.361389, 38.115556, "Palermo"}, {15.087269, 37.502669, "Catania"}}));
@@ -247,6 +363,22 @@ UTEST_F(RedisClientTransactionTest, Georadius) {
     EXPECT_EQ(result[1].dist, 56.4413);
 }
 
+UTEST_F(RedisClientTransactionTest, Geopos) {
+    auto& client = GetTransactionClient();
+    Get(client->Geoadd("Sicily", {{13.1, 38.2, "Palermo"}, {15.3, 37.4, "Catania"}}));
+
+    const auto result = Get(client->Geopos("Sicily", std::vector<std::string>{"Palermo", "Catania", "NonExisting"}));
+    const auto kGeoTolerance = 1e-5;
+    EXPECT_EQ(result.size(), 3);
+    EXPECT_TRUE(result[0].has_value());
+    EXPECT_TRUE(result[1].has_value());
+    EXPECT_FALSE(result[2].has_value());
+    EXPECT_NEAR(result[0].value().lon, 13.1, kGeoTolerance);
+    EXPECT_NEAR(result[0].value().lat, 38.2, kGeoTolerance);
+    EXPECT_NEAR(result[1].value().lon, 15.3, kGeoTolerance);
+    EXPECT_NEAR(result[1].value().lat, 37.4, kGeoTolerance);
+}
+
 UTEST_F(RedisClientTransactionTest, Getset) {
     auto& client = GetTransactionClient();
     EXPECT_EQ(Get(client->Incr("key")), 1);
@@ -491,7 +623,7 @@ UTEST_F(RedisClientTransactionTest, Pexpire) {
     EXPECT_EQ(
         Get(client->Pexpire("key", std::chrono::milliseconds{1999})), storages::redis::ExpireReply::kTimeoutWasSet
     );
-    EXPECT_EQ(Get(client->Ttl("key")).GetExpireSeconds(), 2);
+    EXPECT_EQ(Get(client->Ttl("key")).GetExpire().count(), 2);
 }
 
 UTEST_F(RedisClientTransactionTest, Ping) {
@@ -577,7 +709,7 @@ UTEST_F(RedisClientTransactionTest, Setex) {
     auto& client = GetTransactionClient();
 
     EXPECT_NO_THROW(Get(client->Setex("key", std::chrono::seconds{10}, "value")));
-    EXPECT_EQ(Get(client->Ttl("key")).GetExpireSeconds(), 10);
+    EXPECT_EQ(Get(client->Ttl("key")).GetExpire().count(), 10);
 }
 
 UTEST_F(RedisClientTransactionTest, Sismember) {
diff --git a/redis/src/storages/redis/ttl_reply.cpp b/redis/src/storages/redis/ttl_reply.cpp
index fb2ddf4fdc74..f8ca96b4b77f 100644
--- a/redis/src/storages/redis/ttl_reply.cpp
+++ b/redis/src/storages/redis/ttl_reply.cpp
@@ -19,9 +19,9 @@ bool TtlReply::KeyExists() const { return value_ != static_cast<int64_t>(kKeyDoe
 
 bool TtlReply::KeyHasExpiration() const { return value_ >= 0; }
 
-size_t TtlReply::GetExpireSeconds() const {
+std::chrono::seconds TtlReply::GetExpire() const {
     if (!KeyHasExpiration()) throw KeyHasNoExpirationException("key has no associated expire or does not exist");
-    return value_;
+    return std::chrono::seconds{value_};
 }
 
 }  // namespace storages::redis
diff --git a/redis/testing/include/userver/storages/redis/mock_client_base.hpp b/redis/testing/include/userver/storages/redis/mock_client_base.hpp
index 985352720751..3b3601876b02 100644
--- a/redis/testing/include/userver/storages/redis/mock_client_base.hpp
+++ b/redis/testing/include/userver/storages/redis/mock_client_base.hpp
@@ -87,6 +87,12 @@ class MockClientBase : public Client, public std::enable_shared_from_this<MockCl
         std::vector<std::string> args,
         const CommandControl& command_control
     ) override;
+    RequestGenericCommon GenericCommon(
+        std::string command,
+        std::vector<std::string> args,
+        size_t key_index,
+        const CommandControl& command_control
+    ) override;
 
     RequestScriptLoad ScriptLoad(std::string script, size_t shard, const CommandControl& command_control) override;
 
@@ -96,11 +102,21 @@ class MockClientBase : public Client, public std::enable_shared_from_this<MockCl
 
     RequestExpire Expire(std::string key, std::chrono::seconds ttl, const CommandControl& command_control) override;
 
+    RequestExpire Expire(
+        std::string key,
+        std::chrono::seconds ttl,
+        ExpireOptions options,
+        const CommandControl& command_control
+    ) override;
+
     RequestGeoadd Geoadd(std::string key, GeoaddArg point_member, const CommandControl& command_control) override;
 
     RequestGeoadd Geoadd(std::string key, std::vector<GeoaddArg> point_members, const CommandControl& command_control)
         override;
 
+    RequestGeopos Geopos(std::string key, std::vector<std::string> members, const CommandControl& command_control)
+        override;
+
     RequestGeoradius Georadius(
         std::string key,
         Longitude lon,
diff --git a/redis/testing/include/userver/storages/redis/mock_request.hpp b/redis/testing/include/userver/storages/redis/mock_request.hpp
index 20e991b30a51..799a9bdac2f8 100644
--- a/redis/testing/include/userver/storages/redis/mock_request.hpp
+++ b/redis/testing/include/userver/storages/redis/mock_request.hpp
@@ -84,10 +84,10 @@ class MockRequestDataTimeout final : public RequestDataBase<ReplyType> {
     }
 };
 
-template <ScanTag scan_tag>
-class MockRequestScanData : public RequestScanDataBase<scan_tag> {
+template <ScanTag TScanTag>
+class MockRequestScanData : public RequestScanDataBase<TScanTag> {
 public:
-    using ReplyElem = typename ScanReplyElem<scan_tag>::type;
+    using ReplyElem = typename ScanReplyElem<TScanTag>::type;
 
     template <typename Data>
     explicit MockRequestScanData(const Data& data) : MockRequestScanData(data.begin(), data.end()) {}
@@ -141,9 +141,9 @@ Request CreateMockRequestTimeout() {
     return Request(std::make_unique<impl::MockRequestDataTimeout<typename Request::Result, typename Request::Reply>>());
 }
 
-template <ScanTag scan_tag>
-ScanRequest<scan_tag> CreateMockRequestScan(const std::vector<typename ScanReplyElem<scan_tag>::type>& reply_data) {
-    return ScanRequest<scan_tag>(std::make_unique<impl::MockRequestScanData<scan_tag>>(reply_data));
+template <ScanTag TScanTag>
+ScanRequest<TScanTag> CreateMockRequestScan(const std::vector<typename ScanReplyElem<TScanTag>::type>& reply_data) {
+    return ScanRequest<TScanTag>(std::make_unique<impl::MockRequestScanData<TScanTag>>(reply_data));
 }
 
 }  // namespace storages::redis
diff --git a/redis/testing/include/userver/storages/redis/mock_transaction.hpp b/redis/testing/include/userver/storages/redis/mock_transaction.hpp
index f40e2da287ed..56388df6a460 100644
--- a/redis/testing/include/userver/storages/redis/mock_transaction.hpp
+++ b/redis/testing/include/userver/storages/redis/mock_transaction.hpp
@@ -45,10 +45,14 @@ class MockTransaction final : public Transaction {
 
     RequestExpire Expire(std::string key, std::chrono::seconds ttl) override;
 
+    RequestExpire Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options) override;
+
     RequestGeoadd Geoadd(std::string key, GeoaddArg point_member) override;
 
     RequestGeoadd Geoadd(std::string key, std::vector<GeoaddArg> point_members) override;
 
+    RequestGeopos Geopos(std::string key, std::vector<std::string> members) override;
+
     RequestGeoradius Georadius(
         std::string key,
         Longitude lon,
diff --git a/redis/testing/include/userver/storages/redis/mock_transaction_impl_base.hpp b/redis/testing/include/userver/storages/redis/mock_transaction_impl_base.hpp
index fcc576815d50..a62d3603b32c 100644
--- a/redis/testing/include/userver/storages/redis/mock_transaction_impl_base.hpp
+++ b/redis/testing/include/userver/storages/redis/mock_transaction_impl_base.hpp
@@ -35,10 +35,14 @@ class MockTransactionImplBase {
 
     virtual RequestExpire Expire(std::string key, std::chrono::seconds ttl);
 
+    virtual RequestExpire Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options);
+
     virtual RequestGeoadd Geoadd(std::string key, GeoaddArg point_member);
 
     virtual RequestGeoadd Geoadd(std::string key, std::vector<GeoaddArg> point_members);
 
+    virtual RequestGeopos Geopos(std::string key, std::vector<std::string> members);
+
     virtual RequestGeoradius
     Georadius(std::string key, Longitude lon, Latitude lat, double radius, const GeoradiusOptions& georadius_options);
 
diff --git a/redis/testing/src/storages/redis/mock_client_base.cpp b/redis/testing/src/storages/redis/mock_client_base.cpp
index d8fc56390fdb..ced3321b01e4 100644
--- a/redis/testing/src/storages/redis/mock_client_base.cpp
+++ b/redis/testing/src/storages/redis/mock_client_base.cpp
@@ -10,6 +10,10 @@ namespace storages::redis {
 
 using utils::AbortWithStacktrace;
 
+namespace {
+constexpr std::string_view kNotMocked{"Redis method is not mocked"};
+}
+
 MockClientBase::MockClientBase()
     : mock_transaction_impl_creator_(std::make_unique<MockTransactionImplCreator<MockTransactionImplBase>>()) {}
 
@@ -33,7 +37,7 @@ size_t MockClientBase::ShardByKey(const std::string& /*key*/) const { return 0;
 
 RequestAppend
 MockClientBase::Append(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestBitop MockClientBase::Bitop(
@@ -42,31 +46,31 @@ RequestBitop MockClientBase::Bitop(
     std::vector<std::string> /*src_keys*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestDbsize MockClientBase::Dbsize(size_t /*shard*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestDecr MockClientBase::Decr(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestDel MockClientBase::Del(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestDel MockClientBase::Del(std::vector<std::string> /*keys*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestUnlink MockClientBase::Unlink(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestUnlink MockClientBase::Unlink(std::vector<std::string> /*keys*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestEvalCommon MockClientBase::EvalCommon(
@@ -75,7 +79,7 @@ RequestEvalCommon MockClientBase::EvalCommon(
     std::vector<std::string> /*args*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestEvalShaCommon MockClientBase::EvalShaCommon(
@@ -84,35 +88,58 @@ RequestEvalShaCommon MockClientBase::EvalShaCommon(
     std::vector<std::string> /*args*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
+}
+
+RequestGenericCommon MockClientBase::GenericCommon(
+    std::string /*command*/,
+    std::vector<std::string> /*args*/,
+    size_t /*key_index*/,
+    const CommandControl& /*command_control*/
+) {
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestScriptLoad
 MockClientBase::ScriptLoad(std::string /*script*/, size_t /*shard*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestExists MockClientBase::Exists(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestExists MockClientBase::Exists(std::vector<std::string> /*keys*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestExpire
 MockClientBase::Expire(std::string /*key*/, std::chrono::seconds /*ttl*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
+}
+
+RequestExpire MockClientBase::Expire(
+    std::string /*key*/,
+    std::chrono::seconds /*ttl*/,
+    ExpireOptions /*option*/,
+    const CommandControl& /*command_control*/
+) {
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeoadd
 MockClientBase::Geoadd(std::string /*key*/, GeoaddArg /*point_member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeoadd MockClientBase::
     Geoadd(std::string /*key*/, std::vector<GeoaddArg> /*point_members*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
+}
+
+RequestGeopos MockClientBase::
+    Geopos(std::string /*key*/, std::vector<std::string> /*members*/, const CommandControl& /*command_control*/) {
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeoradius MockClientBase::Georadius(
@@ -123,7 +150,7 @@ RequestGeoradius MockClientBase::Georadius(
     const GeoradiusOptions& /*georadius_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeosearch MockClientBase::Geosearch(
@@ -133,7 +160,7 @@ RequestGeosearch MockClientBase::Geosearch(
     const GeosearchOptions& /*geosearch_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeosearch MockClientBase::Geosearch(
@@ -144,7 +171,7 @@ RequestGeosearch MockClientBase::Geosearch(
     const GeosearchOptions& /*geosearch_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeosearch MockClientBase::Geosearch(
@@ -155,7 +182,7 @@ RequestGeosearch MockClientBase::Geosearch(
     const GeosearchOptions& /*geosearch_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGeosearch MockClientBase::Geosearch(
@@ -167,40 +194,40 @@ RequestGeosearch MockClientBase::Geosearch(
     const GeosearchOptions& /*geosearch_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGet MockClientBase::Get(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestGetset
 MockClientBase::Getset(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHdel
 MockClientBase::Hdel(std::string /*key*/, std::string /*field*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHdel MockClientBase::
     Hdel(std::string /*key*/, std::vector<std::string> /*fields*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHexists
 MockClientBase::Hexists(std::string /*key*/, std::string /*field*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHget
 MockClientBase::Hget(std::string /*key*/, std::string /*field*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHgetall MockClientBase::Hgetall(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHincrby MockClientBase::Hincrby(
@@ -209,7 +236,7 @@ RequestHincrby MockClientBase::Hincrby(
     int64_t /*increment*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHincrbyfloat MockClientBase::Hincrbyfloat(
@@ -218,20 +245,20 @@ RequestHincrbyfloat MockClientBase::Hincrbyfloat(
     double /*increment*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHkeys MockClientBase::Hkeys(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHlen MockClientBase::Hlen(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHmget MockClientBase::
     Hmget(std::string /*key*/, std::vector<std::string> /*fields*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHmset MockClientBase::Hmset(
@@ -239,7 +266,7 @@ RequestHmset MockClientBase::Hmset(
     std::vector<std::pair<std::string, std::string>> /*field_values*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 ScanRequest<ScanTag::kHscan> MockClientBase::Hscan(
@@ -247,12 +274,12 @@ ScanRequest<ScanTag::kHscan> MockClientBase::Hscan(
     HscanOptions /*options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHset MockClientBase::
     Hset(std::string /*key*/, std::string /*field*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHsetnx MockClientBase::Hsetnx(
@@ -261,90 +288,90 @@ RequestHsetnx MockClientBase::Hsetnx(
     std::string /*value*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestHvals MockClientBase::Hvals(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestIncr MockClientBase::Incr(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestKeys
 MockClientBase::Keys(std::string /*keys_pattern*/, size_t /*shard*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLindex
 MockClientBase::Lindex(std::string /*key*/, int64_t /*index*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLlen MockClientBase::Llen(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLpop MockClientBase::Lpop(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLpush
 MockClientBase::Lpush(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLpush MockClientBase::
     Lpush(std::string /*key*/, std::vector<std::string> /*values*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLpushx
 MockClientBase::Lpushx(std::string /*key*/, std::string /*element*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLrange MockClientBase::
     Lrange(std::string /*key*/, int64_t /*start*/, int64_t /*stop*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLrem MockClientBase::
     Lrem(std::string /*key*/, int64_t /*count*/, std::string /*element*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestLtrim MockClientBase::
     Ltrim(std::string /*key*/, int64_t /*start*/, int64_t /*stop*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestMget MockClientBase::Mget(std::vector<std::string> /*keys*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestMset MockClientBase::
     Mset(std::vector<std::pair<std::string, std::string>> /*key_values*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestPersist MockClientBase::Persist(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestPexpire MockClientBase::
     Pexpire(std::string /*key*/, std::chrono::milliseconds /*ttl*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestPing MockClientBase::Ping(size_t /*shard*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestPingMessage
 MockClientBase::Ping(size_t /*shard*/, std::string /*message*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 void MockClientBase::Publish(
@@ -353,59 +380,59 @@ void MockClientBase::Publish(
     const CommandControl& /*command_control*/,
     PubShard /*policy*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 void MockClientBase::
     Spublish(std::string /*channel*/, std::string /*message*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestRename
 MockClientBase::Rename(std::string /*key*/, std::string /*new_key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestRpop MockClientBase::Rpop(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestRpush
 MockClientBase::Rpush(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestRpush MockClientBase::
     Rpush(std::string /*key*/, std::vector<std::string> /*values*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestRpushx
 MockClientBase::Rpushx(std::string /*key*/, std::string /*element*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSadd
 MockClientBase::Sadd(std::string /*key*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSadd MockClientBase::
     Sadd(std::string /*key*/, std::vector<std::string> /*members*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 ScanRequest<ScanTag::kScan>
 MockClientBase::Scan(size_t /*shard*/, ScanOptions /*options*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestScard MockClientBase::Scard(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSet MockClientBase::Set(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSet MockClientBase::
@@ -413,12 +440,12 @@ RequestSet MockClientBase::
         std::string /*value*/,
         std::chrono::milliseconds /*ttl*/,
         const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetIfExist
 MockClientBase::SetIfExist(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetIfExist MockClientBase::SetIfExist(
@@ -427,12 +454,12 @@ RequestSetIfExist MockClientBase::SetIfExist(
     std::chrono::milliseconds /*ttl*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetIfNotExist
 MockClientBase::SetIfNotExist(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetIfNotExist MockClientBase::SetIfNotExist(
@@ -441,12 +468,12 @@ RequestSetIfNotExist MockClientBase::SetIfNotExist(
     std::chrono::milliseconds /*ttl*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetIfNotExistOrGet MockClientBase::
     SetIfNotExistOrGet(std::string /*key*/, std::string /*value*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetIfNotExistOrGet MockClientBase::SetIfNotExistOrGet(
@@ -455,7 +482,7 @@ RequestSetIfNotExistOrGet MockClientBase::SetIfNotExistOrGet(
     std::chrono::milliseconds /*ttl*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSetex MockClientBase::Setex(
@@ -464,35 +491,35 @@ RequestSetex MockClientBase::Setex(
     std::string /*value*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSismember
 MockClientBase::Sismember(std::string /*key*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSmembers MockClientBase::Smembers(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSrandmember MockClientBase::Srandmember(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSrandmembers
 MockClientBase::Srandmembers(std::string /*key*/, int64_t /*count*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSrem
 MockClientBase::Srem(std::string /*key*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestSrem MockClientBase::
     Srem(std::string /*key*/, std::vector<std::string> /*members*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 ScanRequest<ScanTag::kSscan> MockClientBase::Sscan(
@@ -500,28 +527,28 @@ ScanRequest<ScanTag::kSscan> MockClientBase::Sscan(
     SscanOptions /*options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestStrlen MockClientBase::Strlen(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestTime MockClientBase::Time(size_t /*shard*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestTtl MockClientBase::Ttl(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestType MockClientBase::Type(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZadd MockClientBase::
     Zadd(std::string /*key*/, double /*score*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZadd MockClientBase::Zadd(
@@ -531,7 +558,7 @@ RequestZadd MockClientBase::Zadd(
     const ZaddOptions& /*options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZadd MockClientBase::Zadd(
@@ -539,7 +566,7 @@ RequestZadd MockClientBase::Zadd(
     std::vector<std::pair<double, std::string>> /*scored_members*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZadd MockClientBase::Zadd(
@@ -548,12 +575,12 @@ RequestZadd MockClientBase::Zadd(
     const ZaddOptions& /*options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZaddIncr MockClientBase::
     ZaddIncr(std::string /*key*/, double /*score*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZaddIncrExisting MockClientBase::ZaddIncrExisting(
@@ -562,21 +589,21 @@ RequestZaddIncrExisting MockClientBase::ZaddIncrExisting(
     std::string /*member*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZcard MockClientBase::Zcard(std::string /*key*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZcount
 MockClientBase::Zcount(std::string /*key*/, double /*min*/, double /*max*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrange MockClientBase::
     Zrange(std::string /*key*/, int64_t /*start*/, int64_t /*stop*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangeWithScores MockClientBase::ZrangeWithScores(
@@ -585,12 +612,12 @@ RequestZrangeWithScores MockClientBase::ZrangeWithScores(
     int64_t /*stop*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscore MockClientBase::
     Zrangebyscore(std::string /*key*/, double /*min*/, double /*max*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscore MockClientBase::Zrangebyscore(
@@ -599,7 +626,7 @@ RequestZrangebyscore MockClientBase::Zrangebyscore(
     std::string /*max*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscore MockClientBase::Zrangebyscore(
@@ -609,7 +636,7 @@ RequestZrangebyscore MockClientBase::Zrangebyscore(
     const RangeOptions& /*range_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscore MockClientBase::Zrangebyscore(
@@ -619,7 +646,7 @@ RequestZrangebyscore MockClientBase::Zrangebyscore(
     const RangeOptions& /*range_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
@@ -628,7 +655,7 @@ RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
     double /*max*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
@@ -637,7 +664,7 @@ RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
     std::string /*max*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
@@ -647,7 +674,7 @@ RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
     const RangeOptions& /*range_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
@@ -657,17 +684,17 @@ RequestZrangebyscoreWithScores MockClientBase::ZrangebyscoreWithScores(
     const RangeOptions& /*range_options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrem
 MockClientBase::Zrem(std::string /*key*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZrem MockClientBase::
     Zrem(std::string /*key*/, std::vector<std::string> /*members*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZremrangebyrank MockClientBase::Zremrangebyrank(
@@ -676,12 +703,12 @@ RequestZremrangebyrank MockClientBase::Zremrangebyrank(
     int64_t /*stop*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZremrangebyscore MockClientBase::
     Zremrangebyscore(std::string /*key*/, double /*min*/, double /*max*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZremrangebyscore MockClientBase::Zremrangebyscore(
@@ -690,7 +717,7 @@ RequestZremrangebyscore MockClientBase::Zremrangebyscore(
     std::string /*max*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 ScanRequest<ScanTag::kZscan> MockClientBase::Zscan(
@@ -698,12 +725,12 @@ ScanRequest<ScanTag::kZscan> MockClientBase::Zscan(
     ZscanOptions /*options*/,
     const CommandControl& /*command_control*/
 ) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 RequestZscore
 MockClientBase::Zscore(std::string /*key*/, std::string /*member*/, const CommandControl& /*command_control*/) {
-    AbortWithStacktrace("Redis method not mocked");
+    AbortWithStacktrace(kNotMocked);
 }
 
 // end of redis commands
diff --git a/redis/testing/src/storages/redis/mock_transaction.cpp b/redis/testing/src/storages/redis/mock_transaction.cpp
index e422924ff348..bea424f631e2 100644
--- a/redis/testing/src/storages/redis/mock_transaction.cpp
+++ b/redis/testing/src/storages/redis/mock_transaction.cpp
@@ -160,6 +160,11 @@ RequestExpire MockTransaction::Expire(std::string key, std::chrono::seconds ttl)
     return AddSubrequest(impl_->Expire(std::move(key), ttl));
 }
 
+RequestExpire MockTransaction::Expire(std::string key, std::chrono::seconds ttl, ExpireOptions options) {
+    UpdateShard(key);
+    return AddSubrequest(impl_->Expire(std::move(key), ttl, options));
+}
+
 RequestGeoadd MockTransaction::Geoadd(std::string key, GeoaddArg point_member) {
     UpdateShard(key);
     return AddSubrequest(impl_->Geoadd(std::move(key), point_member));
@@ -170,6 +175,11 @@ RequestGeoadd MockTransaction::Geoadd(std::string key, std::vector<GeoaddArg> po
     return AddSubrequest(impl_->Geoadd(std::move(key), std::move(point_members)));
 }
 
+RequestGeopos MockTransaction::Geopos(std::string key, std::vector<std::string> members) {
+    UpdateShard(key);
+    return AddSubrequest(impl_->Geopos(std::move(key), std::move(members)));
+}
+
 RequestGeoradius MockTransaction::Georadius(
     std::string key,
     Longitude lon,
diff --git a/redis/testing/src/storages/redis/mock_transaction_impl_base.cpp b/redis/testing/src/storages/redis/mock_transaction_impl_base.cpp
index a1080b16c673..cb8a1a12f5b4 100644
--- a/redis/testing/src/storages/redis/mock_transaction_impl_base.cpp
+++ b/redis/testing/src/storages/redis/mock_transaction_impl_base.cpp
@@ -45,6 +45,11 @@ RequestExpire MockTransactionImplBase::Expire(std::string /*key*/, std::chrono::
     AbortWithStacktrace("Redis method not mocked");
 }
 
+RequestExpire
+MockTransactionImplBase::Expire(std::string /*key*/, std::chrono::seconds /*ttl*/, ExpireOptions /*option*/) {
+    AbortWithStacktrace("Redis method not mocked");
+}
+
 RequestGeoadd MockTransactionImplBase::Geoadd(std::string /*key*/, GeoaddArg /*point_member*/) {
     AbortWithStacktrace("Redis method not mocked");
 }
@@ -53,6 +58,10 @@ RequestGeoadd MockTransactionImplBase::Geoadd(std::string /*key*/, std::vector<G
     AbortWithStacktrace("Redis method not mocked");
 }
 
+RequestGeopos MockTransactionImplBase::Geopos(std::string /*key*/, std::vector<std::string> /*members*/) {
+    AbortWithStacktrace("Redis method not mocked");
+}
+
 RequestGeoradius MockTransactionImplBase::Georadius(
     std::string /*key*/,
     Longitude /*lon*/,
diff --git a/rocks/CMakeLists.txt b/rocks/CMakeLists.txt
index b89624d917df..32f30271b3f4 100644
--- a/rocks/CMakeLists.txt
+++ b/rocks/CMakeLists.txt
@@ -7,4 +7,5 @@ userver_module(
     SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
     LINK_LIBRARIES RocksDB::rocksdb
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    DEPENDS core
 )
diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt
index 6c007e9cf27f..97a6508f9470 100644
--- a/samples/CMakeLists.txt
+++ b/samples/CMakeLists.txt
@@ -147,5 +147,14 @@ if(USERVER_FEATURE_S3API)
     add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-s3api)
 endif()
 
+_userver_directory_install(
+    COMPONENT examples
+    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    DESTINATION share/userver
+)
+_userver_install_component(MODULE examples DEPENDS "")
+# libuserver-samples, not libuserver-samples-dev
+set(CPACK_DEBIAN_SAMPLES_PACKAGE_NAME libuserver-examples)
+
 # Clean up fake userver installation above to avoid messing with find_package(userver) in the parent project.
 file(REMOVE "${CMAKE_BINARY_DIR}/package_stubs/userverConfig.cmake")
diff --git a/samples/chaotic_openapi_service/CMakeLists.txt b/samples/chaotic_openapi_service/CMakeLists.txt
index c9482c79944c..4fcf56b6c60e 100644
--- a/samples/chaotic_openapi_service/CMakeLists.txt
+++ b/samples/chaotic_openapi_service/CMakeLists.txt
@@ -18,7 +18,7 @@ target_link_libraries(${PROJECT_NAME} ${PROJECT_NAME}_objs)
 userver_target_generate_openapi_client(
     ${PROJECT_NAME}-client-test_objs
     NAME test
-    OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/client/test"
+    OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/clients/test"
     SCHEMAS ${CMAKE_CURRENT_SOURCE_DIR}/clients/test.yaml
 )
 target_link_libraries(${PROJECT_NAME}_objs ${PROJECT_NAME}-client-test_objs)
diff --git a/samples/chaotic_openapi_service/main.cpp b/samples/chaotic_openapi_service/main.cpp
index 1e6bdcfadb95..769b47c8e434 100644
--- a/samples/chaotic_openapi_service/main.cpp
+++ b/samples/chaotic_openapi_service/main.cpp
@@ -10,29 +10,27 @@
 #include <userver/utest/using_namespace_userver.hpp>
 #include <userver/utils/daemon_run.hpp>
 
-// Note: this is for the purposes of tests/samples only
-#include <userver/utest/using_namespace_userver.hpp>
-
 #include <clients/test/component.hpp>
 #include <clients/test/qos.hpp>
 
 #include <hello_handler.hpp>
 
 int main(int argc, char* argv[]) {
-    auto component_list = components::MinimalServerComponentList()
-                              .Append<samples::hello::HelloHandler>()
-                              .Append<components::DynamicConfigClient>()
-                              .Append<components::TestsuiteSupport>()
-                              .Append<server::handlers::TestsControl>()
-                              .Append<components::DynamicConfigClientUpdater>()
-                              .Append<components::HttpClient>()
-                              .Append<clients::dns::Component>()
-                              .Append<chaotic::openapi::QosMiddlewareFactory<clients::test::kQosConfig>>(
-                                  "chaotic-client-middleware-qos-test"
-                              )
-                              .Append<clients::test::Component>();
+    auto component_list =
+        USERVER_NAMESPACE::components::MinimalServerComponentList()
+            .Append<samples::hello::HelloHandler>()
+            .Append<USERVER_NAMESPACE::components::DynamicConfigClient>()
+            .Append<USERVER_NAMESPACE::components::TestsuiteSupport>()
+            .Append<USERVER_NAMESPACE::server::handlers::TestsControl>()
+            .Append<USERVER_NAMESPACE::components::DynamicConfigClientUpdater>()
+            .Append<USERVER_NAMESPACE::components::HttpClient>()
+            .Append<USERVER_NAMESPACE::clients::dns::Component>()
+            .Append<USERVER_NAMESPACE::chaotic::openapi::QosMiddlewareFactory<::clients::test::kQosConfig>>(
+                "chaotic-client-middleware-qos-test"
+            )
+            .Append<::clients::test::Component>();
 
-    chaotic::openapi::middlewares::AppendDefaultMiddlewares(component_list);
+    USERVER_NAMESPACE::chaotic::openapi::middlewares::AppendDefaultMiddlewares(component_list);
 
-    return utils::DaemonMain(argc, argv, component_list);
+    return USERVER_NAMESPACE::utils::DaemonMain(argc, argv, component_list);
 }
diff --git a/samples/grpc_middleware_service/src/middlewares/client/chaos.hpp b/samples/grpc_middleware_service/src/middlewares/client/chaos.hpp
index 7a5b4ccc61b2..16d39856b38a 100644
--- a/samples/grpc_middleware_service/src/middlewares/client/chaos.hpp
+++ b/samples/grpc_middleware_service/src/middlewares/client/chaos.hpp
@@ -8,7 +8,7 @@ namespace samples::grpc::auth::client {
 
 class ChaosMiddleware final : public ugrpc::client::MiddlewareBase {
 public:
-    explicit ChaosMiddleware(bool feature_enabled_);
+    explicit ChaosMiddleware(bool feature_enabled);
 
     void PreStartCall(ugrpc::client::MiddlewareCallContext& context) const override;
 
diff --git a/samples/grpc_service/src/greeter_client.cpp b/samples/grpc_service/src/greeter_client.cpp
index 95ea2ab2f242..904e9b80e16f 100644
--- a/samples/grpc_service/src/greeter_client.cpp
+++ b/samples/grpc_service/src/greeter_client.cpp
@@ -12,6 +12,17 @@
 
 namespace samples {
 
+const dynamic_config::Key<ugrpc::client::ClientQos> kGreeterClientQos{
+    "GREETER_CLIENT_QOS",
+    dynamic_config::DefaultAsJsonString{R"({
+      "methods": {
+        "__default__": {
+          "timeout-ms": 10000
+        }
+      }
+    })"},
+};
+
 // A user-defined wrapper around api::GreeterServiceClient that provides
 // a simplified interface.
 GreeterClient::GreeterClient(api::GreeterServiceClient&& raw_client) : raw_client_(std::move(raw_client)) {}
diff --git a/samples/grpc_service/src/greeter_client.hpp b/samples/grpc_service/src/greeter_client.hpp
index af5c0138d181..e582b75422aa 100644
--- a/samples/grpc_service/src/greeter_client.hpp
+++ b/samples/grpc_service/src/greeter_client.hpp
@@ -49,6 +49,8 @@ class GreeterClient final {
 using Client = GreeterClient;
 
 /// [component]
+extern const dynamic_config::Key<ugrpc::client::ClientQos> kGreeterClientQos;
+
 class GreeterClientComponent final : public ugrpc::client::SimpleClientComponent<Client> {
 public:
     static constexpr std::string_view kName = "greeter-client";
@@ -56,7 +58,7 @@ class GreeterClientComponent final : public ugrpc::client::SimpleClientComponent
     using Base = ugrpc::client::SimpleClientComponent<Client>;
 
     GreeterClientComponent(const ::components::ComponentConfig& config, const ::components::ComponentContext& context)
-        : Base(config, context) {}
+        : Base(config, context, kGreeterClientQos) {}
 
     using Base::GetClient;
 };
diff --git a/samples/json2yaml/src/json2yaml.cpp b/samples/json2yaml/src/json2yaml.cpp
index 534f20976bdc..0466223f5216 100644
--- a/samples/json2yaml/src/json2yaml.cpp
+++ b/samples/json2yaml/src/json2yaml.cpp
@@ -2,37 +2,15 @@
 
 #include <string>
 
+#include <userver/formats/common/conversion_stack.hpp>
+
 /// [json2yaml - convert cpp]
 USERVER_NAMESPACE_BEGIN
 
 namespace formats::parse {
 
 yaml::Value Convert(const json::Value& json, To<yaml::Value>) {
-    yaml::ValueBuilder yaml_vb;
-
-    if (json.IsBool()) {
-        yaml_vb = json.ConvertTo<bool>();
-    } else if (json.IsInt64()) {
-        yaml_vb = json.ConvertTo<int64_t>();
-    } else if (json.IsUInt64()) {
-        yaml_vb = json.ConvertTo<uint64_t>();
-    } else if (json.IsDouble()) {
-        yaml_vb = json.ConvertTo<double>();
-    } else if (json.IsString()) {
-        yaml_vb = json.ConvertTo<std::string>();
-    } else if (json.IsArray()) {
-        yaml_vb = {common::Type::kArray};
-        for (const auto& elem : json) {
-            yaml_vb.PushBack(elem.ConvertTo<yaml::Value>());
-        }
-    } else if (json.IsObject()) {
-        yaml_vb = {common::Type::kObject};
-        for (auto it = json.begin(); it != json.end(); ++it) {
-            yaml_vb[it.GetName()] = it->ConvertTo<yaml::Value>();
-        }
-    }
-
-    return yaml_vb.ExtractValue();
+    return formats::common::PerformMinimalFormatConversion<yaml::Value>(json);
 }
 
 }  // namespace formats::parse
diff --git a/samples/kafka_service/unittest/kafka_test.cpp b/samples/kafka_service/unittest/kafka_test.cpp
index 976a335e0f1d..61caeb4c6b77 100644
--- a/samples/kafka_service/unittest/kafka_test.cpp
+++ b/samples/kafka_service/unittest/kafka_test.cpp
@@ -48,7 +48,8 @@ UTEST_F(KafkaServiceTest, Consume) {
 
     auto consumer = MakeConsumer("kafka-consumer", /*topics=*/{kTestTopic1, kTestTopic2});
     auto user_callback = [](kafka::MessageBatchView messages) { kafka_sample::Consume(messages); };
-    const auto received_messages = ReceiveMessages(consumer, kTestMessages.size(), std::move(user_callback));
+    const auto received_messages =
+        ReceiveMessages(consumer, kTestMessages.size(), /* commit_after_receive */ true, std::move(user_callback));
     ASSERT_EQ(received_messages.size(), kTestMessages.size());
     EXPECT_THAT(received_messages, ::testing::UnorderedElementsAreArray(kTestMessages));
 }
diff --git a/samples/otlp_service/static_config.yaml b/samples/otlp_service/static_config.yaml
index 54165625a675..80dedc5c3a1c 100644
--- a/samples/otlp_service/static_config.yaml
+++ b/samples/otlp_service/static_config.yaml
@@ -25,6 +25,9 @@ components_manager:
 # /// [otlp logger]
         otlp-logger:
             endpoint: '0.0.0.0:4317'
+            # You can use separate endpoints for traces and logs
+            # logs-endpoint: '0.0.0.0:4317'
+            # traces-endpoint: '0.0.0.0:4318'
             client-factory-name: grpc-otlp-factory
             service-name: otlp-example
             log-level: debug
diff --git a/samples/postgres_service/CMakeLists.txt b/samples/postgres_service/CMakeLists.txt
index 1ea3b63ae58c..7a7de7c8efc9 100644
--- a/samples/postgres_service/CMakeLists.txt
+++ b/samples/postgres_service/CMakeLists.txt
@@ -15,6 +15,8 @@ userver_add_sql_library(
     ${PROJECT_NAME}_sql
     NAMESPACE
     samples_postgres_service
+    SOURCE_DIR
+    queries
     OUTPUT_DIR
     ${CMAKE_CURRENT_BINARY_DIR}
     SQL_FILES
diff --git a/samples/postgres_service/select_value.sql b/samples/postgres_service/queries/read/select_value.sql
similarity index 100%
rename from samples/postgres_service/select_value.sql
rename to samples/postgres_service/queries/read/select_value.sql
diff --git a/samples/postgres_service/delete_value.sql b/samples/postgres_service/queries/write/delete_value.sql
similarity index 100%
rename from samples/postgres_service/delete_value.sql
rename to samples/postgres_service/queries/write/delete_value.sql
diff --git a/samples/postgres_service/insert_value.sql b/samples/postgres_service/queries/write/insert_value.sql
similarity index 100%
rename from samples/postgres_service/insert_value.sql
rename to samples/postgres_service/queries/write/insert_value.sql
diff --git a/samples/ydb_service/views/upsert-2rows/post/view.cpp b/samples/ydb_service/views/upsert-2rows/post/view.cpp
index c03cdace92e2..f8af77b03207 100644
--- a/samples/ydb_service/views/upsert-2rows/post/view.cpp
+++ b/samples/ydb_service/views/upsert-2rows/post/view.cpp
@@ -8,9 +8,9 @@
 namespace sample {
 
 formats::json::Value Upsert2RowsHandler::
-    HandleRequestJsonThrow(const server::http::HttpRequest& httpRequest, const formats::json::Value& request, server::request::RequestContext&)
+    HandleRequestJsonThrow(const server::http::HttpRequest& http_request, const formats::json::Value& request, server::request::RequestContext&)
         const {
-    httpRequest.GetHttpResponse().SetContentType(http::content_type::kApplicationJson);
+    http_request.GetHttpResponse().SetContentType(http::content_type::kApplicationJson);
     static const ydb::Query kUpsertQuery{
         R"(
 --!syntax_v1
diff --git a/samples/ydb_service/views/upsert-row/post/view.cpp b/samples/ydb_service/views/upsert-row/post/view.cpp
index afde4bd40867..aed5d2cf9d75 100644
--- a/samples/ydb_service/views/upsert-row/post/view.cpp
+++ b/samples/ydb_service/views/upsert-row/post/view.cpp
@@ -6,9 +6,9 @@
 namespace sample {
 
 formats::json::Value UpsertRowHandler::
-    HandleRequestJsonThrow(const server::http::HttpRequest& httpRequest, const formats::json::Value& request, server::request::RequestContext&)
+    HandleRequestJsonThrow(const server::http::HttpRequest& http_request, const formats::json::Value& request, server::request::RequestContext&)
         const {
-    httpRequest.GetHttpResponse().SetContentType(http::content_type::kApplicationJson);
+    http_request.GetHttpResponse().SetContentType(http::content_type::kApplicationJson);
     static const ydb::Query kUpsertQuery{
         R"(
 --!syntax_v1
diff --git a/scripts/debian-rules b/scripts/debian-rules
new file mode 100755
index 000000000000..85d2e5d2123e
--- /dev/null
+++ b/scripts/debian-rules
@@ -0,0 +1,64 @@
+#!/usr/bin/make -f
+
+export DEB_BUILD_MAINT_OPTIONS = hardening=+all optimize=-lto
+
+BUILD_DIR_RELEASE = $(CURDIR)/debian/obj-$(DEB_HOST_GNU_TYPE)-release
+BUILD_DIR_DEBUG = $(CURDIR)/debian/obj-$(DEB_HOST_GNU_TYPE)-debug
+
+# YDB has no official .deb package, so skip it
+# TODO: pg patch
+# TODO: clickhouse
+CMAKE_OPTS = \
+	     -DUSERVER_INSTALL=ON \
+	     -DUSERVER_BUILD_SAMPLES=ON \
+	     -DUSERVER_BUILD_ALL_COMPONENTS=1 \
+	     -DUSERVER_FEATURE_YDB=OFF \
+	     -DUSERVER_FEATURE_CLICKHOUSE=OFF \
+	     -DUSERVER_FEATURE_PATCH_LIBPQ=OFF \
+	     -DUSERVER_FEATURE_UTEST=ON
+	     # -DUSERVER_BUILD_TESTS=ON \
+
+DEBUG_SANITIZERS = ub addr
+
+
+%:
+	dh $@ --buildsystem=cmake+ninja
+
+override_dh_ctest_configure:
+	dh_ctest_configure --builddirectory=$(BUILD_DIR_RELEASE) -- \
+		-DCMAKE_BUILD_TYPE=Release \
+		$(CMAKE_OPTS)
+	
+	dh_ctest_configure --builddirectory=$(BUILD_DIR_DEBUG) -- \
+		-DCMAKE_BUILD_TYPE=Debug \
+		-DUSERVER_SANITIZE=$(DEBUG_SANITIZERS) \
+		$(CMAKE_OPTS)
+
+override_dh_ctest_build:
+	dh_ctest_build --builddirectory=$(BUILD_DIR_RELEASE)
+	dh_ctest_build --builddirectory=$(BUILD_DIR_DEBUG)
+
+override_dh_ctest_test:
+	dh_ctest_test --builddirectory=$(BUILD_DIR_RELEASE)
+	dh_ctest_test --builddirectory=$(BUILD_DIR_DEBUG)
+
+override_dh_cpack_generate:
+	cpack -G External \
+		--config $(BUILD_DIR_RELEASE)/CPackConfig.cmake \
+		-D CPACK_PACKAGE_FILE_NAME=cpack-metadata \
+		-D CPACK_EXT_REQUESTED_VERSIONS=1.0 \
+		-D CPACK_INSTALL_CMAKE_PROJECTS="$(BUILD_DIR_DEBUG);userver;ALL;/;$(BUILD_DIR_RELEASE);userver;ALL;/" \
+		-B debian/.cpack
+	
+
+override_dh_cpack_install:
+	dh_cpack_install --builddirectory=$(BUILD_DIR_RELEASE)
+	dh_cpack_install --builddirectory=$(BUILD_DIR_DEBUG)
+
+override_dh_auto_install:
+	dh_auto_install --builddirectory=$(BUILD_DIR_RELEASE)
+	dh_auto_install --builddirectory=$(BUILD_DIR_DEBUG)
+
+override_dh_auto_clean:
+	dh_auto_clean --builddirectory=$(BUILD_DIR_RELEASE)
+	dh_auto_clean --builddirectory=$(BUILD_DIR_DEBUG)
diff --git a/scripts/docs/doxygen.conf b/scripts/docs/doxygen.conf
index 8029b9691825..371c488b6036 100644
--- a/scripts/docs/doxygen.conf
+++ b/scripts/docs/doxygen.conf
@@ -1529,6 +1529,7 @@ HTML_EXTRA_FILES       = scripts/docs/doxygen-awesome-css/doxygen-awesome-darkmo
                          scripts/docs/img/plane.svg \
                          scripts/docs/img/sample_static_service.png \
                          scripts/docs/img/slack_logo.svg \
+                         scripts/docs/img/slugkit.svg \
                          scripts/docs/img/Stiker-3.svg \
                          scripts/docs/img/Stiker-5.svg \
                          scripts/docs/img/telegram_logo.svg \
@@ -1548,6 +1549,7 @@ HTML_EXTRA_FILES       = scripts/docs/doxygen-awesome-css/doxygen-awesome-darkmo
                          scripts/docs/scripts/toc.js \
                          scripts/docs/scripts/searchHighlight.js \
                          scripts/docs/scripts/header.js \
+                         scripts/docs/scripts/versions.js \
                          scripts/docs/landing.css
 
 # The HTML_COLORSTYLE tag can be used to specify if the generated HTML output
diff --git a/scripts/docs/dynamic_config_yaml_to_md.py b/scripts/docs/dynamic_config_yaml_to_md.py
index 0c42e74da70e..9556ed244d3e 100755
--- a/scripts/docs/dynamic_config_yaml_to_md.py
+++ b/scripts/docs/dynamic_config_yaml_to_md.py
@@ -25,6 +25,9 @@ def format_md(name, content, content_raw):
 ```
 
 {example}
+
+
+For a full list of dynamic configs see @ref scripts/docs/en/dynamic_configs/dynamic_configs.md
 """
     # TODO: used by component XX
     return text
@@ -51,8 +54,30 @@ def handle_file(ifname, ofname):
 def main():
     args = parse_args()
     os.makedirs(args.o, exist_ok=True)
+    all_configs = list()
     for fname in args.yaml:
-        handle_file(fname, pathlib.Path(args.o) / (pathlib.Path(fname).stem + '.md'))
+        config_name = pathlib.Path(fname).stem
+        handle_file(fname, pathlib.Path(args.o) / (config_name + '.md'))
+        all_configs.append(config_name)
+
+        with open(pathlib.Path(args.o) / 'dynamic_configs.md', 'w') as ofile:
+            ofile.write(
+                """## Dynamic config schemas list
+
+Here you can find schemas of dynamic configs used by userver itself. For general
+information on dynamic configs, see @ref scripts/docs/en/userver/dynamic_config.md
+
+* @ref """
+                + '\n* @ref '.join(sorted(all_configs))
+                + """
+
+----------
+
+@htmlonly <div class="bottom-nav"> @endhtmlonly
+⇦ @ref scripts/docs/en/userver/dynamic_config.md | @ref scripts/docs/en/userver/log_level_running_service.md ⇨
+@htmlonly </div> @endhtmlonly
+"""
+            )
 
 
 if __name__ == '__main__':
diff --git a/scripts/docs/en/deps/alpine.md b/scripts/docs/en/deps/alpine.md
index 26cedad521f6..f7d3bfcdea3f 100644
--- a/scripts/docs/en/deps/alpine.md
+++ b/scripts/docs/en/deps/alpine.md
@@ -31,6 +31,7 @@ nghttp2-static
 openldap-dev
 openssl-dev
 openssl-libs-static
+patch
 postgresql16-dev
 protobuf-c-compiler
 protobuf-c-dev
diff --git a/scripts/docs/en/deps/arch.md b/scripts/docs/en/deps/arch.md
index 4eaf1ccdba2f..2eb3ff78bc2f 100644
--- a/scripts/docs/en/deps/arch.md
+++ b/scripts/docs/en/deps/arch.md
@@ -1,14 +1,13 @@
 benchmark
 boost
-boost-stacktrace-backtrace
 c-ares
 ccache
-clang-format-git
 cmake
 crypto++
 curl
 fmt
 gdb
+gflags
 git
 grpc
 gtest
@@ -16,9 +15,14 @@ hiredis
 jemalloc
 krb5
 libev
+libunwind
 libnghttp2
-makepkg|cctz
+librdkafka
 makepkg|libbacktrace-git
+makepkg|boost-stacktrace-backtrace
+makepkg|cctz
+makepkg|clang-format-static-bin
+mariadb-libs
 mongo-c-driver
 ninja
 openssl
@@ -33,6 +37,6 @@ python-voluptuous
 python-yaml
 re2
 rocksdb
-unixodbc-dev
+unixodbc
 yaml-cpp
 zlib
diff --git a/scripts/docs/en/deps/debian-11.md b/scripts/docs/en/deps/debian-11.md
index 84577803538c..c5e34b255369 100644
--- a/scripts/docs/en/deps/debian-11.md
+++ b/scripts/docs/en/deps/debian-11.md
@@ -3,29 +3,34 @@ clang-format
 cmake
 gdb
 git
+libabsl-dev
 libbenchmark-dev
+libboost1.74-dev
 libboost-filesystem1.74-dev
 libboost-iostreams1.74-dev
 libboost-locale1.74-dev
 libboost-program-options1.74-dev
 libboost-stacktrace1.74-dev
-libboost1.74-dev
 libbson-dev
+libbz2-dev
 libc-ares-dev
 libcctz-dev
 libcrypto++-dev
 libcurl4-openssl-dev
 libev-dev
 libfmt-dev
+libgflags-dev
+libgmock-dev
 libgmock-dev
-libgrpc++-dev
 libgrpc++1
+libgrpc++-dev
 libgrpc-dev
 libgtest-dev
 libhiredis-dev
 libjemalloc-dev
 libkrb5-dev
 libldap2-dev
+libmariadbd-dev
 libmongoc-dev
 libnghttp2-dev
 libpq-dev
@@ -35,10 +40,10 @@ librdkafka-dev
 libre2-dev
 librocksdb-dev
 libsasl2-dev
+libsqlite3-dev
 libssl-dev
 libyaml-cpp-dev
 netbase
-ninja
 postgresql-13
 postgresql-server-dev-13
 protobuf-compiler-grpc
diff --git a/scripts/docs/en/deps/debian-12.md b/scripts/docs/en/deps/debian-12.md
index 61b0400a873f..1a7689784eca 100644
--- a/scripts/docs/en/deps/debian-12.md
+++ b/scripts/docs/en/deps/debian-12.md
@@ -4,12 +4,12 @@ cmake
 gdb
 git
 libbenchmark-dev
+libboost1.81-dev
 libboost-filesystem1.81-dev
 libboost-iostreams1.81-dev
 libboost-locale1.81-dev
 libboost-program-options1.81-dev
 libboost-stacktrace1.81-dev
-libboost1.81-dev
 libbson-dev
 libc-ares-dev
 libcctz-dev
@@ -18,14 +18,17 @@ libcurl4-openssl-dev
 libev-dev
 libfmt-dev
 libgmock-dev
-libgrpc++-dev
+libgmock-dev
 libgrpc++1
+libgrpc++-dev
 libgrpc-dev
 libgtest-dev
 libhiredis-dev
 libjemalloc-dev
 libkrb5-dev
 libldap2-dev
+liblzma-dev
+libmariadbd-dev
 libmongoc-dev
 libnghttp2-dev
 libpq-dev
@@ -35,6 +38,7 @@ librdkafka-dev
 libre2-dev
 librocksdb-dev
 libsasl2-dev
+libsqlite3-dev
 libssl-dev
 libyaml-cpp-dev
 netbase
diff --git a/scripts/docs/en/deps/debian-13.md b/scripts/docs/en/deps/debian-13.md
new file mode 100644
index 000000000000..bbd8ea8b9266
--- /dev/null
+++ b/scripts/docs/en/deps/debian-13.md
@@ -0,0 +1,57 @@
+ccache
+clang-format
+cmake
+gdb
+git
+libbenchmark-dev
+libboost1.83-dev
+libboost-filesystem1.83-dev
+libboost-iostreams1.83-dev
+libboost-locale1.83-dev
+libboost-program-options1.83-dev
+libboost-stacktrace1.83-dev
+libbson-dev
+libc-ares-dev
+libcctz-dev
+libcrypto++-dev
+libcurl4-openssl-dev
+libev-dev
+libfmt-dev
+libgmock-dev
+libgmock-dev
+libgrpc++1
+libgrpc++-dev
+libgrpc-dev
+libgtest-dev
+libhiredis-dev
+libjemalloc-dev
+libkrb5-dev
+libldap2-dev
+liblzma-dev
+libmariadbd-dev
+libmongoc-dev
+libnghttp2-dev
+libpq-dev
+libprotoc-dev
+libpugixml-dev
+librdkafka-dev
+libre2-dev
+librocksdb-dev
+libsasl2-dev
+libsqlite3-dev
+libssl-dev
+libyaml-cpp-dev
+netbase
+ninja-build
+postgresql-17
+postgresql-server-dev-17
+protobuf-compiler-grpc
+python3-dev
+python3-jinja2
+python3-protobuf
+python3-venv
+python3-voluptuous
+python3-yaml
+redis-server
+unixodbc-dev
+zlib1g-dev
diff --git a/scripts/docs/en/deps/fedora-35.md b/scripts/docs/en/deps/fedora-35.md
deleted file mode 100644
index 96834b35ce00..000000000000
--- a/scripts/docs/en/deps/fedora-35.md
+++ /dev/null
@@ -1,36 +0,0 @@
-boost-devel
-c-ares-devel
-ccache
-cctz-devel
-clang-tools-extra
-cmake
-cryptopp-devel
-curl-devel
-fmt-devel
-g++
-gdb
-google-benchmark-devel
-grpc-devel
-grpc-plugins
-gtest-devel
-hiredis-devel
-jemalloc-devel
-libatomic
-libev-devel
-libpq-devel
-mongo-c-driver-devel
-nghttp2-devel
-ninja
-openldap-devel
-openssl-devel
-postgresql-server
-pugixml
-python3-devel
-python3-jinja2
-python3-protobuf
-python3-voluptuous
-re2
-redis
-unixODBC-devel
-yaml-cpp-devel
-zlib-devel
diff --git a/scripts/docs/en/deps/fedora-36.md b/scripts/docs/en/deps/fedora-42.md
similarity index 61%
rename from scripts/docs/en/deps/fedora-36.md
rename to scripts/docs/en/deps/fedora-42.md
index d5e66ffad2a6..dc50aeefd8b6 100644
--- a/scripts/docs/en/deps/fedora-36.md
+++ b/scripts/docs/en/deps/fedora-42.md
@@ -1,4 +1,5 @@
 boost-devel
+bzip2-devel
 c-ares-devel
 ccache
 cctz-devel
@@ -9,6 +10,7 @@ curl-devel
 fmt-devel
 g++
 gdb
+gflags-devel
 google-benchmark-devel
 grpc-devel
 grpc-plugins
@@ -17,22 +19,33 @@ hiredis-devel
 jemalloc-devel
 libasan
 libatomic
+libbson-devel
 libev-devel
-libpq-devel
+libnghttp2-devel
+librdkafka-devel
 libubsan
+lz4-devel
+mariadb-connector-c-devel
+mariadb-devel
 mongo-c-driver-devel
-nghttp2-devel
 ninja
 openldap-devel
 openssl-devel
-postgresql-server
+openssl-devel-engine
+postgresql-server-devel
+postgresql-static
+protobuf-c-compiler
 pugixml
+pugixml-devel
 python3-devel
 python3-jinja2
 python3-protobuf
 python3-voluptuous
 re2
 redis
+rocksdb-devel
+snappy-devel
+sqlite-devel
 unixODBC-devel
 yaml-cpp-devel
 zlib-devel
diff --git a/scripts/docs/en/deps/macos.md b/scripts/docs/en/deps/macos.md
index 39596fb07581..7b81973dddda 100644
--- a/scripts/docs/en/deps/macos.md
+++ b/scripts/docs/en/deps/macos.md
@@ -1,4 +1,4 @@
-boost@1.88
+boost@1.89
 c-ares
 ccache
 cctz
diff --git a/scripts/docs/en/deps/ubuntu-22.04/chaotic b/scripts/docs/en/deps/ubuntu-22.04/chaotic
new file mode 100644
index 000000000000..18379b43dcc1
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/chaotic
@@ -0,0 +1,2 @@
+python3-jinja2
+clang-format
diff --git a/scripts/docs/en/deps/ubuntu-22.04/core b/scripts/docs/en/deps/ubuntu-22.04/core
new file mode 100644
index 000000000000..4fc967d157d9
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/core
@@ -0,0 +1,14 @@
+libboost-context1.74-dev
+libboost-coroutine1.74-dev
+libboost-filesystem1.74-dev
+libboost-iostreams1.74-dev
+libboost-locale1.74-dev
+libboost-program-options1.74-dev
+libboost-stacktrace1.74-dev
+zlib1g-dev
+libssl-dev
+libnghttp2-dev
+libev-dev
+libc-ares-dev
+libcurl4-openssl-dev
+libcrypto++-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/grpc b/scripts/docs/en/deps/ubuntu-22.04/grpc
new file mode 100644
index 000000000000..e3f4e76fcef7
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/grpc
@@ -0,0 +1,5 @@
+libgrpc++-dev
+protobuf-compiler-grpc
+python3-protobuf
+libprotoc-dev
+libgrpc-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/kafka b/scripts/docs/en/deps/ubuntu-22.04/kafka
new file mode 100644
index 000000000000..530241d5616d
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/kafka
@@ -0,0 +1,6 @@
+librdkafka-dev
+libzstd-dev
+liblz4-dev
+libzstd-dev
+libsasl2-dev
+zlib1g-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/mongo b/scripts/docs/en/deps/ubuntu-22.04/mongo
new file mode 100644
index 000000000000..60873aa4e9b3
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/mongo
@@ -0,0 +1,2 @@
+libbson-dev
+libmongoc-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/mysql b/scripts/docs/en/deps/ubuntu-22.04/mysql
new file mode 100644
index 000000000000..7b086d5bebac
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/mysql
@@ -0,0 +1,3 @@
+libmariadb-dev
+zlib1g-dev
+libssl-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/odbc b/scripts/docs/en/deps/ubuntu-22.04/odbc
new file mode 100644
index 000000000000..ccaa85af13d0
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/odbc
@@ -0,0 +1 @@
+unixodbc-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/postgresql b/scripts/docs/en/deps/ubuntu-22.04/postgresql
new file mode 100644
index 000000000000..bebe11cf756a
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/postgresql
@@ -0,0 +1,4 @@
+libpq-dev
+libkrb5-dev
+libldap2-dev
+postgresql-server-dev-16
diff --git a/scripts/docs/en/deps/ubuntu-22.04/redis b/scripts/docs/en/deps/ubuntu-22.04/redis
new file mode 100644
index 000000000000..5628a59befd0
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/redis
@@ -0,0 +1 @@
+libhiredis-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/rocks b/scripts/docs/en/deps/ubuntu-22.04/rocks
new file mode 100644
index 000000000000..36602ea66df4
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/rocks
@@ -0,0 +1 @@
+librocksdb-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/sqlite b/scripts/docs/en/deps/ubuntu-22.04/sqlite
new file mode 100644
index 000000000000..feb92603e946
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/sqlite
@@ -0,0 +1 @@
+libsqlite3-dev
diff --git a/scripts/docs/en/deps/ubuntu-22.04/universal b/scripts/docs/en/deps/ubuntu-22.04/universal
new file mode 100644
index 000000000000..b978cca36ce9
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/universal
@@ -0,0 +1,35 @@
+build-essential
+ccache
+cmake
+cmake-format
+gdb
+git
+libabsl-dev
+libbenchmark-dev
+libbz2-dev
+libcctz-dev
+libdouble-conversion-dev
+libfmt-dev
+libgflags-dev
+libgmock-dev
+libgtest-dev
+libidn11-dev
+libjemalloc-dev
+libjemalloc2
+liblzma-dev
+libpugixml-dev
+libsnappy-dev
+libre2-dev
+libsnappy-dev
+libssh2-1-dev
+libxxhash-dev
+libyaml-cpp-dev
+libyaml-cpp0.7
+netbase
+ninja-build
+odbc-postgresql
+python3-dev
+python3-venv
+python3-voluptuous
+python3-yaml
+yasm
diff --git a/scripts/docs/en/deps/ubuntu-22.04/ydb b/scripts/docs/en/deps/ubuntu-22.04/ydb
new file mode 100644
index 000000000000..3739a2673815
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-22.04/ydb
@@ -0,0 +1 @@
+ragel
diff --git a/scripts/docs/en/deps/ubuntu-24.04/chaotic b/scripts/docs/en/deps/ubuntu-24.04/chaotic
new file mode 100644
index 000000000000..18379b43dcc1
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/chaotic
@@ -0,0 +1,2 @@
+python3-jinja2
+clang-format
diff --git a/scripts/docs/en/deps/ubuntu-24.04/core b/scripts/docs/en/deps/ubuntu-24.04/core
new file mode 100644
index 000000000000..aafacd33ac31
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/core
@@ -0,0 +1,14 @@
+libboost-context1.83-dev
+libboost-coroutine1.83-dev
+libboost-filesystem1.83-dev
+libboost-iostreams1.83-dev
+libboost-locale1.83-dev
+libboost-program-options1.83-dev
+libboost-stacktrace1.83-dev
+zlib1g-dev
+libssl-dev
+libnghttp2-dev
+libev-dev
+libc-ares-dev
+libcurl4-openssl-dev
+libcrypto++-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/grpc b/scripts/docs/en/deps/ubuntu-24.04/grpc
new file mode 100644
index 000000000000..e3f4e76fcef7
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/grpc
@@ -0,0 +1,5 @@
+libgrpc++-dev
+protobuf-compiler-grpc
+python3-protobuf
+libprotoc-dev
+libgrpc-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/kafka b/scripts/docs/en/deps/ubuntu-24.04/kafka
new file mode 100644
index 000000000000..530241d5616d
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/kafka
@@ -0,0 +1,6 @@
+librdkafka-dev
+libzstd-dev
+liblz4-dev
+libzstd-dev
+libsasl2-dev
+zlib1g-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/mongo b/scripts/docs/en/deps/ubuntu-24.04/mongo
new file mode 100644
index 000000000000..60873aa4e9b3
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/mongo
@@ -0,0 +1,2 @@
+libbson-dev
+libmongoc-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/mysql b/scripts/docs/en/deps/ubuntu-24.04/mysql
new file mode 100644
index 000000000000..7b086d5bebac
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/mysql
@@ -0,0 +1,3 @@
+libmariadb-dev
+zlib1g-dev
+libssl-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/odbc b/scripts/docs/en/deps/ubuntu-24.04/odbc
new file mode 100644
index 000000000000..ccaa85af13d0
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/odbc
@@ -0,0 +1 @@
+unixodbc-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/postgresql b/scripts/docs/en/deps/ubuntu-24.04/postgresql
new file mode 100644
index 000000000000..bebe11cf756a
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/postgresql
@@ -0,0 +1,4 @@
+libpq-dev
+libkrb5-dev
+libldap2-dev
+postgresql-server-dev-16
diff --git a/scripts/docs/en/deps/ubuntu-24.04/redis b/scripts/docs/en/deps/ubuntu-24.04/redis
new file mode 100644
index 000000000000..5628a59befd0
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/redis
@@ -0,0 +1 @@
+libhiredis-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/rocks b/scripts/docs/en/deps/ubuntu-24.04/rocks
new file mode 100644
index 000000000000..36602ea66df4
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/rocks
@@ -0,0 +1 @@
+librocksdb-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/sqlite b/scripts/docs/en/deps/ubuntu-24.04/sqlite
new file mode 100644
index 000000000000..feb92603e946
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/sqlite
@@ -0,0 +1 @@
+libsqlite3-dev
diff --git a/scripts/docs/en/deps/ubuntu-24.04/universal b/scripts/docs/en/deps/ubuntu-24.04/universal
new file mode 100644
index 000000000000..32848c9f93c3
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/universal
@@ -0,0 +1,34 @@
+build-essential
+ccache
+cmake
+cmake-format
+gdb
+git
+libabsl-dev
+libbenchmark-dev
+libbz2-dev
+libcctz-dev
+libdouble-conversion-dev
+libfmt-dev
+libgflags-dev
+libgmock-dev
+libgtest-dev
+libidn11-dev
+libjemalloc-dev
+libjemalloc2
+liblzma-dev
+libpugixml-dev
+libsnappy-dev
+libre2-dev
+libsnappy-dev
+libxxhash-dev
+libyaml-cpp-dev
+libyaml-cpp0.8
+netbase
+ninja-build
+odbc-postgresql
+python3-dev
+python3-venv
+python3-voluptuous
+python3-yaml
+yasm
diff --git a/scripts/docs/en/deps/ubuntu-24.04/ydb b/scripts/docs/en/deps/ubuntu-24.04/ydb
new file mode 100644
index 000000000000..3739a2673815
--- /dev/null
+++ b/scripts/docs/en/deps/ubuntu-24.04/ydb
@@ -0,0 +1 @@
+ragel
diff --git a/scripts/docs/en/index.md b/scripts/docs/en/index.md
index 7ea1c6e8f244..1ceeffde3611 100644
--- a/scripts/docs/en/index.md
+++ b/scripts/docs/en/index.md
@@ -17,10 +17,11 @@ Telegram support chats: [English-speaking](https://t.me/userver_en) |
 
 ## Source codes and service templates at github
 
-Ready-to-use services templates and the source codes of the framework itself
-are available at the
+Samples and the source codes of the framework itself are available at the
 [userver-framework at github](https://github.com/userver-framework/).
 
+Mirror is available at [the SourceCraft](https://sourcecraft.dev/userver/repos).
+
 
 ## Introduction
 
@@ -31,6 +32,7 @@ are available at the
 * @ref scripts/docs/en/userver/deploy_env.md
 * @ref scripts/docs/en/userver/development/releases.md
 * @ref scripts/docs/en/userver/roadmap_and_changelog.md
+* @ref scripts/docs/en/userver/distro_maintainers.md
 * @ref scripts/docs/en/userver/faq.md
 
 
@@ -100,6 +102,7 @@ and make sure that it builds and passes tests.
 
 ## Protocols
 * @ref scripts/docs/en/userver/grpc/grpc.md
+    * @ref scripts/docs/en/userver/grpc/timeouts_retries.md
     * Middlewares
         * @ref scripts/docs/en/userver/grpc/server_middlewares.md
             * @ref scripts/docs/en/userver/grpc/server_middleware_implementation.md
@@ -120,7 +123,7 @@ and make sure that it builds and passes tests.
 
 ## Runtime service features
 * @ref scripts/docs/en/userver/dynamic_config.md
-* @ref scripts/docs/en/schemas/dynamic_configs.md
+    * @ref scripts/docs/en/dynamic_configs/dynamic_configs.md
 * @ref scripts/docs/en/userver/log_level_running_service.md
 * @ref scripts/docs/en/userver/requests_in_flight.md
 * @ref scripts/docs/en/userver/service_monitor.md
diff --git a/scripts/docs/en/landing.md b/scripts/docs/en/landing.md
index ac5547cd4bff..0f0c84ef66cc 100644
--- a/scripts/docs/en/landing.md
+++ b/scripts/docs/en/landing.md
@@ -170,6 +170,7 @@ int main(int argc, char* argv[]) {
           <span class="logo logo_delivery" title="Delivery club"></span>
           <span class="logo logo_matchmaker" title="Matchmaker"></span>
           <span class="logo logo_yago" title="Yandex Go"></span>
+          <span class="logo logo_slugkit" title="SlugKit"></span>
         </div>
       </section>
       <section class="section feedback">
diff --git a/scripts/docs/en/schemas/dynamic_configs.md b/scripts/docs/en/schemas/dynamic_configs.md
deleted file mode 100644
index 501f5cb76b4b..000000000000
--- a/scripts/docs/en/schemas/dynamic_configs.md
+++ /dev/null
@@ -1,18 +0,0 @@
-@anchor REDIS_WAIT_CONNECTED
-## REDIS_WAIT_CONNECTED
-
-Dynamic config that controls if services will wait for connections with redis
-instances.
-
-@include redis/dynamic_configs/REDIS_WAIT_CONNECTED.yaml
-
-**Example:**
-```json
-{
-  "mode": "master_or_slave",
-  "throw_on_fail": false,
-  "timeout-ms": 11000
-}
-```
-
-Used by components::Redis.
diff --git a/scripts/docs/en/userver/build/dependencies.md b/scripts/docs/en/userver/build/dependencies.md
index 9d79719714fe..e67b2c8c9606 100644
--- a/scripts/docs/en/userver/build/dependencies.md
+++ b/scripts/docs/en/userver/build/dependencies.md
@@ -80,32 +80,14 @@ CMAKE_COMMON_FLAGS += \
     -DCMAKE_CXX_FLAGS='-D_FILE_OFFSET_BITS=64'
 ```
 
-### Fedora 35
+### Fedora 42
 
-\b Dependencies: @ref scripts/docs/en/deps/fedora-36.md "third_party/userver/scripts/docs/en/deps/fedora-35.md"
+\b Dependencies: @ref scripts/docs/en/deps/fedora-42.md "third_party/userver/scripts/docs/en/deps/fedora-42.md"
 
 Dependencies can be installed via:
 
 ```bash
-DEPS_FILE="https://raw.githubusercontent.com/userver-framework/userver/refs/heads/develop/scripts/docs/en/deps/fedora-35.md" && \
-sudo dnf install -y $(wget -q -O - ${DEPS_FILE})
-```
-
-Recommended CMake options:
-
-```
-USERVER_FEATURE_STACKTRACE=0
-USERVER_FEATURE_PATCH_LIBPQ=0
-```
-
-### Fedora 36
-
-\b Dependencies: @ref scripts/docs/en/deps/fedora-36.md "third_party/userver/scripts/docs/en/deps/fedora-36.md"
-
-Dependencies can be installed via:
-
-```bash
-DEPS_FILE="https://raw.githubusercontent.com/userver-framework/userver/refs/heads/develop/scripts/docs/en/deps/fedora-36.md" && \
+DEPS_FILE="https://raw.githubusercontent.com/userver-framework/userver/refs/heads/develop/scripts/docs/en/deps/fedora-42.md" && \
 sudo dnf install -y $(wget -q -O - ${DEPS_FILE})
 ```
 
diff --git a/scripts/docs/en/userver/build/options.md b/scripts/docs/en/userver/build/options.md
index 07f951fcb948..7e99481d4719 100644
--- a/scripts/docs/en/userver/build/options.md
+++ b/scripts/docs/en/userver/build/options.md
@@ -101,7 +101,7 @@ The exact format of setting cmake options varies depending on the method of buil
 | `USERVER_FEATURE_CRYPTOPP_BLAKE2`      | Provide wrappers for blake2 algorithms of crypto++                                                                | `ON`                                        |
 | `USERVER_FEATURE_PATCH_LIBPQ`          | Apply patches to the libpq (add portals support), requires `libpq.a`                                              | `ON`                                        |
 | `USERVER_FEATURE_CRYPTOPP_BASE64_URL`  | Provide wrappers for Base64 URL decoding and encoding algorithms of crypto++                                      | `ON`                                        |
-| `USERVER_FEATURE_REDIS_TLS`            | SSL/TLS support for Redis driver                                                                                  | `OFF`                                       |
+| `USERVER_FEATURE_REDIS_TLS`            | SSL/TLS support for Redis driver. Use with `"secure_connection": true` secdist option for @ref components::Redis  | `OFF`                                       |
 | `USERVER_FEATURE_STACKTRACE`           | Allow capturing stacktraces using `boost::stacktrace`                                                             | `ON` except for macOS, `*BSD` and old Boost |
 | `USERVER_FEATURE_JEMALLOC`             | Use jemalloc memory allocator                                                                                     | `ON`                                        |
 | `USERVER_FEATURE_DWCAS`                | Require double-width compare-and-swap                                                                             | `ON`                                        |
@@ -131,12 +131,16 @@ The exact format of setting cmake options varies depending on the method of buil
 | `USERVER_DOWNLOAD_PACKAGE_PROTOBUF`      | Download and setup Protobuf if no Protobuf of matching version was found                | `${USERVER_DOWNLOAD_PACKAGE_GRPC}`   |
 | `USERVER_DOWNLOAD_PACKAGE_KAFKA`         | Download and setup librdkafka if no librdkafka matching version was found               | `${USERVER_DOWNLOAD_PACKAGES}`       |
 | `USERVER_DOWNLOAD_PACKAGE_YDBCPPSDK`     | Download and setup ydb-cpp-sdk if no ydb-cpp-sdk of matching version was found          | `${USERVER_DOWNLOAD_PACKAGES}`       |
+| `USERVER_DOWNLOAD_PACKAGE_C_ARES`        | Download and setup libc-ares if no libc-ares of matching version was found              | `${USERVER_DOWNLOAD_PACKAGES}`       |
+| `USERVER_DOWNLOAD_PACKAGE_LIBEV`         | Download and setup libev if no libev of matching version was found                      | `${USERVER_DOWNLOAD_PACKAGES}`       |
+| `USERVER_DOWNLOAD_PACKAGE_LIBNGHTTP2`    | Download and setup libnghttp2 if no libnghttp2 of matching version was found            | `${USERVER_DOWNLOAD_PACKAGES}`       |
+| `USERVER_DOWNLOAD_PACKAGE_YAMLCPP`       | Download and setup libyaml-cpp if no libyaml-cpp of matching version was found          | `${USERVER_DOWNLOAD_PACKAGES}`       |
 | `USERVER_FORCE_DOWNLOAD_PACKAGES`        | Download all possible third-party packages even if there is an installed system package | `OFF`                                |
 | `USERVER_FORCE_DOWNLOAD_ABSEIL`          | Download Abseil even if it exists in a system                                           | `${USERVER_DOWNLOAD_PACKAGES}`       |
 | `USERVER_FORCE_DOWNLOAD_CURL`            | Download Curl even if it exists in a system                                             | `${USERVER_FORCE_DOWNLOAD_PACKAGES}` |
 | `USERVER_FORCE_DOWNLOAD_PROTOBUF`        | Download Protobuf even if there is an installed system package                          | `${USERVER_FORCE_DOWNLOAD_PACKAGES}` |
 | `USERVER_FORCE_DOWNLOAD_GRPC`            | Download gRPC even if there is an installed system package                              | `${USERVER_FORCE_DOWNLOAD_PACKAGES}` |
-| `USERVER_FORCE_DOWNLOAD_FMT`            | Download Fmt even if there is an installed system package                              | `${USERVER_FORCE_DOWNLOAD_PACKAGES}` |
+| `USERVER_FORCE_DOWNLOAD_FMT`             | Download Fmt even if there is an installed system package                               | `${USERVER_FORCE_DOWNLOAD_PACKAGES}` |
 
 ### CMake options for paths to dependencies
 
@@ -174,6 +178,7 @@ The exact format of setting cmake options varies depending on the method of buil
 | `USERVER_PIP_USE_SYSTEM_PACKAGES`       | Use system python packages inside venv. Useful for Docker, CI and other controlled environments             | `OFF`                                                       |
 | `USERVER_PIP_OPTIONS`                   | Options for all pip calls. Useful for passing `--no-index` option to prevent network usage                  | (no options)                                                |
 | `USERVER_INSTALL`                       | Build userver for further installation                                                                      | `OFF`                                                       |
+| `USERVER_INSTALL_MULTIPACKAGE`          | Whether create per-component packages                                                       | `OFF`                                                       |
 | `USERVER_CONAN`                         | Build userver using Conan packages                                                                          | `ON` if build is launched from Conan, `OFF` otherwise       |
 | `USERVER_CHAOTIC_FORMAT`                | Whether to format generated code if FORMAT option is missing                                                | `ON`                                                        |
 
diff --git a/scripts/docs/en/userver/congestion_control.md b/scripts/docs/en/userver/congestion_control.md
index dc95aeb2a4f7..b465499fa9aa 100644
--- a/scripts/docs/en/userver/congestion_control.md
+++ b/scripts/docs/en/userver/congestion_control.md
@@ -12,6 +12,8 @@ CC can run in `fake-mode` with no RPS limit (but FSM works). CC goes into `fake-
 * there are no reliable guarantees on CPU, in this case RPS-limit would be triggered too often,
 * service has no HTTP-handles others than server::handlers::Ping.
 
+`fake-mode` can be useful for more flexible traffic restriction settings, according to it's more complex logic, which can be implemented in a middleware.
+
 ## Usage
 
 congestion_control::Component can be useful if your service stops handling requests when overloaded, significantly increasing response time, responding with HTTP 500 codes to requests, eating memory.
diff --git a/scripts/docs/en/userver/distro_maintainers.md b/scripts/docs/en/userver/distro_maintainers.md
new file mode 100644
index 000000000000..be4787e63ecb
--- /dev/null
+++ b/scripts/docs/en/userver/distro_maintainers.md
@@ -0,0 +1,58 @@
+# Distro package maintainers
+
+## Maintainer's role
+
+We develop userver framework and take care of our users. We want userver to be available on as much platforms, OSes and
+distros as possible. It is quite difficult to maintain such complex product as userver working in any environment. It
+is a difficult engineer problem, but also it is often difficult or impossible to test userver on the target platform
+because of absent software/hardware.
+
+That's why there are userver distro package maintainers! That's the community role which is responsible for maintaining
+userver buildable and working in a specific environment.
+
+A maintainer should (where possible):
+* keep build dependencies list in `scripts/docs/en/deps/` for the distro up-to-date
+* watch for new distro version releases and create new dependency files in `scripts/docs/en/deps` soon after release
+* cleanup EOL (end of life) distro versions dependency files
+* maintain CI setup in `.github/workflows` in "green" state
+
+The maintainer is a community role which is not paid, but is a honorable one. You will get a "distro maintainer" label
+in official userver telegram channels.
+
+
+## Call for maintainers
+
+Currently we're looking for maintainers for the following OSes/distros:
+
+* MacOS
+* Fedora
+* Debian
+* ArchLinux
+* Gentoo
+* FreeBSD
+* Conan package
+
+The list is not complete, you may suggest your own distro to maintain.
+
+
+## Current maintainer list
+
+Active maintainers so far:
+- Ubuntu - userver team
+
+
+## Contacts
+
+If you feel you're ready to be a maintainer, please contact us by any of the following methods:
+- telegram https://t.me/userver_ru (in Russian)
+- telegram https://t.me/userver_en (in English)
+
+Then please make a pull request to [github](https://github.com/userver-framework/userver/) which changes this page and
+adds you to the "Current maintainer list" section.
+
+
+----------
+
+@htmlonly <div class="bottom-nav"> @endhtmlonly
+⇦ @ref scripts/docs/en/userver/roadmap_and_changelog.md | @ref scripts/docs/en/userver/faq.md ⇨
+@htmlonly </div> @endhtmlonly
diff --git a/scripts/docs/en/userver/dynamic_config.md b/scripts/docs/en/userver/dynamic_config.md
index 9955077afc14..580ed2c889bf 100644
--- a/scripts/docs/en/userver/dynamic_config.md
+++ b/scripts/docs/en/userver/dynamic_config.md
@@ -1,7 +1,7 @@
 ## Dynamic config
 
 For schemas of dynamic configs used by userver itself:
-@see @ref scripts/docs/en/schemas/dynamic_configs.md
+@see @ref scripts/docs/en/dynamic_configs/dynamic_configs.md
 
 For information on how to write a service that distributes dynamic configs:
 @see @ref scripts/docs/en/userver/tutorial/config_service.md
@@ -317,7 +317,7 @@ then you may skip this section entirely and use defaults only for testing.
 
 On the other hand, if you prefer to run without a configs service, then you
 may want to override some of the
-@ref scripts/docs/en/schemas/dynamic_configs.md "built-in userver configs".
+@ref scripts/docs/en/dynamic_configs/dynamic_configs.md "built-in userver configs".
 
 Defaults can be overridden in the config of the `dynamic-config` component:
 
@@ -678,5 +678,5 @@ going from the lowest to the highest priority:
 ----------
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
-⇦ @ref rabbitmq_driver | @ref scripts/docs/en/schemas/dynamic_configs.md ⇨
+⇦ @ref rabbitmq_driver | @ref scripts/docs/en/dynamic_configs/dynamic_configs.md ⇨
 @htmlonly </div> @endhtmlonly
diff --git a/scripts/docs/en/userver/faq.md b/scripts/docs/en/userver/faq.md
index 045719014ea8..34074d38b4e7 100644
--- a/scripts/docs/en/userver/faq.md
+++ b/scripts/docs/en/userver/faq.md
@@ -20,6 +20,19 @@ for a list of supported CMake options.
 If you have problems with PostgreSQL build, see @ref postgres_deps_versions "PostgreSQL versions".
 
 
+### SIGUSR1 terminates the service or SIGUSR1 ignored instead of rotating logs
+
+A third-party library is setting a custom signal mask for its own thread. This causes the SIGUSR1 signal to be
+delivered to that thread instead of the userver threads, which are supposed to handle log rotation.
+
+To locate the code that is interfering with signal handling, try the following approaches:
+* Search the source code of your dependencies for calls to POSIX and pthread functions that manage signals. For
+  instance, you can search using regular expressions like `.*sigmask.*` and `sig.*`.
+* Run your service under a debugger and set breakpoints on all relevant POSIX and pthread functions that manage signal
+  handling (e.g., `sigaction`, `rt_sigaction`, `signal`, `sigset`, `sighold`, `sigrelse`, `sigignore`, `sigprocmask`,
+  `pthread_sigmask`, `pthread_attr_setsigmask_np`, etc.).
+
+
 ### Service Terminated/Aborted/SIGSEGV. What to do?
 
 #### Hint: Take a look at the service logs
@@ -121,13 +134,13 @@ acquire connection + execute query <= network timeout
 ```
 
 See PostgreSQL related
-@ref scripts/docs/en/schemas/dynamic_configs.md for more info.
+@ref scripts/docs/en/dynamic_configs/dynamic_configs.md for more info.
 
 
 ### PostgreSQL: Statement XXXX was canceled
 
 Statement was canceled by the `statement timeout`. See PostgreSQL related
-@ref scripts/docs/en/schemas/dynamic_configs.md for more info.
+@ref scripts/docs/en/dynamic_configs/dynamic_configs.md for more info.
 
 
 ### PostgreSQL: Something is slow
@@ -206,5 +219,5 @@ storages::postgres::TimePointTz.
 ----------
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
-⇦ @ref scripts/docs/en/userver/roadmap_and_changelog.md | @ref scripts/docs/en/userver/build/build.md ⇨
+⇦ @ref scripts/docs/en/userver/distro_maintainers.md | @ref scripts/docs/en/userver/build/build.md ⇨
 @htmlonly </div> @endhtmlonly
diff --git a/scripts/docs/en/userver/framework_comparison.md b/scripts/docs/en/userver/framework_comparison.md
index 4f13ff939365..089719d675cf 100644
--- a/scripts/docs/en/userver/framework_comparison.md
+++ b/scripts/docs/en/userver/framework_comparison.md
@@ -19,7 +19,7 @@ use ❌ and ❓ respectively.
 | Programming model for IO-bound apps    | stackful coroutines                                         | stackful coroutines    | actors                                    | stackless coroutines           | callbacks / stackless coroutines | thread pool             |
 | Programming language to use            | С++                                                         | Go-lang                | Python, JS, .Net, PHP, Java, Go           | Rust                           | C++                              | C++                     |
 | Caching data from remote or DB         | ✔️ @ref scripts/docs/en/userver/caches.md "[↗]"             | ❌                      | ❌                                         | ❌                              | ❌                                | ✔️ [[↗]][poco-cache]    |
-| Dynamic Config @ref fcmp1 "[1]"        | ✔️ @ref scripts/docs/en/schemas/dynamic_configs.md "[↗]"    | ✔️ [[↗]][gom-features] | ❌                                         | ❌                              | ❌                                | ❌                       |
+| Dynamic Config @ref fcmp1 "[1]"        | ✔️ @ref scripts/docs/en/dynamic_configs/dynamic_configs.md "[↗]" | ✔️ [[↗]][gom-features] | ❌                                         | ❌                              | ❌                                | ❌                       |
 | Unit testing                           | ✔️ C++ @ref scripts/docs/en/userver/testing.md "[↗]"        | ✔️ via Go-lang         | ✔️ PHP [[↗]][dapr-testig]                 | ✔️                             | ✔️ [[↗]][drog-testig]            | ❓                       |
 | Functional Testing @ref fcmp2 "[2]"    | ✔️ @ref scripts/docs/en/userver/functional_testing.md "[↗]" | ❌                      | ❌ [[↗]][dapr-testig]                      | ❌ [[↗]][actix-test]            | ❌ [[↗]][drog-testig]             | ❓                       |
 | Async synchronization primitives       | ✔️ @ref scripts/docs/en/userver/synchronization.md "[↗]"    | ✔️ via Go-lang         | ❌ [forces turn based access][dapr-actors] | ✔️ [[↗]][tokio-sync]           | ❌                                | ✔️ [[↗]][poco-sync]     |
diff --git a/scripts/docs/en/userver/gdb_debugging.md b/scripts/docs/en/userver/gdb_debugging.md
index b23ee5e7763b..08bfae390e7c 100644
--- a/scripts/docs/en/userver/gdb_debugging.md
+++ b/scripts/docs/en/userver/gdb_debugging.md
@@ -124,7 +124,7 @@ In addition, all of the above functionality works for debugging both a live proc
 ## GDB complains: received signal ?, Unknown signal
 
 This is a side effect of stack usage monitor interfering with GDB. In unit tests you can set the environment variable
-`USERVER_GTEST_ENABLE_STACK_USAGE_MONITOR=0` to disable the monitor, in other binaries you can either disable it
+`USERVER_ENABLE_STACK_USAGE_MONITOR=0` to disable the monitor, in other binaries you can either disable it
 via static config option `coro_pool.stack_usage_monitor_enabled` in components::ManagerControllerComponent or by
 disabling it at all at build time of the framework via `USERVER_FEATURE_STACK_USAGE_MONITOR`
 (see @ref scripts/docs/en/userver/build/options.md).
diff --git a/scripts/docs/en/userver/grpc/grpc.md b/scripts/docs/en/userver/grpc/grpc.md
index b5c8b307ed50..3d1b6f1aed2d 100644
--- a/scripts/docs/en/userver/grpc/grpc.md
+++ b/scripts/docs/en/userver/grpc/grpc.md
@@ -19,7 +19,7 @@ See also:
 * Creating asynchronous gRPC clients and services;
 * Forwarding gRPC Core logs to userver logs;
 * Caching and reusing connections;
-* Timeouts;
+* @ref scripts/docs/en/userver/grpc/grpc_retries.md;
 * Collection of metrics on driver usage;
 * Cancellation support;
 * Automatic authentication using middlewares;
@@ -31,19 +31,32 @@ Generate and link a library from `.proto` schemas and link to it in your `CMakeL
 
 @snippet samples/grpc_service/CMakeLists.txt  add_grpc_library
 
-`userver_add_grpc_library` will link `userver-grpc` transitively and will generate the usual `.pb.h + .pb.cc` files. For service definitions, it will additionally generate asynchronous interfaces `foo_client.usrv.pb.hpp` and `foo_service.usrv.pb.hpp`.
+`userver_add_grpc_library` will link `userver::grpc` transitively and will generate the usual `.pb.h + .pb.cc` files.
+For service definitions, it will additionally generate asynchronous interfaces `foo_client.usrv.pb.hpp` and
+`foo_service.usrv.pb.hpp`.
 
-To create gRPC clients in your microservice, register the provided ugrpc::client::ClientFactoryComponent and add the corresponding component section to the static config.
+To create gRPC clients in your microservice, register the provided @ref ugrpc::client::ClientFactoryComponent and add
+the corresponding component section to the static config.
+
+To create gRPC services in your microservice, register the provided @ref ugrpc::server::ServerComponent and add the
+corresponding component section to the static config.
+
+See @ref scripts/docs/en/userver/tutorial/grpc_service.md for a tutorial.
 
-To create gRPC services in your microservice, register the provided ugrpc::server::ServerComponent and add the corresponding component section to the static config.
 
 ## gRPC clients
 
 ### Client creation
 
-In a component constructor, find ugrpc::client::ClientFactoryComponent and store a reference to its ugrpc::client::ClientFactory. Using it, you can create gRPC clients of code-generated `YourServiceClient` types.
+In a component constructor, find @ref ugrpc::client::ClientFactoryComponent and store a reference to its
+@ref ugrpc::client::ClientFactory. Using it, you can create gRPC clients of code-generated `YourServiceClient` types.
+
+Client creation in an expensive operation! Either create them once at the server boot time or cache them. An automated
+solution for client creation and caching is the @ref ugrpc::client::SimpleClientComponent. It also allows to
+specify dynamic config for @ref ugrpc::client::ClientQos:
+
+@snippet samples/grpc_service/src/greeter_client.hpp  component
 
-Client creation in an expensive operation! Either create them once at the server boot time or cache them.
 
 ### Client usage
 
@@ -53,15 +66,65 @@ Typical steps include:
     * Fill the authentication metadata as necessary
 * Stream creation by calling a client method
 * Operations on the stream
-* Depending on the RPC kind, it is necessary to call `Finish` or `Read` until it returns `false` (otherwise the connection will close abruptly)
+* Depending on the RPC kind, it is necessary to call `Finish` or `Read` until it returns `false`
+  (otherwise the connection will close abruptly)
 
 Read the documentation on gRPC streams:
-* Single request, single response ugrpc::client::UnaryCall
-* Single request, response stream ugrpc::client::InputStream
-* Request stream, single response ugrpc::client::OutputStream
-* Request stream, response stream ugrpc::client::BidirectionalStream
+* Single request, single response @ref ugrpc::client::ResponseFuture
+* Single request, response stream @ref ugrpc::client::Reader
+* Request stream, single response @ref ugrpc::client::Writer
+* Request stream, response stream @ref ugrpc::client::ReaderWriter
+
+On errors, exceptions from @ref userver/ugrpc/client/exceptions.hpp are thrown. It is recommended to catch them outside
+the entire stream interaction. You can catch exceptions for
+[specific gRPC error codes](https://grpc.github.io/grpc/core/md_doc_statuscodes.html) or all at once.
+
+### Working with metadata
+
+gRPC metadata allows you to send additional information along with requests and responses. Metadata consists of
+key-value pairs that are transmitted as HTTP/2 headers.
+
+#### Client-side metadata handling
+
+##### Sending request metadata
+
+To send metadata with a request, use @ref ugrpc::client::CallOptions and its
+@ref ugrpc::client::CallOptions::AddMetadata method:
+
+@snippet grpc/tests/metadata_test.cpp client_write_metadata
+
+##### Receiving response metadata
+
+Response metadata can be accessed through the @ref ugrpc::client::CallContext obtained from
+@ref ugrpc::client::ResponseFuture or stream objects:
+
+* **Reading initial metadata** - metadata sent by the server at the beginning of the response
 
-On errors, exceptions from userver/ugrpc/client/exceptions.hpp are thrown. It is recommended to catch them outside the entire stream interaction. You can catch exceptions for [specific gRPC error codes](https://grpc.github.io/grpc/core/md_doc_statuscodes.html) or all at once.
+@snippet grpc/tests/metadata_test.cpp client_read_initial_metadata
+
+* **Reading trailing metadata** - metadata sent by the server at the end of the response
+
+@snippet grpc/tests/metadata_test.cpp client_read_trailing_metadata
+
+#### Server-side metadata handling
+
+##### Reading client metadata
+
+The server can read metadata sent by the client:
+
+@snippet grpc/tests/metadata_test.cpp server_read_client_metadata
+
+##### Sending response metadata
+
+The server can send two types of metadata back to the client:
+
+* **Initial metadata** - sent at the beginning of the response
+
+@snippet grpc/tests/metadata_test.cpp server_write_initial_metadata
+
+* **Trailing metadata** - sent at the end of the response
+
+@snippet grpc/tests/metadata_test.cpp server_write_trailing_metadata
 
 @anchor grpc_ssl_authentication
 ### TLS / SSL
@@ -105,23 +168,26 @@ Use @ref ugrpc::client::MiddlewareBase to implement new middlewares.
 
 #### List of standard client middlewares:
 
-  1. `grpc-client-logging` with component ugrpc::client::middlewares::log::Component - logs requests and responses.
-  2. `grpc-client-deadline-propagation` with component ugrpc::client::middlewares::deadline_propagation::Component - activates
-  @ref scripts/docs/en/userver/deadline_propagation.md.
-  3. `grpc-client-baggage` with component ugrpc::client::middlewares::baggage::Component - passes request baggage to subrequests.
-  3. `grpc-client-headers-propagator` with component ugrpc::client::middlewares::headers_propagator::Component - propagates headers.
-  4. `grpc-client-middleware-testsuite` with component ugrpc::client::middlewares::testsuite::Component - supports testsuite errors thrown from the mockserver.
+1. `grpc-client-logging` with component ugrpc::client::middlewares::log::Component - logs requests and responses.
+2. `grpc-client-deadline-propagation` with component ugrpc::client::middlewares::deadline_propagation::Component - activates
+   @ref scripts/docs/en/userver/deadline_propagation.md.
+3. `grpc-client-baggage` with component ugrpc::client::middlewares::baggage::Component - passes request baggage to subrequests.
+4. `grpc-client-headers-propagator` with component ugrpc::client::middlewares::headers_propagator::Component - propagates headers.
+5. `grpc-client-middleware-testsuite` with component ugrpc::client::middlewares::testsuite::Component - supports testsuite errors thrown from the mockserver.
+
 
 ## gRPC services
 
 ### Service creation
 
-A service implementation is a class derived from a code-generated `YourServiceBase` interface class. Each service method from the schema corresponds to a method of the interface class. If you don't override some of the methods, `UNIMPLEMENTED` error code will be reported for those.
+A service implementation is a class derived from a code-generated `YourServiceBase` interface class. Each service
+method from the schema corresponds to a method of the interface class. If you don't override some of the methods,
+`UNIMPLEMENTED` error code will be reported for those.
 
 To register your service:
-* Create a component that derives from ugrpc::server::ServiceComponentBase
+* Create a component that derives from @ref ugrpc::server::ServiceComponentBase
 * Store your service implementation instance inside the component
-* Call ugrpc::server::ServiceComponentBase::RegisterService in the component's constructor
+* Call @ref ugrpc::server::ServiceComponentBase::RegisterService in the component's constructor
 * Don't forget to register your service component.
 
 ### Service method handling
@@ -134,12 +200,14 @@ Each method receives:
 When using a server stream, always call `Finish` or `FinishWithError`. Otherwise the client will receive `UNKNOWN` error, which signifies an internal server error.
 
 Read the documentation on gRPC streams:
-* Single request, single response ugrpc::server::UnaryCall
-* Request stream, single response ugrpc::server::InputStream
-* Single request, response stream ugrpc::server::OutputStream
-* Request stream, response stream ugrpc::server::BidirectionalStream
+* Single request, single response @ref ugrpc::server::Response
+* Request stream, single response @ref ugrpc::server::Reader + @ref ugrpc::server::Result
+* Single request, response stream @ref ugrpc::server::Writer + @ref ugrpc::server::StreamingResult
+* Request stream, response stream @ref ugrpc::server::ReaderWriter + @ref ugrpc::server::StreamingResult
 
-On connection errors, exceptions from userver/ugrpc/server/exceptions.hpp are thrown. It is recommended not to catch them, leading to RPC interruption. You can catch exceptions for [specific gRPC error codes](https://grpc.github.io/grpc/core/md_doc_statuscodes.html) or all at once.
+On connection errors, exceptions from userver/ugrpc/server/exceptions.hpp are thrown. It is recommended not to catch
+them, leading to RPC interruption. You can catch exceptions for
+[specific gRPC error codes](https://grpc.github.io/grpc/core/md_doc_statuscodes.html) or all at once.
 
 ### TLS / SSL
 
@@ -398,7 +466,7 @@ These are the metrics provided for each gRPC method:
 ----------
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
-⇦ @ref scripts/docs/en/userver/gdb_debugging.md | @ref scripts/docs/en/userver/grpc/server_middlewares.md ⇨
+⇦ @ref scripts/docs/en/userver/gdb_debugging.md | @ref scripts/docs/en/userver/grpc/timeouts_retries.md ⇨
 @htmlonly </div> @endhtmlonly
 
 @example grpc-generic-proxy/src/proxy_service.hpp
diff --git a/scripts/docs/en/userver/grpc/server_middlewares.md b/scripts/docs/en/userver/grpc/server_middlewares.md
index 87fc2f7780c9..ea1acf267369 100644
--- a/scripts/docs/en/userver/grpc/server_middlewares.md
+++ b/scripts/docs/en/userver/grpc/server_middlewares.md
@@ -77,5 +77,5 @@ How to implement your own middleware with a static config: @ref scripts/docs/en/
 
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
-⇦ @ref scripts/docs/en/userver/grpc/grpc.md | @ref scripts/docs/en/userver/grpc/server_middleware_implementation.md ⇨
+⇦ @ref scripts/docs/en/userver/grpc/timeouts_retries.md | @ref scripts/docs/en/userver/grpc/server_middleware_implementation.md ⇨
 @htmlonly </div> @endhtmlonly
diff --git a/scripts/docs/en/userver/grpc/timeouts_retries.md b/scripts/docs/en/userver/grpc/timeouts_retries.md
new file mode 100644
index 000000000000..a9ee48c8bc98
--- /dev/null
+++ b/scripts/docs/en/userver/grpc/timeouts_retries.md
@@ -0,0 +1,151 @@
+# gRPC Timeouts and Retries
+
+## QOS Config
+
+A QOS @ref scripts/docs/en/userver/dynamic_config.md "dynamic config" is a map from a full method name
+(`namespace.of.Service/Method`) to the settings for that method. It has the
+type @ref ugrpc::client::ClientQos and usually provided to the @ref ugrpc::client::SimpleClientComponent constructor.
+
+There is also a `__default__`, which is the default for all the missing methods and usually used for most
+"lightweight" methods of the service.
+
+`__default__` is NOT recursively merged with per-method settings: if a key for a specific method exists, `__default__`
+is ignored for it.
+
+Carefully check that you have entered the full method name correctly. There is currently no protection against typos
+in this area; an invalid method is silently ignored.
+
+
+## Timeouts
+
+If the `timeout-ms` field is not specified for the current request, the timeout is considered infinite.
+
+In a request, in addition to `timeout-ms`, the
+@ref scripts/docs/en/userver/deadline_propagation.md "deadline of the current handler" is also considered; the minimum
+of the two is used.
+
+### Behavior for Streaming RPC
+
+Timeouts apply to the entire RPC, from the moment the RPC is created until it is closed. To prevent the stream from
+being randomly terminated, override the QOS for streaming RPCs to an infinite timeout (by omitting the `timeout-ms`
+field).
+
+There is no option to configure a timeout for each individual message in a stream
+(from sending a request to receiving the corresponding response). Instead, it is common practice in gRPC to use
+keepalive pings to ensure that the server is still alive:
+
+* [About keepalive](https://grpc.io/docs/guides/keepalive/)
+* [channel-args keys for keepalive](https://grpc.github.io/grpc/core/group__grpc__arg__keys.html#gabeeccb441a671122c75384e062b1b91b)
+* In userver, they can be set in the `channel-args` static config option of @ref ugrpc::client::ClientFactoryComponent.
+
+## Retries
+
+For unary RPCs, clients automatically retry calls that fail with an error.
+
+Conditions for a retry to occur:
+1. The error code is one of the retryable status codes:
+   @snippet grpc/src/ugrpc/client/impl/retry_policy.cpp  retryable
+2. The number of previous attempts is less than `MaxAttempts`;
+3. The overall Deadline (including from @ref scripts/docs/en/userver/deadline_propagation.md) has not been exceeded.
+
+### Configuring Retries
+
+For non-codegenerated clients, retries are disabled by default. They can be enabled in any of the ways listed below.
+
+The maximum number of attempts can be configured as follows, in order of increasing priority:
+* Via static config:
+  @snippet grpc/functional_tests/middleware_client/static_config.yaml grpc client factory
+* Via dynamic gRPC QOS config @ref ugrpc::client::ClientQos;
+* Via an option in the code:
+  @snippet grpc/tests/retry_test.cpp  SetAttempts
+
+Retries can be disabled by specifying 1 attempt.
+
+### Retry Observability
+
+The following tags are set in the call span:
+
+* `max_attempts=<MaxAttempts>` (the limit on the number of attempts)
+* `attempts=<attempts performed>` (the number of attempts actually made)
+
+The following tags are also added to all client logs:
+
+* `max_attempts=<MaxAttempts>` (the limit on the number of attempts)
+* `attempts=<current attempt>` (the number of the current attempt, starting from 1)
+
+
+Middlewares are run for each attempt, and logs are written, including a log with an error status, if any.
+
+The client span is shared across all attempts. With retries, a single client span in the tracing system will have
+multiple child spans from the downstream service's handler.
+
+### grpc-core Retries {#retries-transparent}
+
+By default, ugrpc leaves the default retry behavior of grpc-core as is, without any additional configuration.
+This means that only low-level HTTP/2 errors will be retried (such retries are called Transparent retries).
+
+You can set your own settings for grpc-core retries via the static config:
+
+@snippet grpc/functional_tests/lowlevel/static_config.yaml  retry configuration
+
+You can read more about *grpc-core* retry settings in the official documentation (https://grpc.io/docs/guides/retry/).
+
+### Comparison of userver-grpc and grpc-core retry capabilities
+
+| Feature                       | userver-grpc retries                                  | grpc-core retries                                                    |
+| ----------------------------- | ----------------------------------------------------- | -------------------------------------------------------------------- |
+| *QOS*                         | +                                                     | -                                                                    |
+| *static config*               | `retry-config.attempts`                               | default-service-config (grpc-core format)                            |
+| *middlewares*                 | hooks are called on every retry attempt               | hooks are called once for the entire RPC                             |
+| *observability*               | each attempt is written separately to logs and metrics, span tags are available | no information about intermediate attempts |
+| *retriable status codes*      | hardcoded list                                        | can be configured via static config                                  |
+| *gRPC call becomes committed* | retries are performed regardless of response metadata | No further retries will be attempted                                 |
+
+
+### When grpc-core retries break
+
+Conditions for a retry to occur:
+
+1. grpc-core retries are manually configured in the config. ugrpc automatically configures them for streaming RPCs.
+2. The number of attempts is less than the limit.
+3. The returned status code is in the configured list of retryable codes. Some HTTP/2 level errors are also retried,
+  specifically, `RST_STREAM(REFUSED_STREAM)`, but not `RST_STREAM(INTERNAL)`.
+4. The downstream service did not return initial metadata.
+
+See [When Retries are Valid](https://github.com/grpc/proposal/blob/master/A6-client-retries.md#when-retries-are-valid)
+for more info.
+
+@warning Do not use initial metadata (headers) unless absolutely necessary. It breaks grpc-core retries. This
+         limitation does not apply to trailing metadata (trailers).
+
+It was also discovered experimentally that a Python grpc-io server causes retries to be aborted if the status is
+returned as follows:
+
+@code{.py}
+context.set_code(grpc.StatusCode.UNAVAILABLE)
+context.set_message('Foo')
+return my_package_pb2.MyMethodResponse()
+@endcode
+
+To prevent this issue, you should do this instead:
+
+@code{.py}
+await context.abort(grpc.StatusCode.UNAVAILABLE, 'Foo')
+@endcode
+
+
+### Why we decided to move away from grpc-core retries for unary calls and create our own ugrpc retries
+
+1. Limitations on metadata, see above.
+2. The default timeout field in the client's gRPC service config does not allow retrying timeouts. For retrying
+   timeouts, there is an experimental `perAttemptTimeoutMs` field. But after we started using this option,
+   [it turned out](https://github.com/grpc/grpc/issues/39935) that grpc-core sometimes encounters a race condition
+   and hangs indefinitely.
+
+
+----------
+
+@htmlonly <div class="bottom-nav"> @endhtmlonly
+⇦ @ref scripts/docs/en/userver/grpc/grpc.md | @ref scripts/docs/en/userver/grpc/server_middlewares.md ⇨
+@htmlonly </div> @endhtmlonly
+
diff --git a/scripts/docs/en/userver/log_level_running_service.md b/scripts/docs/en/userver/log_level_running_service.md
index 7943ee93a970..adffbb52d471 100644
--- a/scripts/docs/en/userver/log_level_running_service.md
+++ b/scripts/docs/en/userver/log_level_running_service.md
@@ -255,6 +255,6 @@ This configuration disables:
 ----------
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
-⇦ @ref scripts/docs/en/schemas/dynamic_configs.md | @ref scripts/docs/en/userver/requests_in_flight.md ⇨
+⇦ @ref scripts/docs/en/dynamic_configs/dynamic_configs.md | @ref scripts/docs/en/userver/requests_in_flight.md ⇨
 @htmlonly </div> @endhtmlonly
 
diff --git a/scripts/docs/en/userver/pg_user_types.md b/scripts/docs/en/userver/pg_user_types.md
index 8e63255259f7..830216a1ed8d 100644
--- a/scripts/docs/en/userver/pg_user_types.md
+++ b/scripts/docs/en/userver/pg_user_types.md
@@ -113,6 +113,18 @@ enumeration can have a long qualified name.
 @note Enums @ref scripts/docs/en/userver/chaotic.md "generated by codegen" can be easily mapped
       via storages::postgres::io::Codegen.
 
+## Mapping C++ enums to PostgreSQL text
+
+A C++ enumeration can be mapped to PostgreSQL text type by providing a
+`ToString()` and `Parse()` functions for the enumeration values and declaring specialization of
+storages::postgres::io::CppToSystemPg template.
+
+Example:
+
+@snippet storages/postgres/tests/enums_pgtest.cpp Autogenerated user enum type
+
+@note Enums @ref scripts/docs/en/userver/chaotic.md "generated by codegen" can be easily mapped to postgres text type by only providing the CppToSystemPg specialization, as they already have ToString() and Parse() functions.
+
 
 @anchor pg_range_types
 ## User Range types
diff --git a/scripts/docs/en/userver/publications.md b/scripts/docs/en/userver/publications.md
index 02bc6134c22c..4a9a603306dc 100644
--- a/scripts/docs/en/userver/publications.md
+++ b/scripts/docs/en/userver/publications.md
@@ -39,10 +39,15 @@
 ## Technologies overview
 * 📖 Generic async engine implementation (ru): [Анатомия асинхронных фреймворков в С++ и других языках](https://habr.com/ru/company/yandex/blog/647853/)
 * 🎥 Generic async engine implementation (ru): [Анатомия асинхронных движков](https://youtu.be/MiE22pTvnPs)
-* 🎥 Mutex implementation in userver (ru): [Реализация мьютекса в userver](https://www.youtube.com/watch?v=myaEpjYyx3I)
-* 🎥 Description of utils::FastPimpl, formats::parse::To and logging implementation (ru): [C++ трюки из Такси](https://youtu.be/_AkF8SpUV3k)
-* 🎥 Description of utils::LazyPrvalue, utils::FixedArray, utils::TrivialBiMap, ODR-detection in PostgreSQL [C++ трюки из userver](https://www.youtube.com/watch?v=FcQC19CX-AY)
+* 🎥 Mutex implementation in userver (ru): [Реализация мьютекса в userver](https://www.youtube.com/watch?v=myaEpjYyx3I),
+  [VK mirror](https://vkvideo.ru/video-17796776_456240865)
+* 🎥 Description of utils::FastPimpl, formats::parse::To and logging implementation (ru): [C++ трюки из Такси](https://youtu.be/_AkF8SpUV3k),
+  [VK mirror](https://vkvideo.ru/video-77278886_456239394)
+* 🎥 Description of utils::LazyPrvalue, utils::FixedArray, utils::TrivialBiMap, ODR-detection in PostgreSQL [C++ трюки из userver](https://www.youtube.com/watch?v=FcQC19CX-AY),
+  [VK mirror](https://vkvideo.ru/video-77278886_456239838)
 * 🎥 Description of cache::LruSet implementation and optimizations (ru): [Ещё чуть быстрее делаем свой контейнер](https://youtu.be/60XhYzkXu1M)
+* 🎥 Description of Exception hacks and third-party tweaks [Грязные C++ трюки из userver и Boost](https://youtu.be/-pE3T6wsIrM),
+  [VK mirror](https://vkvideo.ru/video-77278886_456239891)
 * 🎥 Monolithic vs. Microservices architecture and how userver works around their issues (ru):
   [Монолит vs Микросервисы, и Как эффективно работать с последними в C++](https://youtu.be/5QtAFKgS938)
 * 📖 Retries, exponential backoff, jitter, rate limits, circuit breakers, deadline propagations and other
@@ -52,8 +57,12 @@
 * 📖 [Story of website design at Behance](https://www.behance.net/gallery/185906583/Userver-C)
 
 
-## Fun
+## Fun and Management
 * 📖 Half a year in open-source (ru): [userver — что мы узнали за полгода в open-source](https://habr.com/ru/companies/yandex/articles/729588/)
+* 🎥 666 PRs later [666 PR спустя: как мы делаем userver](https://youtu.be/ufILdqDUUcY),
+  [VK mirror](https://vkvideo.ru/video-17796776_456241259)
+* 🎥 Opensource for companies and developers in Boost, C++ and userver [Опенсорс для компаний и разработчиков на примере Boost, C++, userver](https://youtu.be/htxvkdho70Y),
+  [VK mirror](https://vkvideo.ru/video-152308462_456242774)
 
 ----------
 
diff --git a/scripts/docs/en/userver/roadmap_and_changelog.md b/scripts/docs/en/userver/roadmap_and_changelog.md
index 8439fda050b7..14dd851d51e9 100644
--- a/scripts/docs/en/userver/roadmap_and_changelog.md
+++ b/scripts/docs/en/userver/roadmap_and_changelog.md
@@ -35,6 +35,86 @@ Changelog news also go to the
 
 ## Changelog
 
+### Release v2.12
+
+* Added infrastructure to detect IO-bound operations in transactions. See `enable_trx_tracker` static config option into
+  @ref components::ManagerControllerComponent and @ref userver/utils/trx_tracker.hpp. The detection is turned on by
+  default and is used in HTTP clients and gRPC for PostgreSQL transactions.
+* Added support for separate logs and traces endpoints into OpenTelemetry. See `logs-endpoint` and `tracing-endpoint`
+  static config options of the @ref otlp::LoggerComponent.
+* Implemented non blocking receive for engine::io::TlsWrapper. Many thanks to
+  [Denis Razinkin](https://github.com/DenisRazinkin) for the PR!
+* Added @ref server::websocket::WebSocketConnection now has `SendPing()` and `NotAnsweredSequentialPingsCount()`
+  functions for initiating pings on server side.
+* Created [userver mirror repo at SourceCraft](https://sourcecraft.dev/userver/repos).
+
+* Kafka now supports SSL authentication. Many thanks to [Timur Yalymov](https://github.com/tyalymov) for the PR!
+* Fixed UB in WebSockets. Many thanks to [Denis Razinkin](https://github.com/DenisRazinkin) for the PR!
+* Chaotic now handles `x-usrv-cpp-container: std::unordered_set` with `format: uuid`;
+  `x-usrv-cpp-type: userver::utils::StrongTypedef<my::CustomString, std::string>`; `std::intXX_t`
+* Crypto part of the `userver::universal` now supports work with multiple `std::string_views`. Thanks to
+  [Dmitry Sorokin](https://github.com/sorydima) for vibe-coding the initial version of PR.
+* Google Benchmark ASLR-disabling feature enabled if supported. Many thanks to
+  [Konstantin Goncharik](https://github.com/botanegg) for the PR!
+* Simplified third-party types usage in chaotic. `userver_target_generate_chaotic` CMake function now has
+  a `LINK_TARGETS` parameter to provide targets with paths to chaotic serializers. For example with
+  `LINK_TARGETS userver::postgresql` chaotic would find the
+  userver/postgresql/include/userver/chaotic/io/userver/storages/postgres/time_point_tz.hpp header with
+  @ref storages::postgres::TimePointTz converters.
+
+* gRPC and Protobuf
+  * Implemented retries. See @ref scripts/docs/en/userver/grpc/timeouts_retries.md for more info.
+  * @ref ugrpc::client::ClientFactoryComponent now can be customized via `ssl-credentials-options`. Many thanks to
+    [aklyuchev86](https://github.com/aklyuchev86) for the PR!
+  * @ref decimal64::Decimal::FromStringPermissive() now understands format with exponent, which makes it compatible
+    with Protobuf well-known Decimal types.
+
+* Database drivers
+  * Implemented @ref storages::redis::Client::GenericCommand() for execution of custom commands.
+  * Redis now supports `sentinel_password` @ref storages::secdist::Secdist option for authorization on sentinels with
+    password along with `password` authorization on shards. Many thanks to [Tikhon Sergienko](https://github.com/tysion)
+    for the PR!
+  * Implemented @ref storages::mongo::Collection::Distinct() command.
+  * Implemented @ref storages::clickhouse::ParameterStore. Many thanks to [Alexey Medvedev](https://github.com/Reavolt)
+    for the PR!
+  * `update-period` for @ref components::Secdist is now set to `10s`. As a result all the databases now automatically
+    recreate connections on connection data change in SecDist.
+  * Implemented parsing of C++ `enum` into PostgreSQL text for `enums` with `Parse()` and `ToString()` functions. See
+    @ref scripts/docs/en/userver/pg_user_types.md for more info.
+
+* Optimizations
+  * @ref concurrent::BackgroundTaskStorage was optimized with striped counters. Detaching a task now takes ~6% of
+    the whole CPU usage of the detaching benchmark (before the optimizations it was ~46%).
+  * @ref storages::Query now avoids dynamic initialization when constructed from @ref storages::Query::NameLiteral.
+    As a result variables generated with CMake `userver_add_sql_library` function are now not affected by initialization
+    order fiasco issues and can be safely used in any static or global variable. Dynamic memory allocations are
+    now avoided for the above cases.
+  * @ref utils::zstring_view now used for Kafka topic names avoiding temporary string constructions.
+
+* Build
+  * The oldest supported Python is now Python 3.9.
+  * Protobuf 6.x.y is now supported. Thanks to [halfdarkangel](https://github.com/halfdarkangel) for the PR!
+  * Supported by-component installation in CPack. See `USERVER_INSTALL_MULTIPACKAGE` CMake option for a way to enable
+    the feature.
+  * Optimized compilation time for the @ref userver/utils/periodic_task.hpp header by removing inclusion of 7
+    heavy headers.
+  * Improved build times by disabling modules scan. Many thanks to [Konstantin Goncharik](https://github.com/botanegg)
+    for the PR!
+  * Builds are now tested on Fedora.
+  * Bumped Kafka version to 4.0 in CI checks. Many thanks to [MichaelKab](https://github.com/MichaelKab) for PR!
+
+* Documentation and Diagnostics:
+  * Version change widget was rewritten to avoid versions hard-code. Many thanks to
+    [Lone-Marshal](https://github.com/Lone-Marshal) for the PR!
+  * Added docs on @ref scripts/docs/en/userver/distro_maintainers.md roles.
+  * Added more information on metadata usage into @ref scripts/docs/en/userver/grpc/grpc.md
+  * `USERVER_GTEST_ENABLE_STACK_USAGE_MONITOR` environment variable name was changed
+    to `USERVER_ENABLE_STACK_USAGE_MONITOR`. `USERVER_ENABLE_STACK_USAGE_MONITOR` is now usable not only in unit-tests,
+    but in all the userver based applications and services.
+  * Redis driver now does much more logging on cluster topology change to ease the cluster issues debugging.
+  * Dynamic config pages with description are now generated from schemes.
+
+
 ### Release v2.11
 
 * Added support for TLS in RedisCluster mode. Many thanks to [Danilkormilin](https://github.com/Danilkormilin) for the PR!
@@ -63,7 +143,7 @@ Changelog news also go to the
   [Konstantin Goncharik](https://github.com/botanegg) for the PR!
 * Allow dynamic selection of response streaming. Many thanks to [Sergei Fedorov](https://github.com/zmij)
   for the PR!
-* Added support for @ref mongo::options::Hint for @ref storages::mongo::operations::Delete,
+* Added support for @ref storages::mongo::options::Hint for @ref storages::mongo::operations::Delete,
   @ref storages::mongo::bulk_ops::Update and @ref  storages::mongo::bulk_ops::Delete.
 * @ref storages::Query now used in ClickHouse, MySQL and SQLite drivers, making it possible to directly use result of
   generation @ref scripts/docs/en/userver/sql_files.md "external SQL/YQL files". storages::Query::Statement() and
@@ -1781,6 +1861,6 @@ Detailed descriptions could be found below.
 ----------
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
-⇦ @ref scripts/docs/en/userver/development/releases.md | @ref scripts/docs/en/userver/faq.md ⇨
+⇦ @ref scripts/docs/en/userver/development/releases.md | @ref scripts/docs/en/userver/distro_maintainers.md ⇨
 @htmlonly </div> @endhtmlonly
 
diff --git a/scripts/docs/en/userver/sql_files.md b/scripts/docs/en/userver/sql_files.md
index 50d877187f08..f94b24fa23e5 100644
--- a/scripts/docs/en/userver/sql_files.md
+++ b/scripts/docs/en/userver/sql_files.md
@@ -1,6 +1,6 @@
-# External SQL/YQL files
+# Embedding SQL/YQL files via userver_add_sql_library
 
-You may generate SQL queries or YQL queries (for YDB) from external .sql/.yql files.
+You may generate SQL queries or YQL queries (for YDB) from `.sql` / `.yql` files.
 To do this, call the following cmake function in your CMakeLists.txt:
 
 @snippet samples/postgres_service/CMakeLists.txt Postgres service sample - CMakeLists.txt
@@ -31,8 +31,8 @@ const USERVER_NAMESPACE::storages::Query kSelectValue = {
 };
 @endcode
 
-Each variable is statically initialized (has no dynamic|runtime initializtion), giving a protection against static
-intialization order fiasco when those variables are used.
+Each variable is statically initialized (has no dynamic|runtime initialization), giving a protection against static
+initialization order fiasco when those variables are used.
 
 You may use it as usual by passing to @ref storages::postgres::Cluster::Execute() or @ref storages::clickhouse::Cluster
 for SQL files or @ref ydb::TableClient::ExecuteDataQuery() for YQL files:
diff --git a/scripts/docs/en/userver/stack.md b/scripts/docs/en/userver/stack.md
index f7945efe05e1..fef1ce1bdfd1 100644
--- a/scripts/docs/en/userver/stack.md
+++ b/scripts/docs/en/userver/stack.md
@@ -24,6 +24,14 @@ If you ignore the metric you might face a disaster anyway.
 In case of stack overflow the process gets a SIGSEGV on attempt to access missing memory page or even writes garbage to a random memory page.
 So you might want to use a metric to avoid the UB.
 
+The stack usage monitor can be explicitly disabled via `USERVER_ENABLE_STACK_USAGE_MONITOR` environment variable.
+If you have any issues with it, just set it to `0`:
+
+```
+bash
+export USERVER_ENABLE_STACK_USAGE_MONITOR=0
+```
+
 ----------
 
 @htmlonly <div class="bottom-nav"> @endhtmlonly
diff --git a/scripts/docs/en/userver/testing.md b/scripts/docs/en/userver/testing.md
index 5803d1deb74a..910575a21821 100644
--- a/scripts/docs/en/userver/testing.md
+++ b/scripts/docs/en/userver/testing.md
@@ -156,7 +156,7 @@ Userver uses signals for internal matters to identify coroutine stack usage @ref
 If you see too much "caught signal X" in debugger, you may disable stack usage monitor via environment variable:
 
 ```
-USERVER_GTEST_ENABLE_STACK_USAGE_MONITOR=0
+USERVER_ENABLE_STACK_USAGE_MONITOR=0
 ```
 
 Now you should not be annoyed by extra "caught signal X" events.
diff --git a/scripts/docs/en/userver/tutorial/postgres_service.md b/scripts/docs/en/userver/tutorial/postgres_service.md
index 08640b3e6bfe..9d7ef9143957 100644
--- a/scripts/docs/en/userver/tutorial/postgres_service.md
+++ b/scripts/docs/en/userver/tutorial/postgres_service.md
@@ -55,9 +55,9 @@ KeyValue component only uses the thread safe DB client. In more complex cases
 We can generate the necessary `storages::Query` objects from external SQL/YQL files.
 
 In our case, we have the following files:
-* @ref samples/postgres_service/select_value.sql
-* @ref samples/postgres_service/insert_value.sql
-* @ref samples/postgres_service/delete_value.sql
+* @ref samples/postgres_service/queries/read/select_value.sql
+* @ref samples/postgres_service/queries/write/insert_value.sql
+* @ref samples/postgres_service/queries/write/delete_value.sql
 
 From which we will get:
 @code{.hpp}
@@ -116,7 +116,7 @@ Note the `dynamic-config.defaults` usage. In
 @ref scripts/docs/en/userver/tutorial/production_service.md "production ready service"
 those values are usually retrieved from remote server, so that they could be
 changed at runtime without any need to restart the service. See
-@ref scripts/docs/en/schemas/dynamic_configs.md for more info.
+@ref scripts/docs/en/dynamic_configs/dynamic_configs.md for more info.
 
 
 ### int main()
@@ -225,6 +225,6 @@ See the full example:
 @example samples/postgres_service/CMakeLists.txt
 @example samples/postgres_service/tests/conftest.py
 @example samples/postgres_service/tests/test_postgres.py
-@example samples/postgres_service/select_value.sql
-@example samples/postgres_service/insert_value.sql
-@example samples/postgres_service/delete_value.sql
+@example samples/postgres_service/queries/read/select_value.sql
+@example samples/postgres_service/queries/write/insert_value.sql
+@example samples/postgres_service/queries/write/delete_value.sql
diff --git a/scripts/docs/en/userver/tutorial/production_service.md b/scripts/docs/en/userver/tutorial/production_service.md
index 7e7dd9d32bca..45fe3ceab486 100644
--- a/scripts/docs/en/userver/tutorial/production_service.md
+++ b/scripts/docs/en/userver/tutorial/production_service.md
@@ -146,7 +146,7 @@ file (if it exists).
 @note Dynamic configs is an essential part of a reliable service with high
       availability. Those could be used as an emergency switch for new
       functionality, selector for experiments, limits/timeouts/log-level setup,
-      proxy setup. See @ref scripts/docs/en/schemas/dynamic_configs.md for
+      proxy setup. See @ref scripts/docs/en/dynamic_configs/dynamic_configs.md for
       more info and @ref scripts/docs/en/userver/tutorial/config_service.md for
       insights on how to implement such service.
 
diff --git a/scripts/docs/en/userver/tutorial/static_content.md b/scripts/docs/en/userver/tutorial/static_content.md
index c74652756ce6..520102558d46 100644
--- a/scripts/docs/en/userver/tutorial/static_content.md
+++ b/scripts/docs/en/userver/tutorial/static_content.md
@@ -45,7 +45,7 @@ concurrently on the same instance of `MessagesHandler` if more than one requests
 ### Serving Static Content
 
 The C++ code for serving static content is extremely simple because all the logic is provided by the ready-to-use
-@ref userver::server::handlers::HttpHandlerStatic. Just add it and the components::FsCache into the component list:
+@ref server::handlers::HttpHandlerStatic. Just add it and the components::FsCache into the component list:
 
 @snippet samples/static_service/main.cpp  Static service sample - main
 
@@ -60,7 +60,7 @@ Providing paths to files in file system to the `fs-cache-main` component, tellin
 With the above config a request to
 * `/index.html` will receive file `/var/www/index.html`;
 * `/` will receive file `/var/www/index.html` due to the default value of `directory-file` static config option of
-  @ref userver::server::handlers::HttpHandlerStatic;
+  @ref server::handlers::HttpHandlerStatic;
 * `/custom.js` will receive file `/var/www/custom.js`;
 * `/custom.css` will receive file `/var/www/custom.css`;
 * `/v1/messages` request will be processed by our `MessagesHandler` handler.
diff --git a/scripts/docs/generate_versions.py b/scripts/docs/generate_versions.py
new file mode 100644
index 000000000000..17055ec9f244
--- /dev/null
+++ b/scripts/docs/generate_versions.py
@@ -0,0 +1,33 @@
+import json
+from pathlib import Path
+
+import requests
+
+url = 'https://api.github.com/repos/userver-framework/docs/contents/'
+headers = {'Accept': 'application/vnd.github+json'}
+response = requests.get(url, headers=headers)
+response.raise_for_status()
+data = response.json()
+
+versions = [item['name'] for item in data if item['type'] == 'dir' and item['name'].lower().startswith('v')]
+
+versions.sort(key=lambda v: [int(x) for x in v.lstrip('vV').split('.')])
+
+versions_js_path = Path('scripts/docs/scripts/versions.js')
+versions_js_path.parent.mkdir(parents=True, exist_ok=True)
+
+versions_js_content = f'export const versions = {json.dumps(versions)};\n'
+versions_js_path.write_text(versions_js_content, encoding='utf-8')
+
+versions_md_path = Path('scripts/docs/en/versions.md')
+versions_md_path.parent.mkdir(parents=True, exist_ok=True)
+
+versions_md_content = (
+    '\\page versions Versions\n\n'
+    + '- [trunk/develop](index.html)\n'
+    + '\n'.join(f'- [{ver}](docs/{ver}/index.html)' for ver in reversed(versions))
+    + '\n'
+)
+versions_md_path.write_text(versions_md_content, encoding='utf-8')
+
+print('✅ versions.js and versions.md generated')
diff --git a/scripts/docs/img/slugkit.svg b/scripts/docs/img/slugkit.svg
new file mode 100644
index 000000000000..97096c04293b
--- /dev/null
+++ b/scripts/docs/img/slugkit.svg
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="100"
+   height="100"
+   viewBox="0 0 36 35"
+   version="1.1"
+   id="svg1"
+   sodipodi:docname="slug-black.svg"
+   inkscape:version="1.4 (e7c3feb1, 2024-10-09)"
+   inkscape:export-filename="slug.png"
+   inkscape:export-xdpi="576"
+   inkscape:export-ydpi="576"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1" />
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="3.7615115"
+     inkscape:cx="31.503293"
+     inkscape:cy="59.417604"
+     inkscape:window-width="1712"
+     inkscape:window-height="958"
+     inkscape:window-x="2338"
+     inkscape:window-y="113"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg1" />
+  <path
+     id="path1"
+     style="fill:#000000;stroke:none;stroke-width:0.513484"
+     d="m 26.617811,9.2252555 c -2.79871,-0.946797 -5.83501,-1.314909 -8.559131,0.135857 0,-1.710385 -0.234005,-3.608052 0.02003,-5.298507 0.151493,-1.008119 0.987251,-1.583572 0.742091,-2.717184 -0.352013,-1.62773996 -2.453968,-2.23115 -3.561588,-0.93675594 -1.09869,1.28395794 0.01792,2.28084494 0.311346,3.51808094 0.39757,1.676514 0.290745,4.545192 0.02254,6.2489975 -0.114265,0.725881 -0.833106,1.073382 -1.326302,1.53429 -0.732454,0.684499 -1.357317,1.539793 -1.856012,2.406153 -1.576713,2.739163 -1.567455,5.988358 -3.21072,8.694986 -1.518201,2.500639 -4.016078,3.668229 -5.8230719,5.843941 -0.888173,1.069396 -1.578721,2.552095 -1.012343,3.93792 1.235025,3.021885 5.7315229,2.717185 8.3576469,2.717185 h 9.102564 c 4.70104,0 9.73558,-0.12856 11.75675,-5.298507 1.69639,-4.339198 0.99234,-10.908023 -0.48086,-15.216227 -0.48034,-1.404717 -1.81944,-2.691131 -2.13212,-4.075777 -0.40998,-1.8154575 -0.29814,-4.8148505 -0.0212,-6.6571025 0.16718,-1.11209 1.10309,-1.725936 0.70645,-2.9889019 -0.59015,-1.8791261 -3.45461,-1.7591921 -3.91465,0.135859 -0.31403,1.2935389 0.68567,1.7611109 0.85855,2.8583909 0.25813,1.638306 0.02,3.49774 0.02,5.157302 M 15.477323,18.245529 c 1.007686,-0.231899 2.229273,-0.05357 3.260628,-0.05357 h 6.52124 c 1.05773,0 2.66334,-0.307659 3.51808,0.445421 0.80718,0.711175 0.69355,1.705577 0.69355,2.679342 0,2.126063 0.0543,4.260126 -0.002,6.385378 -0.0222,0.837271 -0.35562,1.674403 -1.22127,1.949204 -0.99828,0.316901 -2.35517,0.08868 -3.39595,0.08868 h -6.928825 c -1.059876,0 -2.560768,0.288567 -3.365555,-0.561572 -0.651816,-0.688555 -0.574363,-1.686773 -0.574363,-2.563186 0,-2.131547 -0.324198,-4.558152 0.04467,-6.657104 0.139396,-0.793219 0.631041,-1.524183 1.449796,-1.712601 m 2.586776,2.752303 c -1.919099,0.632601 -0.844121,3.643093 1.081431,3.062179 2.18735,-0.659903 1.07477,-3.772943 -1.081431,-3.062179 m 4.633891,0.419737 c -0.55505,0.251088 -0.56621,1.200272 0,1.447489 0.74324,0.324506 3.55538,0.358617 4.28418,0 0.5222,-0.256957 0.37234,-1.254543 -0.1128,-1.46636 -0.77176,-0.336958 -3.40451,-0.328039 -4.17138,0.01884 m 0.13051,3.101702 c -0.65281,0.210811 -0.76733,1.284967 -0.11961,1.587537 0.72885,0.340471 3.15235,0.326894 3.89411,0.0189 0.67402,-0.2799 0.65219,-1.295139 -0.004,-1.583347 -0.79162,-0.34804 -2.9516,-0.287721 -3.77114,-0.02306 m -4.633999,0.688309 c -0.646686,0.06237 -2.766957,1.35723 -1.451258,2.004969 0.802888,0.395279 3.007697,0.211976 3.888767,0.06185 0.80998,-0.138014 0.52177,-1.121135 0.0902,-1.534397 -0.61141,-0.585535 -1.73426,-0.60896 -2.527759,-0.532426 z" />
+</svg>
diff --git a/scripts/docs/landing.css b/scripts/docs/landing.css
index fdb8cd08bcf7..34746db7fd01 100644
--- a/scripts/docs/landing.css
+++ b/scripts/docs/landing.css
@@ -780,6 +780,12 @@ html.dark-mode .values__card {
   width: 63px;
 }
 
+.logo_slugkit {
+  mask-image: url("slugkit.svg");
+  -webkit-mask-image: url("slugkit.svg");
+  width: 63px;
+}
+
 @media (max-width: 767px) {
   .companies__logos {
     justify-content: space-around;
diff --git a/scripts/docs/make_docs.sh b/scripts/docs/make_docs.sh
index 453bf0d87c4c..be9e67ea3b6d 100755
--- a/scripts/docs/make_docs.sh
+++ b/scripts/docs/make_docs.sh
@@ -1,5 +1,8 @@
 #!/bin/sh
 
+# Exit on any error
+set -e
+
 cd "$(dirname "$0")/../.."
 
 if [ -z "$BUILD_DIR" ]; then
@@ -50,12 +53,18 @@ echo "Building target userver-codegen."
 
 echo "Building target userver-gen-dynamic-configs-docs."
 "$CMAKE_COMMAND" --build "$BUILD_DIR" --target userver-gen-dynamic-configs-docs
-rm -f scripts/docs/en/dynamic_configs
-ln -s ../../../$BUILD_DIR/docs-dynamic-configs scripts/docs/en/dynamic_configs
+rm -rf scripts/docs/en/dynamic_configs
+mkdir scripts/docs/en/dynamic_configs
+cp $BUILD_DIR/docs-dynamic-configs/* scripts/docs/en/dynamic_configs/
 
 # Run doxygen.
 rm -rf "$BUILD_DIR/docs" || :
 
+if [ -z "$NO_DEFAULT_HTML_CLEANUP" ]; then
+    # Generate versions for docs
+    python3 scripts/docs/generate_versions.py
+fi
+
 DOXYFILE_OVERRIDES="${DOXYFILE_OVERRIDES:-}"
 
 echo "Running doxygen..."
@@ -71,3 +80,6 @@ if [ -z "$NO_DEFAULT_HTML_CLEANUP" ]; then
     cp "$BUILD_DIR/docs/html/d8/dee/md_en_2userver_2404.html" "$BUILD_DIR/docs/html/404.html" || :
     sed -i 's|\.\./\.\./|/|g' "$BUILD_DIR/docs/html/404.html"
 fi
+
+# Cleanup
+rm -rf scripts/docs/en/dynamic_configs || :
diff --git a/scripts/docs/scripts/header.js b/scripts/docs/scripts/header.js
index e5481a9c0d5f..f68afb16cf20 100644
--- a/scripts/docs/scripts/header.js
+++ b/scripts/docs/scripts/header.js
@@ -1,3 +1,17 @@
+const TRUNK_VERSION = "trunk/develop";
+const NONE_VERSION = "none"
+
+function loadVersions() {
+    return import('/versions.js').then((imported_versions_module) => {
+        versions = imported_versions_module.versions
+        return versions
+    }
+    ).catch(() => {
+        console.log("Versions loading failed")
+    });
+}
+
+
 const addModal = () => {
     const modalHandler = () => {
         const modal = document.getElementById('main-nav')
@@ -62,17 +76,19 @@ const remove_legacy_searchbox = () => {
 }
 
 const old_docs_version = () => {
-    const version = "v3.0"
-    const brief = document.getElementById('projectbrief').getElementsByTagName('a')[0];
-    brief.textContent += " " + version;
-    const base_page_url = window.location.pathname.split('/' + version + '/')[1];
+    const version = get_current_version()
+
+    if (version != TRUNK_VERSION) {
+        const brief = document.getElementById('projectbrief').getElementsByTagName('a')[0];
+        brief.textContent += " " + version;
+    }
 
     var warning = document.createElement("div");
     warning.style.width = '100%';
     warning.style.display = 'flex';
     warning.style.flexDirection = 'column';
     warning.innerHTML = `
-      <a style="padding: 16px; margin-bottom: 20px; text-align: center; border: 1px solid var(--warning-color-dark); border-radius: var(--border-radius-large);" href="/` + base_page_url + `">
+      <a style="padding: 16px; margin-bottom: 20px; text-align: center; border: 1px solid var(--warning-color-dark); border-radius: var(--border-radius-large);" href="/">
         ⚠️ This is the documentation for an old userver version. Click here to switch to the latest version.
       </a>
     `;
@@ -80,17 +96,110 @@ const old_docs_version = () => {
     titlearea.parentNode.insertBefore(warning, titlearea);
 }
 
+const get_current_version = () => {
+    const { pathname } = window.location;
+
+    const urlSplitLimiter = 3;
+    const versionTokenPosition = 2;
+
+    if (pathname.startsWith("/docs/")) {
+        return pathname.split("/", urlSplitLimiter)[versionTokenPosition]
+    }
+
+    if (pathname.startsWith("/d4/de0/versions.html")) {
+        return NONE_VERSION
+    }
+
+    return TRUNK_VERSION;
+}
+
+const getPreviousVersion = (versions, current_version) => {
+    let index = -1;
+
+    if (typeof current_version.index === "number") {
+        index = current_version.index;
+    } else if ("value" in current_version) {
+        index = versions.indexOf(current_version.value);
+    }
+
+    if (index <= 0 || index >= versions.length) {
+        return undefined;
+    }
+
+    return {
+        index: index - 1,
+        value: versions[index - 1]
+    };
+}
+
+const getVersionMajorPart = (version) => {
+    const major = version.split(".")[0].replace("v", "");
+
+    const major_as_number = parseInt(major, 10);
+
+    return major_as_number;
+};
+
+
+const floor_to_major_version = (versions, target_version) => {
+    let target_major_version = getVersionMajorPart(target_version)
+    let version_iterator = { value: target_version, index: versions.length - 1 }
+
+    while (getVersionMajorPart(getPreviousVersion(versions, version_iterator).value) == target_major_version) {
+        version_iterator = getPreviousVersion(versions, version_iterator)
+    }
+
+    return version_iterator.value
+}
+
 const add_docs_versioning = () => {
-    // old_docs_version();
-    const footer = document.getElementById('nav-path').getElementsByTagName('ul')[0];
-    footer.innerHTML = `
-    <li style="box-shadow: inset -1px 0 0 0 var(--separator-color); background-image: none; margin-right: 48px;">
+
+    loadVersions().then((versions) => {
+        const latest_version = versions[versions.length - 1]
+        let second_likely_popular_version = floor_to_major_version(versions, latest_version)
+
+        if (second_likely_popular_version == latest_version) {
+            second_likely_popular_version = getPreviousVersion(versions, { value: latest_version }).value
+        }
+
+        const current_version = get_current_version()
+
+        if (current_version != latest_version &&
+            current_version != TRUNK_VERSION &&
+            current_version != NONE_VERSION) {
+            old_docs_version()
+        }
+
+        const footer = document.getElementById('nav-path').getElementsByTagName('ul')[0];
+        const footer_prefix = `
+        <li style="box-shadow: inset -1px 0 0 0 var(--separator-color); background-image: none; margin-right: 48px;">
         <span style="color: var(--toc-foreground);">Docs version:</span>
-        <a href="/docs/v1.0` + window.location.pathname + `">v1.0</a>,
-        <a href="/docs/v2.0` + window.location.pathname + `">v2.0</a>,
-        <span style="background-image: none; color: var(--toc-active-color); font-weight: bold;">trunk/develop</span>
-    </li>`
-    + footer.innerHTML;
+    `
+
+        let footer_infix = ""
+
+        if (current_version == TRUNK_VERSION) {
+            footer_infix += `<span style="background-image: none; color: var(--toc-active-color); font-weight: bold;">${TRUNK_VERSION}</span>, `
+        } else {
+            footer_infix += `<a href="/index.html">${TRUNK_VERSION}</a>, `
+        }
+
+        not_trunk_versions = [latest_version, second_likely_popular_version]
+
+        for (let version of not_trunk_versions) {
+            if (current_version != version) {
+                footer_infix += `<a href="/docs/${version}/index.html">${version}</a>, `
+            } else {
+                footer_infix += `<span style="background-image: none; color: var(--toc-active-color); font-weight: bold;">${version}</span>, `
+            }
+        }
+
+        footer_infix += `<a href="/d4/de0/versions.html">others</a>`
+
+        footer.innerHTML = footer_prefix + footer_infix
+            + footer.innerHTML;
+    })
+
 }
 
 const init_header = () => {
diff --git a/scripts/docs/upload_docs.sh b/scripts/docs/upload_docs.sh
index c20a68405d70..5ce2217a455c 100755
--- a/scripts/docs/upload_docs.sh
+++ b/scripts/docs/upload_docs.sh
@@ -1,5 +1,8 @@
 #!/bin/sh
 
+# Exit on any error
+set -e
+
 if [ -z "$BUILD_DIR" ]; then
     echo "!!! Set BUILD_DIR environment variable to cmake build directory with docs already built."
     echo "!!! See userver/scripts/docs/README.md"
diff --git a/scripts/gdb/pretty_printers/cmd/utask/cmd.py b/scripts/gdb/pretty_printers/cmd/utask/cmd.py
index 93c3dab3ee73..01c68885dbc9 100644
--- a/scripts/gdb/pretty_printers/cmd/utask/cmd.py
+++ b/scripts/gdb/pretty_printers/cmd/utask/cmd.py
@@ -25,7 +25,7 @@ class FrameId:
 arch_name: str = re.search(
     'boost.*context.*/asm/jump_([a-z_0-9]+)', gdb.execute('info sources boost.*context.*/asm/jump_', to_string=True)
 ).group(1)
-registers_offets = {
+registers_offsets = {
     'x86_64_sysv_elf_gas': {
         'r12': 0x10,
         'r13': 0x18,
@@ -164,7 +164,7 @@ def __init__(self, ctx: gdb.Value):
 
     def read_registers(self):
         result: dict[str, gdb.Value] = {}
-        for reg_name, reg_offset in registers_offets.items():
+        for reg_name, reg_offset in registers_offsets.items():
             reg_value = self.ctx + reg_offset
             if reg_name != 'sp':
                 reg_value = reg_value.cast(void_pp_t).dereference()
@@ -467,13 +467,13 @@ def invoke(self, arg: str, from_tty: bool):
                 if task_cnt == 0:
                     print('No tasks found')
             else:
-                fast_cheched_tasks: list[TaskContext] = []
+                fast_chached_tasks: list[TaskContext] = []
                 for task in get_all_tasks():
                     # fast filtering
                     if which_task == task.task_id:
                         return self.invoke_per_task(task, cmd, from_tty)
-                    fast_cheched_tasks.append(task)
-                for task in fast_cheched_tasks:
+                    fast_chached_tasks.append(task)
+                for task in fast_chached_tasks:
                     # getting attached_span is a bit longer
                     if (span := task.attached_span) and which_task == span.name:
                         return self.invoke_per_task(task, cmd, from_tty)
diff --git a/scripts/generate-debian-directory.sh b/scripts/generate-debian-directory.sh
new file mode 100755
index 000000000000..52a78649e8bb
--- /dev/null
+++ b/scripts/generate-debian-directory.sh
@@ -0,0 +1,97 @@
+#!/bin/bash
+
+# Exit on any error and treat unset variables as errors, print all commands
+set -euo pipefail
+
+VERSION=${VERSION:-$(cat version.txt)}
+DISTRO=${DISTRO:-ubuntu-24.04}
+ALL_MODULES=$(ls scripts/docs/en/deps/$DISTRO)
+ALL_PACKAGES=$(echo $ALL_MODULES | xargs -n1 | sed 's/.*/libuserver-\0-dev/')
+BUILD_DEPENDENCIES=$(cat scripts/docs/en/deps/$DISTRO.md | sed 's/$/,/' | xargs | sed 's/,$//')
+
+
+
+# Cleanup
+rm -rf debian/
+
+
+# Static files
+mkdir -p debian/
+cp scripts/debian-rules debian/rules
+
+
+# Generate debian/control
+cat >debian/control <<EOF
+Source: userver
+Section: libdevel
+Priority: optional
+Maintainer: Antony Polukhin <antoshkka@userver.tech>
+Build-Depends: debhelper-compat (= 13),
+               dh-cmake,
+	       dh-cmake-compat (= 1),
+               dh-sequence-ctest,
+               dh-sequence-cpack,
+               cmake (>= 3.14),
+               pkg-config,
+               libc6-dev,
+	       $BUILD_DEPENDENCIES
+Standards-Version: 4.6.2
+Homepage: https://userver.tech
+Vcs-Git: https://github.com/userver-framework/userver.git
+Vcs-Browser: https://github.com/userver-framework/userver
+
+Package: libuserver-all-dev
+Architecture: any
+Depends: $(echo $ALL_PACKAGES | sed 's/ /, /g' | xargs), libuserver-examples
+Description:
+ userver is the modern open source asynchronous framework with a rich set
+ of abstractions for fast and comfortable creation of C++ microservices,
+ services and utilities.
+ .
+ This metapackage provides the complete userver development environment,
+ including all modules, libraries and examples.
+
+Package: libuserver-examples
+Architecture: any
+Description:
+ userver is the modern open source asynchronous framework with a rich set
+ of abstractions for fast and comfortable creation of C++ microservices,
+ services and utilities.
+ .
+ This package contains userver example services.
+
+EOF
+
+for MODULE in $ALL_MODULES; do
+    echo "$MODULE" >debian/libuserver-$MODULE-dev.cpack-components
+
+    cat >>debian/control <<EOF
+Package: libuserver-$MODULE-dev
+Architecture: any
+Depends: \${cpack:Depends}, \${misc:Depends}
+Description:
+ userver is the modern open source asynchronous framework with a rich set
+ of abstractions for fast and comfortable creation of C++ microservices,
+ services and utilities.
+ .
+ This package provides $MODULE module/library support.
+
+EOF
+done
+
+
+# TODO: parse ./scripts/docs/en/userver/roadmap_and_changelog.md ?
+#
+# Generate debian/changelog
+cat >debian/changelog <<EOF
+userver ($VERSION) unstable; urgency=medium
+
+  $(awk '/### Release/ {p++;} {if(p==1) print "  "$0;}' <scripts/docs/en/userver/roadmap_and_changelog.md)
+
+ -- Vasily Kulikov <segoon@yandex-team.ru>  Wed, 20 Aug 2025 22:19:05 +0300
+EOF
+
+cat <<EOF
+debian/{control,changelog,*} are generated.
+Now run 'dpkg-buildpackage -S' to build debian source package.
+EOF
diff --git a/scripts/grpc/requirements-6.txt b/scripts/grpc/requirements-6.txt
new file mode 100644
index 000000000000..581c04339814
--- /dev/null
+++ b/scripts/grpc/requirements-6.txt
@@ -0,0 +1,2 @@
+Jinja2 >= 2.10
+protobuf >= 6.30.0, < 7.0dev
diff --git a/scripts/grpc/templates/client.usrv.cpp.jinja b/scripts/grpc/templates/client.usrv.cpp.jinja
index 5211cc6ba856..f473c9468bbc 100644
--- a/scripts/grpc/templates/client.usrv.cpp.jinja
+++ b/scripts/grpc/templates/client.usrv.cpp.jinja
@@ -13,9 +13,20 @@
 {% for service in proto.services %}
 
 // Inline to deduplicate between client.usrv.cpp and service.usrv.cpp
-inline constexpr std::array<std::string_view, {{service.method | length}}> k{{service.name}}MethodNames = {
+inline constexpr std::array<USERVER_NAMESPACE::ugrpc::impl::MethodDescriptor, {{service.method | length}}> k{{service.name}}Methods = {
 {% for method in service.method %}
-    "{{proto.package_prefix}}{{service.name}}/{{method.name}}",
+    USERVER_NAMESPACE::ugrpc::impl::MethodDescriptor{
+        "{{proto.package_prefix}}{{service.name}}/{{method.name}}",
+{% if method.client_streaming and method.server_streaming %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kBidiStreaming,
+{% elif method.client_streaming %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kClientStreaming,
+{% elif method.server_streaming %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kServerStreaming,
+{% else %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kUnary,
+{% endif %}
+    },
 {% endfor %}
 };
 
@@ -29,11 +40,17 @@ inline const bool k{{service.name}}TypesRegistration =
     }),
     false);
 
-{{service.name}}Client::{{service.name}}Client(
-    USERVER_NAMESPACE::ugrpc::client::impl::ClientInternals&& internals)
-    : impl_(std::move(internals), GetMetadata(),
+{{service.name}}Client::{{service.name}}Client(USERVER_NAMESPACE::ugrpc::client::impl::ClientInternals&& internals)
+    : client_data_(std::move(internals), GetMetadata(),
             std::in_place_type<{{utils.namespace_with_colons(proto.namespace)}}::{{service.name}}>) {
     }
+
+{{service.name}}Client::{{service.name}}Client({{service.name}}Client&&) noexcept = default;
+
+{{service.name}}Client& {{service.name}}Client::operator=({{service.name}}Client&&) noexcept = default;
+
+{{service.name}}Client::~{{service.name}}Client() = default;
+
 {% for method in service.method %}
 {% set method_id = loop.index0 %}
 
@@ -43,7 +60,7 @@ inline const bool k{{service.name}}TypesRegistration =
 ) const {
     return {
         USERVER_NAMESPACE::ugrpc::client::impl::CreateCallParams(
-            impl_, {{method_id}}, std::move(call_options)
+            *client_data_, {{method_id}}, std::move(call_options)
         ),
         &{{service.name}}::Stub::PrepareAsync{{method.name}},
     };
@@ -54,7 +71,7 @@ inline const bool k{{service.name}}TypesRegistration =
 ) const {
     return {
         USERVER_NAMESPACE::ugrpc::client::impl::CreateCallParams(
-            impl_, {{method_id}}, std::move(call_options)
+            *client_data_, {{method_id}}, std::move(call_options)
         ),
         &{{service.name}}::Stub::PrepareAsync{{method.name}},
     };
@@ -66,7 +83,7 @@ inline const bool k{{service.name}}TypesRegistration =
 ) const {
     return {
         USERVER_NAMESPACE::ugrpc::client::impl::CreateCallParams(
-            impl_, {{method_id}}, std::move(call_options)
+            *client_data_, {{method_id}}, std::move(call_options)
         ),
         &{{service.name}}::Stub::PrepareAsync{{method.name}},
         request,
@@ -79,7 +96,7 @@ inline const bool k{{service.name}}TypesRegistration =
 ) const {
     return USERVER_NAMESPACE::ugrpc::client::impl::PerformUnaryCall(
         USERVER_NAMESPACE::ugrpc::client::impl::CreateCallParams(
-            impl_, {{method_id}}, std::move(call_options)
+            *client_data_, {{method_id}}, std::move(call_options)
         ),
         USERVER_NAMESPACE::ugrpc::client::impl::PrepareUnaryCallProxy(
             &{{service.name}}::Stub::PrepareAsync{{method.name}}
@@ -94,7 +111,7 @@ inline const bool k{{service.name}}TypesRegistration =
 ) const {
     return {
         USERVER_NAMESPACE::ugrpc::client::impl::CreateCallParams(
-            impl_, {{method_id}}, std::move(call_options)
+            *client_data_, {{method_id}}, std::move(call_options)
         ),
         USERVER_NAMESPACE::ugrpc::client::impl::PrepareUnaryCallProxy(
             &{{service.name}}::Stub::PrepareAsync{{method.name}}
@@ -111,7 +128,7 @@ USERVER_NAMESPACE::ugrpc::impl::StaticServiceMetadata
 
   return USERVER_NAMESPACE::ugrpc::impl::MakeStaticServiceMetadata<
       {{utils.namespace_with_colons(proto.namespace)}}::{{service.name}}>(
-          k{{service.name}}MethodNames);
+          k{{service.name}}Methods);
 }
 {% endfor %}
 {% endcall %} {# utils.optional_namespace #}
diff --git a/scripts/grpc/templates/client.usrv.hpp.jinja b/scripts/grpc/templates/client.usrv.hpp.jinja
index 37ea8241b4a2..9cefd1c9cff5 100644
--- a/scripts/grpc/templates/client.usrv.hpp.jinja
+++ b/scripts/grpc/templates/client.usrv.hpp.jinja
@@ -17,9 +17,11 @@
 // Client for {{service.name}}
 class {{service.name}}Client final {
 public:
-    // For internal use only
-    {{service.name}}Client(
-        USERVER_NAMESPACE::ugrpc::client::impl::ClientInternals&& internals);
+    {{service.name}}Client({{service.name}}Client&&) noexcept;
+    {{service.name}}Client& operator=({{service.name}}Client&&) noexcept;
+
+    ~{{service.name}}Client();
+
 {% for method in service.method %}
 
 {% if method.client_streaming and method.server_streaming %}
@@ -65,16 +67,18 @@ public:
 {% endif %}
 {% endfor %}
 
+    /// @cond
     // For internal use only
+    {{service.name}}Client(USERVER_NAMESPACE::ugrpc::client::impl::ClientInternals&& internals);
+
     static USERVER_NAMESPACE::ugrpc::impl::StaticServiceMetadata GetMetadata();
+    /// @endcond
 
 private:
-    template <typename Client>
-    friend USERVER_NAMESPACE::ugrpc::client::impl::ClientData&
-    USERVER_NAMESPACE::ugrpc::client::impl::GetClientData(Client& client);
+    friend class USERVER_NAMESPACE::ugrpc::client::impl::ClientDataAccessor;
 
     {# All non-template related client data should be placed in ClientData #}
-    USERVER_NAMESPACE::ugrpc::client::impl::ClientData impl_;
+    USERVER_NAMESPACE::utils::Box<USERVER_NAMESPACE::ugrpc::client::impl::ClientData> client_data_;
 };
 {% endfor %}
 {% endcall %} {# utils.optional_namespace #}
diff --git a/scripts/grpc/templates/service.usrv.cpp.jinja b/scripts/grpc/templates/service.usrv.cpp.jinja
index 9308d2610a70..0bdcdac7d336 100644
--- a/scripts/grpc/templates/service.usrv.cpp.jinja
+++ b/scripts/grpc/templates/service.usrv.cpp.jinja
@@ -13,10 +13,21 @@
 {% for service in proto.services %}
 
 // Inline to deduplicate between client.usrv.cpp and service.usrv.cpp
-inline constexpr std::array<std::string_view, {{service.method | length}}> k{{service.name}}MethodNames{
-  {% for method in service.method %}
-  std::string_view{"{{proto.package_prefix}}{{service.name}}/{{method.name}}"},
-  {% endfor %}
+inline constexpr std::array<USERVER_NAMESPACE::ugrpc::impl::MethodDescriptor, {{service.method | length}}> k{{service.name}}Methods = {
+{% for method in service.method %}
+    USERVER_NAMESPACE::ugrpc::impl::MethodDescriptor{
+        "{{proto.package_prefix}}{{service.name}}/{{method.name}}",
+{% if method.client_streaming and method.server_streaming %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kBidiStreaming,
+{% elif method.client_streaming %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kClientStreaming,
+{% elif method.server_streaming %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kServerStreaming,
+{% else %}
+        USERVER_NAMESPACE::ugrpc::impl::RpcType::kUnary,
+{% endif %}
+    },
+{% endfor %}
 };
 
 // Inline to deduplicate between client.usrv.cpp and service.usrv.cpp
@@ -77,7 +88,7 @@ std::unique_ptr<USERVER_NAMESPACE::ugrpc::server::impl::ServiceWorker>
 
   return USERVER_NAMESPACE::ugrpc::server::impl::MakeServiceWorker<
       {{utils.namespace_with_colons(proto.namespace)}}::{{service.name}}>(
-      std::move(internals), k{{service.name}}MethodNames, *this{% if service.method %},{% endif %}
+      std::move(internals), k{{service.name}}Methods, *this{% if service.method %},{% endif %}
       {% for method in service.method %}
       &{{service.name}}Base::{{method.name}}{{ "," if not loop.last }}
       {% endfor %}
diff --git a/scripts/proto_structs/README.md b/scripts/proto_structs/README.md
new file mode 100644
index 000000000000..5dd79e39cb85
--- /dev/null
+++ b/scripts/proto_structs/README.md
@@ -0,0 +1,64 @@
+# userver proto structs generator
+
+The generator is currently highly experimental, cmake integration is non-existent.
+
+To get proper syntax highlighting in an IDE, add `userver/scripts` directory to your Python Path. For example, in `.vscode/settings.json`:
+
+```json
+{
+    "python.analysis.extraPaths": [
+        "${workspaceFolder}/scripts"
+    ],
+    "python.languageServer": "Pylance"
+}
+```
+
+# Implementation node: controlling whitespace in jinja
+
+We want the generated files to look like a formatted file.
+Applying clang-format is not an option, because it would take too long to build large projects.
+
+First, read docs on [Whitespace Control](https://jinja.palletsprojects.com/en/stable/templates/#whitespace-control).
+Summary, with our settings:
+
+* Most whitespace is written as it appears in the template
+   * This includes empty lines
+   * This includes trailing newline after `}}` and `#}`
+
+* A single trailing newline after `%}` is removed automatically
+
+* `{%-`, `{{-`, `{#-` removes all whitespace before the block, starting from the previous text or statement
+
+* `-%}`, `-}}`, `-#}` removes all whitespace after the block, ending at the next text or statement
+
+* In particular, `{{-` and `-}}` are not equivalent to `trim`, they remove whitespace outside the expression
+
+## Whitespace control policy
+
+1. Do not indent anything manually. Use `{% filter indent(width=4, first=True) %}` instead.
+
+2. Do not use `trim`. Instead of removing extra newlines, make it so that extra newlines are not generated.
+
+3. A macro that generates a whole line or multiple lines should include the trailing newline character, 
+   so that it produces a [POSIX line](https://stackoverflow.com/q/729692/5173839).
+
+   * On the other hand, a macro that generates a part of a line should not include the trailing newline.
+     Use `{%- endmacro %}` for that.
+
+4. When calling macros that generate a whole line or multiple lines, be aware that `}}` produces an extra empty line
+   (unless cut by the next block) use `-}}` or `{%-` in the next block to produce no extra empty lines.
+
+5. For definitions that should be separated by a single empty line,
+   put a single empty line at the beginning of the macro that generates it.
+
+   * A block of such definitions looks like this:
+     ```jinja
+     {
+     {% for child in children %}
+     {{ render(child) -}}
+     {% endfor %}
+
+     }
+     ```
+     This expects that `render` macro includes a leading empty line.
+   * This pattern composes nicely with complex nesting and elements of different kinds.
diff --git a/scripts/proto_structs/descriptors/__init__.py b/scripts/proto_structs/descriptors/__init__.py
new file mode 100644
index 000000000000..b2c63563d84b
--- /dev/null
+++ b/scripts/proto_structs/descriptors/__init__.py
@@ -0,0 +1 @@
+"""The bridge between Python Protobuf types and `proto_structs.models`."""
diff --git a/scripts/proto_structs/descriptors/descriptor_proto.py b/scripts/proto_structs/descriptors/descriptor_proto.py
new file mode 100644
index 000000000000..6f03f6c4d522
--- /dev/null
+++ b/scripts/proto_structs/descriptors/descriptor_proto.py
@@ -0,0 +1,42 @@
+"""Functions for working with raw descriptors from `google.protobuf.descriptor_pb2`."""
+
+import functools
+from typing import Dict
+from typing import List
+from typing import Mapping
+
+import google.protobuf.descriptor as descriptor
+import google.protobuf.descriptor_pb2 as descriptor_pb2  # pyright: ignore
+
+
+@functools.cache
+def to_descriptor_proto(message: descriptor.Descriptor) -> descriptor_pb2.DescriptorProto:  # pyright: ignore
+    """Converts `Descriptor` to `DescriptorProto`."""
+    message_proto = descriptor_pb2.DescriptorProto()  # pyright: ignore
+    message.CopyToProto(message_proto)  # pyright: ignore
+    return message_proto  # pyright: ignore
+
+
+@functools.cache
+def message_fields_map(  # pyright: ignore
+    message: descriptor.Descriptor,
+) -> Mapping[str, descriptor_pb2.FieldDescriptorProto]:  # pyright: ignore
+    """Returns a mapping from field names to their descriptors."""
+    message_proto = to_descriptor_proto(message)  # pyright: ignore
+    fields: List[descriptor_pb2.FieldDescriptorProto] = message_proto.field  # pyright: ignore
+    result: Dict[str, descriptor_pb2.FieldDescriptorProto] = {}  # pyright: ignore
+    for field in fields:  # pyright: ignore
+        field_name: str = field.name  # pyright: ignore
+        result[field_name] = field  # pyright: ignore
+    return result  # pyright: ignore
+
+
+def to_field_descriptor_proto(  # pyright: ignore
+    field: descriptor.FieldDescriptor,
+) -> descriptor_pb2.FieldDescriptorProto:  # pyright: ignore
+    """Converts `FieldDescriptor` to `FieldDescriptorProto`."""
+    field_name: str = field.name
+    containing_message: descriptor.Descriptor = field.containing_type
+    field_proto = message_fields_map(containing_message).get(field_name)  # pyright: ignore
+    assert field_proto, f'Field "{field_name}" of descriptors.Descriptor is missing in descriptor_pb2.DescriptorProto'
+    return field_proto  # pyright: ignore
diff --git a/scripts/proto_structs/descriptors/node_parsers.py b/scripts/proto_structs/descriptors/node_parsers.py
new file mode 100644
index 000000000000..10e4ee85065b
--- /dev/null
+++ b/scripts/proto_structs/descriptors/node_parsers.py
@@ -0,0 +1,363 @@
+"""Parsers from Protobuf descriptors to CodegenNode."""
+
+# Documentation on Protobuf descriptors:
+# https://googleapis.dev/python/protobuf/latest/google/protobuf/descriptor.html
+
+import pathlib
+import re
+import typing
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Mapping
+from typing import MutableSet
+from typing import Optional
+from typing import Union
+
+import google.protobuf.descriptor as descriptor
+
+from proto_structs.descriptors import option_parsers
+from proto_structs.descriptors import type_mapping
+from proto_structs.models import forward_decls
+from proto_structs.models import gen_node
+from proto_structs.models import io
+from proto_structs.models import names
+from proto_structs.models import options
+from proto_structs.models import sort_dependencies
+from proto_structs.models import type_ref
+from proto_structs.models import type_ref_consts
+from proto_structs.models import vanilla
+
+TypeDescriptor = Union[descriptor.Descriptor, descriptor.EnumDescriptor]
+
+
+def parse_file(file: descriptor.FileDescriptor, *, plugin_options: options.PluginOptions) -> gen_node.File:
+    types: List[gen_node.TypeNode] = []
+    for enum in typing.cast(Dict[str, descriptor.EnumDescriptor], file.enum_types_by_name).values():
+        types.append(parse_enum(enum))
+    for message in typing.cast(Dict[str, descriptor.Descriptor], file.message_types_by_name).values():
+        if message_type := parse_message(message, plugin_options=plugin_options):
+            types.append(message_type)
+
+    types = sort_dependencies.sort_types_topologically(types)
+
+    vanilla_namespace = gen_node.NamespaceNode.make_for_vanilla(
+        typing.cast(str, file.package),
+        children=vanilla.collect_vanilla_types(types=types),
+    )
+    structs_namespace = gen_node.NamespaceNode.make_for_structs(
+        typing.cast(str, file.package),
+        children=types,
+    )
+
+    forward_decls.add_forward_declarations((structs_namespace,))
+
+    return gen_node.File(
+        proto_relative_path=pathlib.Path(typing.cast(str, file.name)),
+        children=[vanilla_namespace, structs_namespace],
+    )
+
+
+def parse_enum(enum: descriptor.EnumDescriptor) -> gen_node.EnumNode:
+    proto_file_descriptor: descriptor.FileDescriptor = enum.file
+    proto_file_name: str = proto_file_descriptor.name
+    values: List[gen_node.EnumValue] = []
+    for value in typing.cast(List[descriptor.EnumValueDescriptor], enum.values):
+        values.append(parse_enum_value(value))
+    return gen_node.EnumNode(
+        vanilla_name=type_mapping.parse_type_name(enum), proto_file=pathlib.Path(proto_file_name), values=values
+    )
+
+
+def parse_enum_value(value: descriptor.EnumValueDescriptor) -> gen_node.EnumValue:
+    enum_value_name = typing.cast(str, value.name)
+    enum_descriptor = typing.cast(descriptor.EnumDescriptor, value.type)
+    enum_name = typing.cast(str, enum_descriptor.name)
+
+    return gen_node.EnumValue(
+        short_name=names.escape_id(_format_enum_value_name(enum_value_name, enum_name=enum_name)),
+        number=typing.cast(int, value.number),
+    )
+
+
+def _format_enum_value_name(value_name: str, *, enum_name: str) -> str:
+    name = _cut_enum_value_name(value_name, enum_name=enum_name)
+    return f'k{names.to_pascal_case(name, to_lower=True)}'
+
+
+def _cut_enum_value_name(value_name: str, *, enum_name: str) -> str:
+    if value_name.startswith(upper_enum_name := names.to_upper_case(enum_name)):
+        # ENUM_NAME_VALUE_NAME -> VALUE_NAME
+        cut_name = value_name[len(upper_enum_name) :].removeprefix('_')
+        if names.is_valid_id(cut_name):
+            return cut_name
+    return value_name
+
+
+def parse_message(
+    message: descriptor.Descriptor, *, plugin_options: options.PluginOptions
+) -> Optional[gen_node.TypeNode]:
+    if _is_map_entry(message):
+        return None
+
+    vanilla_type_name = type_mapping.parse_type_name(message)
+    proto_file_descriptor: descriptor.FileDescriptor = message.file
+    proto_file_name: str = proto_file_descriptor.name
+
+    taken_member_names = _collect_taken_member_names(message)
+
+    nested_types: List[gen_node.TypeNode] = []
+    for nested_enum in typing.cast(List[descriptor.EnumDescriptor], message.enum_types):
+        nested_types.append(parse_enum(nested_enum))
+    for nested_message in typing.cast(List[descriptor.Descriptor], message.nested_types):
+        if message_type := parse_message(nested_message, plugin_options=plugin_options):
+            nested_types.append(message_type)
+
+    nested_types = sort_dependencies.sort_types_topologically(nested_types)
+
+    fields: List[gen_node.StructField] = []
+
+    for field in typing.cast(List[descriptor.FieldDescriptor], message.fields):
+        if oneof := typing.cast(Optional[descriptor.OneofDescriptor], field.containing_oneof):
+            if not _is_synthetic_oneof(oneof):
+                oneof_fields = typing.cast(List[descriptor.FieldDescriptor], oneof.fields)
+                assert len(oneof_fields) >= 1
+                if oneof_fields[0] is field:
+                    fields.append(
+                        parse_oneof(
+                            oneof,
+                            taken_member_names=taken_member_names,
+                            nested_types_to_generate=nested_types,
+                            plugin_options=plugin_options,
+                        )
+                    )
+                continue
+        fields.append(parse_field(field, plugin_options=plugin_options))
+
+    nested_types = sort_dependencies.sort_types_topologically(nested_types)
+
+    result = gen_node.StructNode(
+        vanilla_name=vanilla_type_name,
+        proto_file=pathlib.Path(proto_file_name),
+        nested_types=nested_types,
+        fields=fields,
+    )
+    if result_enum := _try_transform_enum_wrapper(result):
+        return result_enum
+
+    return result
+
+
+_SYNTHETIC_ONEOF_NAME_REGEX = re.compile(r'X*_\w*')
+
+
+def _io_kind_read(field: descriptor.FieldDescriptor) -> io.ReadVanillaFieldKind:
+    if typing.cast(int, field.label) == descriptor.FieldDescriptor.LABEL_OPTIONAL:
+        if typing.cast(bool, field.has_presence):
+            return io.ReadVanillaFieldKind.OPTIONAL
+
+    return io.ReadVanillaFieldKind.OTHER
+
+
+def _io_kind_write(field: descriptor.FieldDescriptor) -> io.WriteVanillaFieldKind:
+    type_kind: int = field.type
+    label = typing.cast(int, field.label)
+
+    # Check repeated firstly. Also handle a repeated map entry.
+    if label == descriptor.FieldDescriptor.LABEL_REPEATED:
+        return io.WriteVanillaFieldKind.VECTOR_MAP_MESSAGE
+
+    if type_kind == descriptor.FieldDescriptor.TYPE_STRING or type_kind == descriptor.FieldDescriptor.TYPE_BYTES:
+        return io.WriteVanillaFieldKind.STRING
+
+    if type_mapping.BUILTIN_TYPES.get(type_kind) is not None or type_kind == descriptor.FieldDescriptor.TYPE_ENUM:
+        return io.WriteVanillaFieldKind.OTHER
+
+    if type_kind == descriptor.FieldDescriptor.TYPE_MESSAGE or type_kind == descriptor.FieldDescriptor.TYPE_GROUP:
+        return io.WriteVanillaFieldKind.VECTOR_MAP_MESSAGE
+
+    raise Exception('unreachable')
+
+
+def _io_kind_by_field(field: descriptor.FieldDescriptor) -> io.IoKind:
+    return io.IoKind(read=_io_kind_read(field), write=_io_kind_write(field))
+
+
+def _io_kind_oneof() -> io.IoKind:
+    return io.IoKind(read=io.ReadVanillaFieldKind.ONEOF, write=io.WriteVanillaFieldKind.ONEOF)
+
+
+def _apply_options_to_field(
+    field: descriptor.FieldDescriptor, struct_field: gen_node.StructField, *, plugin_options: options.PluginOptions
+) -> gen_node.StructField:
+    message_type = _get_optional_message_type(field)
+    if message_type:
+        message_options = option_parsers.parse_message(message_type, plugin_options)
+    else:
+        message_options = None
+
+    field_options = option_parsers.parse_field(field, plugin_options)
+
+    should_box = field_options.indirect or (message_options and message_options.indirect)
+    if should_box:
+        gen_node.wrap_field_in_box(struct_field)
+
+    return struct_field
+
+
+def _is_synthetic_oneof(oneof: descriptor.OneofDescriptor) -> bool:
+    # https://protobuf.com/docs/descriptors#synthetic-oneofs
+    oneof_fields = typing.cast(List[descriptor.FieldDescriptor], oneof.fields)
+    if len(oneof_fields) != 1:
+        return False
+
+    oneof_name = typing.cast(str, oneof.name)
+
+    return _SYNTHETIC_ONEOF_NAME_REGEX.fullmatch(oneof_name) is not None
+
+
+def _try_transform_enum_wrapper(struct: gen_node.StructNode) -> Optional[gen_node.EnumNode]:
+    # FooBarEnum { enum FooBar { ... } } -> FooBarEnum
+    if len(struct.fields) != 0:
+        return None
+
+    if len(struct.nested_types) != 1:
+        return None
+    nested_type = struct.nested_types[0]
+
+    if not isinstance(nested_type, gen_node.EnumNode):
+        return None
+
+    if struct.name.short_name != f'{nested_type.name.short_name}Enum':
+        return None
+    return gen_node.EnumNode(vanilla_name=struct.vanilla_name, proto_file=struct.proto_file, values=nested_type.values)
+
+
+def _is_map_entry(message: descriptor.Descriptor) -> bool:
+    # https://protobuf.com/docs/descriptors#map-fields
+    options: Any = message.GetOptions()
+    is_map_entry: bool = getattr(options, 'map_entry', False)
+    return is_map_entry
+
+
+def parse_field(
+    field: descriptor.FieldDescriptor,
+    *,
+    plugin_options: options.PluginOptions,
+    ignore_label: bool = False,
+) -> gen_node.StructField:
+    if map_field_type := _try_parse_map_field_type(field):
+        parsed_type = map_field_type
+        initializer = ''
+    else:
+        parsed_type = type_mapping.parse_type_reference(field)
+        parsed_type = type_mapping.replace_well_known_types(parsed_type)
+        initializer = '' if isinstance(parsed_type, type_ref.UserverCodegenType) else '{}'
+        if not ignore_label:
+            parsed_type = type_mapping.handle_type_label(field, parsed_type)
+
+    result_field = gen_node.StructField(
+        short_name=names.escape_id(typing.cast(str, field.name)),
+        field_type=parsed_type,
+        initializer=initializer,
+        number=typing.cast(int, field.number),
+        oneof_fields=None,
+        io_kinds=_io_kind_by_field(field),
+    )
+    return _apply_options_to_field(field, result_field, plugin_options=plugin_options)
+
+
+def _try_parse_map_field_type(field: descriptor.FieldDescriptor) -> Optional[type_ref.TypeReference]:
+    # https://protobuf.com/docs/descriptors#map-fields
+    if typing.cast(int, field.type) != descriptor.FieldDescriptor.TYPE_MESSAGE:
+        return None
+    message_type = typing.cast(descriptor.Descriptor, field.message_type)
+    if not _is_map_entry(message_type):
+        return None
+
+    fields_by_name = typing.cast(Mapping[str, descriptor.FieldDescriptor], message_type.fields_by_name)
+    key_type = type_mapping.parse_type_reference(fields_by_name['key'])
+    value_type = type_mapping.parse_type_reference(fields_by_name['value'])
+
+    return type_ref_consts.make_hash_map(key_type, value_type)
+
+
+def parse_oneof(
+    oneof: descriptor.OneofDescriptor,
+    taken_member_names: MutableSet[str],
+    nested_types_to_generate: List[gen_node.TypeNode],
+    plugin_options: options.PluginOptions,
+) -> gen_node.StructField:
+    oneof_options = option_parsers.parse_oneof(oneof, plugin_options)
+
+    fields: List[gen_node.StructField] = []
+
+    for field in typing.cast(List[descriptor.FieldDescriptor], oneof.fields):
+        assert typing.cast(int, field.label) == descriptor.FieldDescriptor.LABEL_OPTIONAL
+        fields.append(parse_field(field, plugin_options=plugin_options, ignore_label=True))
+
+    containing_type_descriptor = typing.cast(descriptor.Descriptor, oneof.containing_type)
+    containing_type_name = names.make_structs_type_name(type_mapping.parse_type_name(containing_type_descriptor))
+
+    oneof_field_short_name = names.escape_id(typing.cast(str, oneof.name))
+    oneof_type_short_name = oneof_options.generated_type_name or _synthesize_oneof_type_name(
+        oneof_field_short_name, taken_member_names
+    )
+
+    oneof_type_name = names.make_nested_type_name(containing_type_name, oneof_type_short_name)
+
+    oneof_node = gen_node.OneofNode(name=oneof_type_name, fields=fields)
+    nested_types_to_generate.append(oneof_node)
+
+    type_reference = type_ref.UserverCodegenType(
+        name=oneof_type_name,
+        proto_file=type_mapping.parse_file_path(containing_type_descriptor),
+    )
+
+    return gen_node.StructField(
+        short_name=oneof_field_short_name,
+        field_type=type_reference,
+        initializer='',
+        number=None,
+        oneof_fields=fields,
+        io_kinds=_io_kind_oneof(),
+    )
+
+
+def _synthesize_oneof_type_name(oneof_field_short_name: str, taken_member_names: MutableSet[str]) -> str:
+    if oneof_field_short_name[0].isupper():
+        oneof_type_short_name = f'T{names.to_pascal_case(oneof_field_short_name)}'
+    else:
+        oneof_type_short_name = names.to_pascal_case(oneof_field_short_name)
+    return _make_unique_member_name(oneof_type_short_name, taken_member_names)
+
+
+def _collect_taken_member_names(message: descriptor.Descriptor) -> MutableSet[str]:
+    result: MutableSet[str] = set()
+    result.add(typing.cast(str, message.name))
+    for nested_type in typing.cast(List[descriptor.Descriptor], message.nested_types):
+        result.add(typing.cast(str, nested_type.name))
+    for enum_type in typing.cast(List[descriptor.Descriptor], message.enum_types):
+        result.add(typing.cast(str, enum_type.name))
+    for neighbour_field in typing.cast(List[descriptor.FieldDescriptor], message.fields):
+        result.add(typing.cast(str, neighbour_field.name))
+    for oneof in typing.cast(List[descriptor.OneofDescriptor], message.oneofs):
+        result.add(typing.cast(str, oneof.name))
+    return result
+
+
+def _make_unique_member_name(base_name: str, taken_member_names: MutableSet[str]) -> str:
+    while base_name in taken_member_names:
+        base_name = f'X{base_name}'
+    taken_member_names.add(base_name)
+    return base_name
+
+
+def _get_optional_message_type(field: descriptor.FieldDescriptor) -> Optional[descriptor.Descriptor]:
+    type_kind: int = field.type
+    if type_kind == descriptor.FieldDescriptor.TYPE_MESSAGE or type_kind == descriptor.FieldDescriptor.TYPE_GROUP:
+        # Details on groups:
+        # https://protobuf.com/docs/descriptors#groups
+        message_type: descriptor.Descriptor = field.message_type
+        return message_type
+    return None
diff --git a/scripts/proto_structs/descriptors/option_parsers.py b/scripts/proto_structs/descriptors/option_parsers.py
new file mode 100644
index 000000000000..951024c2bc83
--- /dev/null
+++ b/scripts/proto_structs/descriptors/option_parsers.py
@@ -0,0 +1,91 @@
+"""Parsers from Protobuf descriptor options to `models/options.py`."""
+
+# Documentation on Protobuf descriptors and extensions:
+# https://googleapis.dev/python/protobuf/latest/google/protobuf/descriptor.html
+# https://googleapis.dev/python/protobuf/latest/google/protobuf/message.html
+
+import typing
+from typing import Any
+from typing import Callable
+from typing import Mapping
+from typing import Type
+from typing import TypeVar
+
+import google.protobuf.descriptor as descriptor_module
+import google.protobuf.message as message_module
+from userver.structs import annotations_pb2  # pyright: ignore
+
+from proto_structs.models import options
+
+
+def parse_file(file: descriptor_module.FileDescriptor, /, defaults: options.PluginOptions) -> options.FileOptions:
+    """Parses file options from descriptor, merging with options manually passed to this protoc plugin."""
+    return options.FileOptions()
+
+
+def parse_message(message: descriptor_module.Descriptor, /, defaults: options.PluginOptions) -> options.MessageOptions:
+    """Parses message options from descriptor, merging with options manually passed to this protoc plugin."""
+    options_raw = _get_option(message, annotations_pb2.message, annotations_pb2.MessageAnnotations)  # pyright: ignore
+
+    indirect_raw = typing.cast(bool, options_raw.indirect)
+    # Add new options here.
+
+    message_full_name: str = message.full_name
+    message_defaults = defaults.message_options.get(message_full_name, options.MessageOptions())
+
+    return options.MessageOptions(
+        indirect=indirect_raw or message_defaults.indirect,
+        # Add new options here.
+    )
+
+
+def parse_oneof(oneof: descriptor_module.OneofDescriptor, /, defaults: options.PluginOptions) -> options.OneofOptions:
+    """Parses oneof options from descriptor, merging with options manually passed to this protoc plugin."""
+    options_raw = _get_option(oneof, annotations_pb2.oneof, annotations_pb2.OneofAnnotations)  # pyright: ignore
+
+    generated_type_name_raw = typing.cast(str, options_raw.generated_type_name)
+    # Add new options here.
+
+    oneof_full_name: str = oneof.full_name
+    oneof_defaults = defaults.oneof_options.get(oneof_full_name, options.OneofOptions())
+
+    return options.OneofOptions(
+        generated_type_name=generated_type_name_raw or oneof_defaults.generated_type_name,
+        # Add new options here.
+    )
+
+
+def parse_field(field: descriptor_module.FieldDescriptor, /, defaults: options.PluginOptions) -> options.FieldOptions:
+    """Parses field options from descriptor, merging with options manually passed to this protoc plugin."""
+    options_raw = _get_option(field, annotations_pb2.field, annotations_pb2.FieldAnnotations)  # pyright: ignore
+
+    indirect_raw = typing.cast(bool, options_raw.indirect)  # pyright: ignore
+    # Add new options here.
+
+    field_full_name: str = field.full_name
+    field_defaults = defaults.field_options.get(field_full_name, options.FieldOptions())
+
+    return options.FieldOptions(
+        indirect=indirect_raw or field_defaults.indirect,
+        # Add new options here.
+    )
+
+
+TExtension = TypeVar('TExtension', bound=message_module.Message)
+
+
+def _get_option(
+    any_descriptor: descriptor_module.DescriptorBase,
+    /,
+    extension_handle: Any,
+    extension_type: Type[TExtension],
+) -> TExtension:
+    options_message = typing.cast(message_module.Message, any_descriptor.GetOptions())
+    has_extension_func = typing.cast(Callable[[Any], bool], options_message.HasExtension)
+    has_extension = has_extension_func(extension_handle)
+    if has_extension:
+        extensions: Mapping[Any, Any] = getattr(options_message, 'Extensions')
+        extension: TExtension = extensions[extension_handle]
+        return extension
+    else:
+        return extension_type()
diff --git a/scripts/proto_structs/descriptors/type_mapping.py b/scripts/proto_structs/descriptors/type_mapping.py
new file mode 100644
index 000000000000..8af57411e161
--- /dev/null
+++ b/scripts/proto_structs/descriptors/type_mapping.py
@@ -0,0 +1,144 @@
+"""Parsers from Protobuf descriptors to TypeReference."""
+
+# Documentation on Protobuf descriptors:
+# https://googleapis.dev/python/protobuf/latest/google/protobuf/descriptor.html
+
+from collections.abc import Sequence
+import pathlib
+import typing
+from typing import List
+from typing import Mapping
+from typing import Optional
+from typing import Union
+
+import google.protobuf.descriptor as descriptor
+
+from proto_structs.descriptors import descriptor_proto
+from proto_structs.models import names
+from proto_structs.models import type_ref
+from proto_structs.models import type_ref_consts
+
+TypeDescriptor = Union[descriptor.Descriptor, descriptor.EnumDescriptor]
+
+
+BUILTIN_TYPES: Mapping[int, type_ref.TypeReference] = {
+    descriptor.FieldDescriptor.TYPE_BOOL: type_ref.KeywordType(full_cpp_name='bool'),
+    descriptor.FieldDescriptor.TYPE_FLOAT: type_ref.KeywordType(full_cpp_name='float'),
+    descriptor.FieldDescriptor.TYPE_DOUBLE: type_ref.KeywordType(full_cpp_name='double'),
+    descriptor.FieldDescriptor.TYPE_STRING: type_ref.BuiltinType(full_cpp_name='std::string'),
+    descriptor.FieldDescriptor.TYPE_BYTES: type_ref.BuiltinType(full_cpp_name='std::string'),
+    descriptor.FieldDescriptor.TYPE_INT32: type_ref.BuiltinType(full_cpp_name='std::int32_t'),
+    descriptor.FieldDescriptor.TYPE_INT64: type_ref.BuiltinType(full_cpp_name='std::int64_t'),
+    descriptor.FieldDescriptor.TYPE_UINT32: type_ref.BuiltinType(full_cpp_name='std::uint32_t'),
+    descriptor.FieldDescriptor.TYPE_UINT64: type_ref.BuiltinType(full_cpp_name='std::uint64_t'),
+    descriptor.FieldDescriptor.TYPE_SINT32: type_ref.BuiltinType(full_cpp_name='std::int32_t'),
+    descriptor.FieldDescriptor.TYPE_SINT64: type_ref.BuiltinType(full_cpp_name='std::int64_t'),
+    descriptor.FieldDescriptor.TYPE_FIXED32: type_ref.BuiltinType(full_cpp_name='std::uint32_t'),
+    descriptor.FieldDescriptor.TYPE_FIXED64: type_ref.BuiltinType(full_cpp_name='std::uint64_t'),
+    descriptor.FieldDescriptor.TYPE_SFIXED32: type_ref.BuiltinType(full_cpp_name='std::int32_t'),
+    descriptor.FieldDescriptor.TYPE_SFIXED64: type_ref.BuiltinType(full_cpp_name='std::int64_t'),
+}
+
+
+def parse_enum_reference(field_type: descriptor.EnumDescriptor) -> type_ref.TypeReference:
+    return type_ref.UserverCodegenType(
+        name=names.make_structs_type_name(vanilla_type_name=parse_type_name(field_type)),
+        proto_file=parse_file_path(field_type),
+    )
+
+
+def parse_struct_reference(field_type: descriptor.Descriptor) -> type_ref.TypeReference:
+    return type_ref.UserverCodegenType(
+        name=names.make_structs_type_name(vanilla_type_name=parse_type_name(field_type)),
+        proto_file=parse_file_path(field_type),
+    )
+
+
+def parse_type_reference(field: descriptor.FieldDescriptor) -> type_ref.TypeReference:
+    """Parses `field` type, not applying any wrappings or replacements yet."""
+    type_kind = typing.cast(int, field.type)
+    if builtin_type := BUILTIN_TYPES.get(type_kind):
+        return builtin_type
+
+    if type_kind == descriptor.FieldDescriptor.TYPE_ENUM:
+        enum_type = typing.cast(descriptor.EnumDescriptor, field.enum_type)
+        return parse_enum_reference(enum_type)
+
+    if type_kind == descriptor.FieldDescriptor.TYPE_MESSAGE or type_kind == descriptor.FieldDescriptor.TYPE_GROUP:
+        # Details on groups:
+        # https://protobuf.com/docs/descriptors#groups
+        message_type = typing.cast(descriptor.Descriptor, field.message_type)
+        return parse_struct_reference(message_type)
+
+    raise RuntimeError(f'Invalid field type kind: {type_kind}')
+
+
+def handle_type_label(
+    field: descriptor.FieldDescriptor,
+    parsed_type: type_ref.TypeReference,
+) -> type_ref.TypeReference:
+    """Applies `optional` and `repeated` labels to the parsed type."""
+    label = typing.cast(int, field.label)
+    # Message fields are serialized as a sequence of (field number, field value). Some fields may be omitted.
+    # * `LABEL_REQUIRED` only exists in proto2. It means that the field is always serialized.
+    # * In proto3, all fields except `repeated` are `LABEL_OPTIONAL`, meaning that default value
+    #   (not present or default-initialized) is not present in the serialized binary form at all.
+    if label == descriptor.FieldDescriptor.LABEL_OPTIONAL:
+        if _should_wrap_in_optional(field):
+            return type_ref_consts.make_optional(parsed_type)
+        else:
+            return parsed_type
+    if label == descriptor.FieldDescriptor.LABEL_REQUIRED:
+        return parsed_type
+    if label == descriptor.FieldDescriptor.LABEL_REPEATED:
+        return type_ref_consts.make_vector(parsed_type)
+    raise RuntimeError(f'Unknown type label {label}')
+
+
+def _should_wrap_in_optional(field: descriptor.FieldDescriptor) -> bool:
+    """
+    Policy:
+    * Primitive fields are wrapped in `std::optional` iff `has_presence`.
+    * Message-typed fields are wrapped in `std::optional` iff defined using an explicit `optional` keyword.
+    """
+    field_kind: int = field.type
+    if field_kind == descriptor.FieldDescriptor.TYPE_MESSAGE or field_kind == descriptor.FieldDescriptor.TYPE_GROUP:
+        field_proto = descriptor_proto.to_field_descriptor_proto(field)  # pyright: ignore
+        # `proto3_optional` checks whether the field is defined in the `.proto` file using `optional` keyword.
+        # Note that message-typed fields are always `has_presence == true`, and `optional` keyword does not affect it.
+        # https://github.com/protocolbuffers/protobuf/blob/v22.0/src/google/protobuf/descriptor.proto#L240
+        has_optional_keyword = typing.cast(bool, field_proto.proto3_optional)  # pyright: ignore
+        return has_optional_keyword
+    else:
+        # `has_presence` is the proper flag to check `std::optional`-ity in proto3.
+        # If `true`, then the field distinguishes unpopulated and default values.
+        has_presence = typing.cast(bool, field.has_presence)
+        return has_presence
+
+
+def replace_well_known_types(parsed_type: type_ref.TypeReference) -> type_ref.TypeReference:
+    """Replaces `parsed_type` according to options and built-in notions of well-known types."""
+    # TODO(TAXICOMMON-10999): support well-known types
+    return parsed_type
+
+
+def parse_type_name(proto_type: TypeDescriptor) -> names.TypeName:
+    return names.make_escaped_type_name(
+        package=typing.cast(str, proto_type.file.package),
+        outer_type_names=_get_outer_structs_names(proto_type),
+        short_name=typing.cast(str, proto_type.name),
+    )
+
+
+def _get_outer_structs_names(proto_type: TypeDescriptor) -> Sequence[str]:
+    names_list: List[str] = []
+    parent_type = proto_type
+    while parent_type := typing.cast(Optional[descriptor.Descriptor], parent_type.containing_type):
+        names_list.append(typing.cast(str, parent_type.name))
+    return list(reversed(names_list))
+
+
+def parse_file_path(proto_type: TypeDescriptor) -> pathlib.Path:
+    file = typing.cast(descriptor.FileDescriptor, proto_type.file)
+    file_name = typing.cast(str, file.name)
+    return pathlib.Path(file_name)
diff --git a/scripts/proto_structs/generator.py b/scripts/proto_structs/generator.py
index a35af05d11fd..c8b6b497aa11 100755
--- a/scripts/proto_structs/generator.py
+++ b/scripts/proto_structs/generator.py
@@ -1,106 +1,140 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-"""
-What am I? Bro, you have to add description.
-"""
+"""The core of the proto structs generation."""
 
-import os
+import json
+import pathlib
 import sys
+import typing
 from typing import Any
 from typing import Dict
+from typing import List
 from typing import Optional
 
+from google.protobuf import descriptor
+from google.protobuf import descriptor_pool
 from google.protobuf.compiler import plugin_pb2  # pyright: ignore
-import google.protobuf.descriptor_pb2 as descriptor_pb2  # pyright: ignore
 import jinja2
+import pydantic
 
+from proto_structs.descriptors import node_parsers
+from proto_structs.models import gen_node
+from proto_structs.models import includes
+from proto_structs.models import options
+from proto_structs.models import type_ref_consts
 
-def strip_ext(path: str) -> str:
+
+def _strip_ext(path: str) -> str:
     return path.removesuffix('.proto')
 
 
+class Params(pydantic.BaseModel, extra='forbid'):
+    """
+    protoc allows to pass a single string option to a plugin (`--uproto-structs_opt`).
+    The option must contain JSON described by this model.
+    """
+
+    #: Absolute path to the file with the JSON containing detailed options, see `models/options.py`.
+    opts_file: Optional[pydantic.FilePath] = None
+
+
 class _CodeGenerator:
     def __init__(
         self,
-        proto_file: descriptor_pb2.FileDescriptorProto,
-        response: plugin_pb2.CodeGeneratorResponse,
+        file_descriptor: descriptor.FileDescriptor,
         jinja_env: jinja2.Environment,
+        plugin_options: options.PluginOptions,
+        response: plugin_pb2.CodeGeneratorResponse,  # pyright: ignore
     ) -> None:
-        self.proto_file = proto_file
-        self.response = response
+        self.file_descriptor = file_descriptor
         self.jinja_env = jinja_env
+        self.plugin_options = plugin_options
+        self.response = response  # pyright: ignore
 
     def run(self) -> None:
-        self._generate_code()
-
-    @property
-    def _proto_file_stem(self) -> str:
-        return self.proto_file.name.replace('.proto', '')
-
-    def _generate_code(self) -> None:
-        data: Dict[str, Any] = {
-            'name_wo_ext': strip_ext(self.proto_file.name),
-            'dependency': list(map(strip_ext, self.proto_file.dependency)),
+        try:
+            file_node = node_parsers.parse_file(self.file_descriptor, plugin_options=self.plugin_options)
+            data = self._make_jinja_data(file_node)
+
+            for file_ext in ['cpp', 'hpp']:
+                template_name = f'structs.usrv.{file_ext}.jinja'
+                template = self.jinja_env.get_template(template_name)
+
+                file_name = str(file_node.gen_path(ext=file_ext))
+                file_content = template.render(**data)
+
+                file = self.response.file.add()  # pyright: ignore
+                file.name = file_name  # pyright: ignore
+                file.content = file_content  # pyright: ignore
+        except Exception:
+            raise Exception(
+                f'userver proto structs codegen failed for file: {self.file_descriptor.name} '
+                '(see details in the exception above)'
+            )
+
+    @staticmethod
+    def _make_jinja_data(file_node: gen_node.File) -> Dict[str, Any]:
+        includes_dict = includes.sorted_includes(file_node, current_hpp=str(file_node.gen_path(ext='hpp')))
+
+        return {
+            'file_name_wo_ext': _strip_ext(str(file_node.proto_relative_path)),
+            'file': file_node,
+            'includes_hpp': includes_dict[includes.IncludeKind.FOR_HPP],
+            'includes_cpp': includes_dict[includes.IncludeKind.FOR_CPP],
+            'type_ref_consts': type_ref_consts,
         }
 
-        for file_ext in ['cpp', 'hpp']:
-            template_name = f'structs.usrv.{file_ext}.jinja'
-            template = self.jinja_env.get_template(template_name)
-
-            file = self.response.file.add()
-            file.name = f'{self._proto_file_stem}.structs.usrv.pb.{file_ext}'
-            file.content = template.render(**data)
 
-
-def generate(
-    loader: jinja2.BaseLoader,
-) -> None:
+def generate(loader: jinja2.BaseLoader) -> None:
     data = sys.stdin.buffer.read()
 
-    request = plugin_pb2.CodeGeneratorRequest()
-    request.ParseFromString(data)
+    request = plugin_pb2.CodeGeneratorRequest()  # pyright: ignore
+    request.ParseFromString(data)  # pyright: ignore
+
+    params = Params(**json.loads(request.parameter)) if request.parameter else Params()  # pyright: ignore
+    plugin_options = options.load_plugin_options(params.opts_file)
 
-    response = plugin_pb2.CodeGeneratorResponse()
-    if hasattr(response, 'FEATURE_PROTO3_OPTIONAL'):
+    response = plugin_pb2.CodeGeneratorResponse()  # pyright: ignore
+    if hasattr(response, 'FEATURE_PROTO3_OPTIONAL'):  # pyright: ignore
         setattr(
-            response,
+            response,  # pyright: ignore
             'supported_features',
-            getattr(response, 'FEATURE_PROTO3_OPTIONAL'),
+            getattr(response, 'FEATURE_PROTO3_OPTIONAL'),  # pyright: ignore
         )
 
     jinja_env = jinja2.Environment(
         loader=loader,
         trim_blocks=True,
         lstrip_blocks=True,
-        # We do not render HTML pages with Jinja. However the gRPC data could
-        # be shown on web. Assuming that the generation should not deal with
-        # HTML special characters, it is safer to turn on autoescaping.
-        autoescape=True,
+        # Do not escape C++ sources for HTML.
+        autoescape=False,
     )
 
+    pool = descriptor_pool.DescriptorPool()
+
+    files: List[str] = []
     # pylint: disable=no-member
-    for proto_file in request.proto_file:
+    for proto_file in request.proto_file:  # pyright: ignore
+        pool.Add(proto_file)  # pyright: ignore
+        name: str = typing.cast(str, proto_file.name)
+        files.append(name)
+
+    # pylint: disable=no-member
+    for file_to_generate in request.file_to_generate:  # pyright: ignore
         _CodeGenerator(
+            file_descriptor=pool.FindFileByName(file_to_generate),  # pyright: ignore
             jinja_env=jinja_env,
-            proto_file=proto_file,
-            response=response,
+            plugin_options=plugin_options,
+            response=response,  # pyright: ignore
         ).run()
 
-    output = response.SerializeToString()
-    sys.stdout.buffer.write(output)
+    sys.stdout.buffer.write(response.SerializeToString())  # pyright: ignore
 
 
-def main(
-    loader: Optional[jinja2.BaseLoader] = None,
-) -> None:
+def main(loader: Optional[jinja2.BaseLoader] = None) -> None:
     if loader is None:
-        loader = jinja2.FileSystemLoader(
-            os.path.join(
-                os.path.dirname(os.path.abspath(__file__)),
-                'templates',
-            ),
-        )
+        loader = jinja2.FileSystemLoader(pathlib.Path(__file__).resolve().parent / 'templates')
 
     generate(
         loader=loader,
diff --git a/scripts/proto_structs/models/__init__.py b/scripts/proto_structs/models/__init__.py
new file mode 100644
index 000000000000..d7a1d8fc92d3
--- /dev/null
+++ b/scripts/proto_structs/models/__init__.py
@@ -0,0 +1 @@
+"""Backend models of C++ entities and helpers for jinja templates."""
diff --git a/scripts/proto_structs/models/forward_decls.py b/scripts/proto_structs/models/forward_decls.py
new file mode 100644
index 000000000000..855f4b75dfda
--- /dev/null
+++ b/scripts/proto_structs/models/forward_decls.py
@@ -0,0 +1,48 @@
+"""Adds forward declarations for types where needed."""
+
+from collections.abc import Sequence
+from typing import Dict
+
+from proto_structs.models import gen_node
+from proto_structs.models import type_ref
+
+
+def add_forward_declarations(root_nodes: Sequence[gen_node.CodegenNode]) -> None:
+    """
+    Set `should_forward_declare` on `TypeNode`s where it is needed to refer to a type defined later.
+    `root_nodes` should already be topologically sorted, recursively, so the order should be as in the generated file.
+    """
+    resolver = _ForwardDeclarationsResolver(root_nodes)
+    resolver.run()
+
+
+class _ForwardDeclarationsResolver:
+    def __init__(self, root_nodes: Sequence[gen_node.CodegenNode]) -> None:
+        self._root_nodes = root_nodes
+        self._types_by_names: Dict[str, gen_node.TypeNode] = {
+            child.full_cpp_name(): child for node in root_nodes for child in gen_node.iter_type_nodes(node)
+        }
+        # As we walk through nodes, recursively, in the order of their definition, we will mark them as defined.
+        self._is_type_defined_so_far: Dict[gen_node.TypeNode, bool] = {
+            child: False for node in root_nodes for child in gen_node.iter_type_nodes(node)
+        }
+
+    def _do_run(self, node: gen_node.CodegenNode) -> None:
+        for child in node.children:
+            self._do_run(child)
+        # The intent is to visit "own" type dependencies of `node` without its children,
+        # but recursive visit is also OK, because all children are marked as defined at this point.
+        for dep in node.type_dependencies():
+            if dep_node := self._types_by_names.get(dep.type_reference.full_cpp_name()):
+                if not self._is_type_defined_so_far[dep_node]:
+                    assert dep.kind == type_ref.TypeDependencyKind.WEAK, (
+                        '`nodes` should be topologically sorted, recursively, '
+                        'before passing them to `add_forward_declarations`.'
+                    )
+                    dep_node.should_forward_declare = True
+        if isinstance(node, gen_node.TypeNode):
+            self._is_type_defined_so_far[node] = True
+
+    def run(self) -> None:
+        for node in self._root_nodes:
+            self._do_run(node)
diff --git a/scripts/proto_structs/models/gen_node.py b/scripts/proto_structs/models/gen_node.py
new file mode 100644
index 000000000000..b9b7f90712b0
--- /dev/null
+++ b/scripts/proto_structs/models/gen_node.py
@@ -0,0 +1,411 @@
+"""Models for definitions of C++ entities."""
+
+from __future__ import annotations
+
+import abc
+from collections.abc import Iterable
+from collections.abc import Sequence
+import dataclasses
+import pathlib
+from typing import Final
+from typing import final
+from typing import Optional
+
+from typing_extensions import override
+
+from proto_structs.models import includes
+from proto_structs.models import io
+from proto_structs.models import names
+from proto_structs.models import reserved_identifiers
+from proto_structs.models import type_ref
+from proto_structs.models import type_ref_consts
+
+
+class CodegenNode(names.HasCppNameImpl, includes.HasCppIncludes, type_ref.HasTypeDependencies, abc.ABC):
+    """A C++ entity definition that should be generated. Introduces the concept of child nodes."""
+
+    @property
+    @abc.abstractmethod
+    def kind(self) -> str:
+        """A short string representing the kind of this node for the jinja template."""
+        raise NotImplementedError()
+
+    @property
+    def children(self) -> Sequence[CodegenNode]:
+        """Returns the child C++ entities, if any. Empty by default, intended to be overridden."""
+        return ()
+
+    def iter_all_children(self) -> Iterable[CodegenNode]:
+        """Iterate over all childrens, including inners. Pre-order."""
+        yield self
+        for child in self.children:
+            yield from child.iter_all_children()
+
+    @override
+    @abc.abstractmethod
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        raise NotImplementedError()
+
+    @final  # Prevent derived classes from overriding this instead of `own_includes` by mistake.
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        yield from self.own_includes()
+        for child in self.children:
+            yield from child.collect_includes()
+
+    def own_includes(self) -> Iterable[includes.Include]:
+        """
+        Returns includes required by the current node itself, not accounting for `children`.
+        Empty by default, intended to be overridden.
+        """
+        return ()
+
+    @override
+    def type_dependencies(self) -> Iterable[type_ref.TypeDependency]:
+        for child in self.children:
+            yield from child.type_dependencies()
+
+
+class File(names.HasCppName, includes.HasCppIncludes):
+    """A C++ proto structs file scheduled for generation."""
+
+    def __init__(self, *, proto_relative_path: pathlib.Path, children: Sequence[CodegenNode]) -> None:
+        super().__init__()
+        assert not proto_relative_path.is_absolute()
+        #: Path to the original proto file relative to its base source directory.
+        self.proto_relative_path: Final[pathlib.Path] = proto_relative_path
+        #: The top-level C++ entities to define in the file.
+        self.children = children
+
+    @override
+    def full_cpp_name(self) -> str:
+        return f'<file {self.proto_relative_path}>'
+
+    @override
+    def contextual_cpp_name(self, *, context: names.HasCppName) -> str:
+        return self.full_cpp_name()
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        return ()
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        for child in self.children:
+            yield from child.collect_includes()
+
+    def gen_path(self, *, ext: str) -> pathlib.Path:
+        """Path to the generated userver proto structs file."""
+        return includes.proto_path_to_structs_path(self.proto_relative_path, ext=ext)
+
+
+class NamespaceNode(CodegenNode):
+    """A C++ namespace definition scheduled for generation."""
+
+    def __init__(
+        self,
+        *,
+        parent_name_segments: Iterable[str],
+        name_segments: Iterable[str],
+        children: Sequence[CodegenNode],
+    ) -> None:
+        super().__init__()
+        self._parent_name_segments = parent_name_segments
+        self._name_segments = name_segments
+        self._children = children
+
+    @property
+    @override
+    def kind(self) -> str:
+        return 'namespace'
+
+    @property
+    @override
+    def children(self) -> Sequence[CodegenNode]:
+        return self._children
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        return *self._parent_name_segments, *self._name_segments
+
+    @property
+    def short_name(self) -> str:
+        """Name of the namespace itself without parent namespaces."""
+        assert all(self._name_segments), 'Empty name segments are not allowed'
+        return '::'.join(self._name_segments)
+
+    @classmethod
+    def make_for_structs(cls, package: str, children: Sequence[CodegenNode]) -> NamespaceNode:
+        return NamespaceNode(
+            parent_name_segments=(),
+            name_segments=(*names.proto_namespace_to_segments(names.package_to_namespace(package)), 'structs'),
+            children=children,
+        )
+
+    @classmethod
+    def make_for_vanilla(cls, package: str, children: Sequence[CodegenNode]) -> NamespaceNode:
+        return NamespaceNode(
+            parent_name_segments=(),
+            name_segments=names.proto_namespace_to_segments(names.package_to_namespace(package)),
+            children=children,
+        )
+
+
+class TypeNode(CodegenNode, abc.ABC):
+    """A base class that contains the common logic for any C++ type definition scheduled for generation."""
+
+    def __init__(self, *, name: names.TypeName) -> None:
+        super().__init__()
+        #: Detailed type name.
+        self.name: Final[names.TypeName] = name
+        #: Whether a forward declaration should be generated for the type at the top of the containing scope.
+        self.should_forward_declare: bool = False
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        return self.name.name_segments()
+
+
+def iter_type_nodes(node: CodegenNode) -> Iterable[TypeNode]:
+    """Iterate through all types defined inside, recursively."""
+    for child in node.iter_all_children():
+        if isinstance(child, TypeNode):
+            yield child
+
+
+class StructNode(TypeNode, names.HasVanillaName):
+    """A C++ proto struct definition scheduled for generation."""
+
+    def __init__(
+        self,
+        *,
+        vanilla_name: names.TypeName,
+        proto_file: pathlib.Path,
+        nested_types: Sequence[TypeNode],
+        fields: Sequence[StructField],
+    ) -> None:
+        super().__init__(name=names.make_structs_type_name(vanilla_name))
+        #: Vanilla message class name.
+        self._vanilla_name: Final[names.TypeName] = vanilla_name
+        #: Source proto file path, as it appears in imports.
+        self.proto_file: Final[pathlib.Path] = proto_file
+        #: Nested types definitions.
+        self.nested_types: Final[Sequence[TypeNode]] = nested_types
+        #: Struct fields.
+        self.fields: Final[Sequence[StructField]] = [f for f in fields if f.short_name not in ['minor', 'major']]
+
+    @property
+    @override
+    def kind(self) -> str:
+        return 'struct'
+
+    @property
+    @override
+    def children(self) -> Sequence[CodegenNode]:
+        return self.nested_types
+
+    @override
+    def own_includes(self) -> Iterable[includes.Include]:
+        # Need for IO.
+        yield includes.Include(
+            path=includes.proto_path_to_vanilla_pb_h(path=self.proto_file),
+            kind=includes.IncludeKind.FOR_CPP,
+        )
+        for field in self.fields:
+            yield from field.field_type.collect_includes()
+        yield includes.Include(path='userver/proto-structs/io/fwd.hpp', kind=includes.IncludeKind.FOR_HPP)
+
+        # For IO.
+        yield from [
+            includes.Include(path=path, kind=includes.IncludeKind.FOR_CPP)
+            for path in [
+                'utility',
+                'userver/proto-structs/io/impl/field_accessor.hpp',
+                'userver/proto-structs/io/impl/read.hpp',
+                'userver/proto-structs/io/impl/write.hpp',
+                'userver/proto-structs/type_mapping.hpp',
+            ]
+        ]
+
+    @override
+    def type_dependencies(self) -> Iterable[type_ref.TypeDependency]:
+        yield type_ref.TypeDependency(type_reference=self._vanilla_type_ref(), kind=type_ref.TypeDependencyKind.WEAK)
+        for field in self.fields:
+            yield from field.field_type.type_dependencies()
+        for nested in self.nested_types:
+            yield from nested.type_dependencies()
+
+    def _vanilla_type_ref(self) -> type_ref.TypeReference:
+        # TODO should move this method to HasVanillaName.
+        # TODO should implement methods of HasVanillaName using TypeReference.full_cpp_name.
+        return type_ref.VanillaCodegenType(name=self._vanilla_name, proto_file=self.proto_file)
+
+    @property
+    @override
+    def vanilla_name(self) -> names.TypeName:
+        return self._vanilla_name
+
+
+@dataclasses.dataclass
+class StructField:
+    """A field of a C++ proto struct."""
+
+    #: Name of the field.
+    short_name: Final[str]
+    #: Type of the field.
+    field_type: type_ref.TypeReference
+    #: C++ code for the field initializer, e.g. '', '{}' or '{5}'.
+    initializer: Final[str]
+    #: Low-level numeric ID of the field for serialization. Absent for fields of type "oneof".
+    number: Final[Optional[int]]
+    #: If this struct field maps to oneof, lists the fields of the oneof type.
+    oneof_fields: Final[Optional[Sequence[StructField]]]
+    #: IoKind:
+    io_kinds: Final[io.IoKind]
+
+    @property
+    def field_number_name(self) -> str:
+        """
+        Converts a `snake_case` or `camelCase` identifier to `PascalCase`.
+        Example: some_bytes_my_word -> kSomeBytesMyWordFieldNumber
+        Example: IYandexUid -> kIYandexUidFieldNumber
+        """
+        return f'k{names.to_pascal_case(self.short_name)}FieldNumber'
+
+    @property
+    def read_kind(self) -> str:
+        return self.io_kinds.read.name.lower()
+
+    @property
+    def write_kind(self) -> str:
+        return self.io_kinds.write.name.lower()
+
+    @property
+    def short_vanilla_name(self) -> str:
+        if self.short_name.lower() in reserved_identifiers.CPP_KEYWORDS:
+            return f'{self.short_name.lower()}_'
+        if self.short_name.endswith('_'):
+            if self.short_name[:-1].lower() in reserved_identifiers.CPP_KEYWORDS or self.short_name.endswith('__'):
+                return self.short_name.lower()
+        return self.short_name.removesuffix('_').lower()
+
+
+def wrap_field_in_box(field: StructField) -> None:
+    """
+    Wrap type of the field in `utils::Box`.
+    Policy:
+     * Message types `T` are replaced with `utils::Box<T>`.
+     * For optionals `std::optional<T>`, the inside is wrapped: `std::optional<utils::Box<T>>`.
+       This prevents an unnecessary allocation for empty fields.
+     * For repeated and map containers that require type definition, the whole container is wrapped, not each element.
+     * For custom / unknown types, `T` is replaced with `utils::Box<T>`.
+    """
+    if isinstance(field.field_type, type_ref.TemplateType):
+        if field.field_type.template.full_cpp_name() == type_ref_consts.OPTIONAL_TEMPLATE.full_cpp_name():
+            # Wrap the type inside the optional in `utils::Box`, not the optional itself.
+            value_type = field.field_type.template_args[0]
+            field.field_type = type_ref_consts.make_optional(type_ref_consts.make_box(value_type))
+            return
+    field.field_type = type_ref_consts.make_box(field.field_type)
+
+
+class EnumNode(TypeNode, names.HasVanillaName):
+    """A C++ proto enum class definition scheduled for generation."""
+
+    def __init__(
+        self,
+        *,
+        vanilla_name: names.TypeName,
+        proto_file: pathlib.Path,
+        values: Sequence[EnumValue],
+    ) -> None:
+        super().__init__(name=names.make_structs_type_name(vanilla_name))
+        #: Vanilla enum type name.
+        self._vanilla_name: Final[names.TypeName] = vanilla_name
+        #: Source proto file path, as it appears in imports.
+        self.proto_file: Final[pathlib.Path] = proto_file
+        #: Enum values (cases).
+        self.values: Final[Sequence[EnumValue]] = values
+
+    @property
+    @override
+    def kind(self) -> str:
+        return 'enum'
+
+    @override
+    def own_includes(self) -> Iterable[includes.Include]:
+        yield includes.Include(path='cstdint', kind=includes.IncludeKind.FOR_HPP)
+        yield includes.Include(path='limits', kind=includes.IncludeKind.FOR_HPP)
+        yield includes.Include(
+            path=includes.proto_path_to_vanilla_pb_h(self.proto_file), kind=includes.IncludeKind.FOR_CPP
+        )
+
+    @property
+    @override
+    def vanilla_name(self) -> names.TypeName:
+        return self._vanilla_name
+
+
+@dataclasses.dataclass(frozen=True)
+class EnumValue:
+    """A single value (case) of a C++ proto enum class."""
+
+    #: Name of the enum case.
+    short_name: str
+    #: Integer value of the enum case.
+    number: int
+
+
+class OneofNode(TypeNode):
+    """A C++ oneof class definition scheduled for generation."""
+
+    def __init__(
+        self,
+        *,
+        name: names.TypeName,
+        fields: Sequence[StructField],
+    ) -> None:
+        super().__init__(name=name)
+        #: Struct fields included in the oneof.
+        self.fields: Final[Sequence[StructField]] = fields
+
+    @property
+    @override
+    def kind(self) -> str:
+        return 'oneof'
+
+    @override
+    def own_includes(self) -> Iterable[includes.Include]:
+        for field in self.fields:
+            yield from field.field_type.collect_includes()
+        yield includes.Include(path='userver/proto-structs/impl/oneof_codegen.hpp', kind=includes.IncludeKind.FOR_HPP)
+
+    @override
+    def type_dependencies(self) -> Iterable[type_ref.TypeDependency]:
+        yield from super().type_dependencies()
+        for field in self.fields:
+            yield from field.field_type.type_dependencies()
+
+
+class VanillaTypeDeclaration(TypeNode, abc.ABC):
+    """A C++ vanilla type."""
+
+    def __init__(
+        self,
+        *,
+        vanilla_name: names.TypeName,
+    ) -> None:
+        super().__init__(name=names.make_structs_type_name(vanilla_name))
+        #: Vanilla type name.
+        self.vanilla_name: Final[names.TypeName] = vanilla_name
+        # `forward_decls.py` does not work across files, so just require the forward declaration here.
+        self.should_forward_declare = True
+
+
+class VanillaClassDeclaration(VanillaTypeDeclaration):
+    """A C++ vanilla class."""
+
+    @property
+    @override
+    def kind(self) -> str:
+        return 'vanilla_class'
diff --git a/scripts/proto_structs/models/includes.py b/scripts/proto_structs/models/includes.py
new file mode 100644
index 000000000000..08c10b711b28
--- /dev/null
+++ b/scripts/proto_structs/models/includes.py
@@ -0,0 +1,82 @@
+"""Concepts and helpers related to C++ includes and Protobuf imports."""
+
+import abc
+from collections.abc import Iterable
+import dataclasses
+import enum
+import pathlib
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from proto_structs.models import includes_bundles
+from proto_structs.models import names
+
+
+class IncludeKind(enum.Enum):
+    """The kind of C++ include."""
+
+    #: For .hpp.
+    FOR_HPP = enum.auto()
+    #: For .cpp.
+    FOR_CPP = enum.auto()
+
+
+@dataclasses.dataclass(order=True, frozen=True)
+class Include:
+    """A C++ include"""
+
+    #: Include path without '<>'.
+    path: str
+    #: Include type.
+    kind: IncludeKind
+
+
+class HasCppIncludes(abc.ABC):
+    """A C++ entity or entity group that may require includes to define."""
+
+    @abc.abstractmethod
+    def collect_includes(self) -> Iterable[Include]:
+        """Collects C++ includes required for rendering this and nested C++ entities. May contain duplicates."""
+        raise NotImplementedError()
+
+
+def sorted_includes(entity: HasCppIncludes, *, current_hpp: Optional[str] = None) -> Dict[IncludeKind, List[str]]:
+    """Returns a ready-to-use list of C++ includes required for rendering this and nested C++ entities."""
+    includes_set = set(entity.collect_includes())
+    if current_hpp:
+        includes_set.discard(Include(path=current_hpp, kind=IncludeKind.FOR_HPP))
+    sorted_includes = sorted(includes_set)
+    return {
+        IncludeKind.FOR_HPP: [
+            include.path
+            for include in sorted_includes
+            if include.kind == IncludeKind.FOR_HPP and include.path not in includes_bundles.BUNDLE_HPP
+        ],
+        IncludeKind.FOR_CPP: [
+            include.path
+            for include in sorted_includes
+            if include.kind == IncludeKind.FOR_CPP and include.path not in includes_bundles.BUNDLE_CPP
+        ],
+    }
+
+
+def proto_path_to_structs_path(proto_relative_path: pathlib.Path, *, ext: str) -> pathlib.Path:
+    """Returns the path of structs hpp or cpp based on the path of original proto file (relative to source dir)."""
+    return proto_relative_path.with_suffix(f'.structs.usrv.pb.{ext}')
+
+
+def proto_path_to_vanilla_pb_h(path: pathlib.Path) -> str:
+    """Returns the path of vanilla C++ `.pb.h` file (relative to source dir)."""
+    return str(path.with_suffix('.pb.h'))
+
+
+def io_includes_by_full_name(name: str, *, prefix: str) -> List[Include]:
+    """Returns includes for IO."""
+
+    name = names.to_snake_case(name)
+    path: str = prefix + '/'.join([word.removeprefix('_') for word in name.split('::')])
+    return [
+        Include(path=path + '.hpp', kind=IncludeKind.FOR_HPP),
+        Include(path=path + '_conv.hpp', kind=IncludeKind.FOR_CPP),
+    ]
diff --git a/scripts/proto_structs/models/includes_bundles.py b/scripts/proto_structs/models/includes_bundles.py
new file mode 100644
index 000000000000..28f2d590776a
--- /dev/null
+++ b/scripts/proto_structs/models/includes_bundles.py
@@ -0,0 +1,30 @@
+"""Sets of includes that are in bundles."""
+
+from typing import Set
+
+BUNDLE_HPP: Set[str] = {
+    'cstdint',
+    'limits',
+    'optional',
+    'string',
+    'utility',
+    'vector',
+    'userver/proto-structs/impl/oneof_codegen.hpp',
+    'userver/proto-structs/io/fwd.hpp',
+}
+
+BUNDLE_CPP: Set[str] = {
+    'userver/proto-structs/io/impl/field_accessor.hpp',
+    'userver/proto-structs/io/impl/read.hpp',
+    'userver/proto-structs/io/impl/write.hpp',
+    'userver/proto-structs/type_mapping.hpp',
+    'userver/proto-structs/io/std/optional_conv.hpp',
+    'userver/proto-structs/io/std/string_conv.hpp',
+    'userver/proto-structs/io/std/vector_conv.hpp',
+    'userver/proto-structs/io/std/int32_t_conv.hpp',
+    'userver/proto-structs/io/std/int64_t_conv.hpp',
+    'userver/proto-structs/io/std/size_t_conv.hpp',
+    'userver/proto-structs/io/std/uint32_t_conv.hpp',
+    'userver/proto-structs/io/std/uint64_t_conv.hpp',
+    'userver/proto-structs/io/std/scalar_conv.hpp',
+}
diff --git a/scripts/proto_structs/models/io.py b/scripts/proto_structs/models/io.py
new file mode 100644
index 000000000000..bfc41897c314
--- /dev/null
+++ b/scripts/proto_structs/models/io.py
@@ -0,0 +1,38 @@
+"""Concepts and helpers for io functions."""
+
+import dataclasses
+import enum
+
+
+class ReadVanillaFieldKind(enum.Enum):
+    """The kind of ReadProtoStruct getter. A kind is depended only from protobuf type."""
+
+    #: Oneof.
+    ONEOF = enum.auto()
+    #: std::optional.
+    OPTIONAL = enum.auto()
+    #: Other.
+    OTHER = enum.auto()
+
+
+class WriteVanillaFieldKind(enum.Enum):
+    """The kind of WriteProtoStruct setter. A kind is depended only from protobuf type."""
+
+    #: std::string or std::optional<std::string>.
+    STRING = enum.auto()
+    #: Oneof.
+    ONEOF = enum.auto()
+    #: Other.
+    OTHER = enum.auto()
+    #: Vector|Map|Message.
+    VECTOR_MAP_MESSAGE = enum.auto()
+
+
+@dataclasses.dataclass
+class IoKind:
+    """IO kinds for getters and setters."""
+
+    #: Read kind.
+    read: ReadVanillaFieldKind = ReadVanillaFieldKind.OTHER
+    #: Write kind.
+    write: WriteVanillaFieldKind = WriteVanillaFieldKind.OTHER
diff --git a/scripts/proto_structs/models/names.py b/scripts/proto_structs/models/names.py
new file mode 100644
index 000000000000..0805e6aaf74f
--- /dev/null
+++ b/scripts/proto_structs/models/names.py
@@ -0,0 +1,279 @@
+"""Concepts and helpers related to C++ and Protobuf naming."""
+
+from __future__ import annotations
+
+import abc
+from collections.abc import Sequence
+import dataclasses
+import re
+
+from proto_structs.models import reserved_identifiers
+
+
+class HasCppName(abc.ABC):
+    """A C++ entity with a name."""
+
+    @abc.abstractmethod
+    def full_cpp_name(self) -> str:
+        """Returns the fully-qualified name of the C++ entity, including parents. Mostly intended for diagnostics."""
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def contextual_cpp_name(self, *, context: HasCppName) -> str:
+        """
+        Returns the "enough-qualified" name of the C++ entity usable from inside the definition of `context`.
+        Examples:
+        contextual_cpp_name(foo::Bar::Baz::Qux, foo::Bar) -> Baz::Qux
+        contextual_cpp_name(std::optional<foo::Bar::Baz::Qux>, foo::Bar) -> std::optional<Baz::Qux>
+        contextual_cpp_name(foo, foo::bar) -> foo
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        """Returns parts of the full C++ name."""
+        raise NotImplementedError()
+
+
+class HasCppNameImpl(HasCppName, abc.ABC):
+    """
+    An implementation of `HasCppName` suitable for most cases where a name is a single qualified ID,
+    e.g. `foo::bar::Baz::Qux` is OK, but `std::optional<foo::Bar>` is NOT ok.
+    """
+
+    def full_cpp_name(self) -> str:
+        segments = self.full_cpp_name_segments()
+        assert all(segments), f'Empty name segments are not allowed for {self}'
+        return '::'.join(segments)
+
+    def contextual_cpp_name(self, *, context: HasCppName) -> str:
+        return _get_contextual_cpp_name(self, context=context)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__qualname__}(name={self.full_cpp_name()})'
+
+
+class HasVanillaName(abc.ABC):
+    """A C++ entity with a vanilla proto name."""
+
+    @property
+    @abc.abstractmethod
+    def vanilla_name(self) -> TypeName:
+        """Returns a vanilla type name."""
+        raise NotImplementedError()
+
+    @property
+    def vanilla_full_name(self) -> str:
+        """
+        Vanilla name when the definition is available.
+        Example: 'path::to::MyType::Nested::Inner'.
+        """
+        return self._name_impl(name=self.vanilla_name)
+
+    @property
+    def vanilla_full_name_fwd(self) -> str:
+        """
+        Vanilla name when the definition isn't available. For fwd.
+        Example: 'path::to:MyType_Nested_Inner'.
+        """
+        return self._name_impl(name=get_vanilla_fwd_type_name(name=self.vanilla_name))
+
+    def _name_impl(self, name: TypeName) -> str:
+        # TODO this is a copy-paste from full_cpp_name().
+        # TODO HasVanillaName should require proto_file property and should rely on VanillaCodegenType.
+        segments = name.name_segments()
+        assert all(segments), f'Empty name segments are not allowed for {self}'
+        return '::'.join(segments)
+
+
+def get_vanilla_fwd_type_name(*, name: TypeName) -> TypeName:
+    """
+    Converts a proto package to a vanilla protobuf name.
+    Example: 'path::to::MyType::Nested::Inner' -> 'path::to:MyType_Nested_Inner'.
+    """
+    short_name: str = '_'.join((*name.outer_type_names, name.short_name))
+
+    return TypeName(namespace_segments=name.namespace_segments, outer_type_names=(), short_name=short_name)
+
+
+_GLOBAL_PREFIXES: Sequence[str] = (
+    '::',
+    'std::',
+    'USERVER_NAMESPACE::',
+)
+
+
+def _get_contextual_cpp_name(entity: HasCppName, *, context: HasCppName) -> str:
+    node_names = entity.full_cpp_name_segments()
+
+    assert node_names, f'Cannot render a reference to an instance of {entity.__class__} by an empty name'
+    assert all(node_names), f'Empty name segments are not allowed for {entity=}'
+
+    if node_names[0] in reserved_identifiers.CPP_KEYWORDS:
+        assert len(node_names) == 1
+        return node_names[0]
+
+    if node_names[0] == 'std' or any(node_names[0].startswith(prefix) for prefix in _GLOBAL_PREFIXES):
+        # Always mention std:: entities by full name, global namespace prefixing is not required.
+        # Do not prefix USERVER_NAMESPACE:: names with global namespace as well (it results in a syntax error).
+        return '::'.join(node_names)
+
+    context_names = context.full_cpp_name_segments()
+    assert all(context_names), f'Empty name segments are not allowed for {context=}'
+
+    if not context_names:
+        # If no context then all we can do is returning a full cpp name.
+        return '::' + '::'.join(node_names)
+
+    if node_names[0] != context_names[0]:
+        # If no common ancestor then all we can do is returning a full cpp name.
+        return '::' + '::'.join(node_names)
+
+    # "index + 1 < len(node_names)" covers case:
+    # struct A {  // node=['A']
+    #   struct B {  // context=['A', 'B']
+    #     A field;  // get_contextual_cpp_name(node=A, context=B)
+    #   }
+    # }
+    #
+    # "index < len(context_names)" covers case:
+    # struct A {  // context=['A']
+    #   struct B {}  // node=['A', 'B']
+    #
+    #   B field;  // get_contextual_cpp_name(node=B, context=A)
+    # }
+    #
+    # "node_names[index] == context_names[index]" covers case:
+    # struct A {
+    #   struct B {
+    #       struct C {}  // node=['A', 'B', 'C']
+    #   }
+    #
+    #   struct D {  // context=['A', 'D']
+    #       B::C field;  // get_contextual_cpp_name(node=C, context=D)
+    #   }
+    # }
+    index = 0
+    while index + 1 < len(node_names) and index < len(context_names) and node_names[index] == context_names[index]:
+        index += 1
+
+    return '::'.join(node_names[index:])
+
+
+_ID_REGEX = re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*')
+
+
+def is_valid_id(identifier: str) -> bool:
+    return _ID_REGEX.fullmatch(identifier) is not None
+
+
+def escape_id(identifier: str) -> str:
+    """
+    Escapes a Protobuf identifier for use in C++.
+    Uses the same escaping technique as the native C++ Protobuf codegen.
+    """
+    if identifier in reserved_identifiers.CPP_RESERVED_IDENTIFIERS:
+        return f'{identifier}_'
+    return identifier
+
+
+def package_to_namespace(package: str) -> str:
+    """Converts a proto package to C++ namespace."""
+    return '::'.join(escape_id(part) for part in package.split('.'))
+
+
+def proto_namespace_to_segments(namespace: str) -> Sequence[str]:
+    """Returns namespace parts, as required by `HasCppName.full_cpp_name_segments`."""
+    if not namespace:
+        return ()
+    # Returning a single segment to force `contextual_cpp_name` to either mention the package-namespace as a whole
+    # or to omit it completely, mimicking proto naming rules.
+    return (namespace,)
+
+
+@dataclasses.dataclass(frozen=True)
+class TypeName:
+    """The qualified name of a C++ type."""
+
+    #: Namespace obtained from the Protobuf package.
+    namespace_segments: Sequence[str]
+    #: Containing types, if any, outer-to-inner, e.g. for `foo::Bar::Baz::Qux` it is `[Bar, Baz]`.
+    outer_type_names: Sequence[str]
+    #: Name of the type itself without outer types or namespaces.
+    short_name: str
+
+    def name_segments(self) -> Sequence[str]:
+        """Returns all segments of the qualified name."""
+        return *self.namespace_segments, *self.outer_type_names, self.short_name
+
+
+def make_escaped_type_name(*, package: str, outer_type_names: Sequence[str], short_name: str) -> TypeName:
+    """Escapes a Protobuf full type name into a C++ `TypeName`."""
+    return TypeName(
+        namespace_segments=proto_namespace_to_segments(package_to_namespace(package)),
+        outer_type_names=[escape_id(type_name) for type_name in outer_type_names],
+        short_name=escape_id(short_name),
+    )
+
+
+def make_structs_type_name(vanilla_type_name: TypeName) -> TypeName:
+    """Makes a name for a proto-structs type from a vanilla type name."""
+    return dataclasses.replace(vanilla_type_name, namespace_segments=(*vanilla_type_name.namespace_segments, 'structs'))
+
+
+def make_nested_type_name(containing_type_name: TypeName, short_name: str) -> TypeName:
+    """Makes a `TypeName` for a nested type."""
+    return TypeName(
+        namespace_segments=containing_type_name.namespace_segments,
+        outer_type_names=(*containing_type_name.outer_type_names, containing_type_name.short_name),
+        short_name=short_name,
+    )
+
+
+_SPLIT_PASCAL_PATTERN = re.compile(r'_|(?<=[a-z])(?=[A-Z])')
+
+
+def to_pascal_case(name: str, to_lower: bool = False) -> str:
+    """
+    Converts a `snake_case` or `UPPER_CASE` or `camelCase` identifier to `PascalCase`.
+    Examples:
+    some_bytes_my_word -> SomeBytesMyWord
+    by2tes_m1y -> By2TesM1Y
+    IYandexUid -> IYandexUid (if to_lower=False)
+    FOO_BAR_BazQux -> FooBarBazQux
+    """
+    # We should split name by '_' and uppers letters. 'FOO_BAR_BazQux' -> ["FOO", "BAR", "Baz", "Qux"]
+    words = _SPLIT_PASCAL_PATTERN.split(name)
+    name = '_'.join(words)
+
+    if to_lower:
+        name = name.lower()
+
+    words = ''.join(word[0].upper() + word[1:] for word in name.split('_') if len(word) > 0)
+
+    result = ''
+    for prev, ch in zip(' ' + words, words):
+        # Handle digits.
+        if prev.isdigit() and ch.isalpha():
+            result = result + ch.upper()
+        else:
+            result = result + ch
+    return result
+
+
+def to_upper_case(name: str) -> str:
+    """Converts a `snake_case`, `camelCase`, `PascalCase` or `UPPER_CASE` identifier to `UPPER_CASE`."""
+    if name.isupper():
+        return name
+    result = ''
+    for i, char in enumerate(name):
+        if char.isupper() and i > 0:
+            result += '_'
+        result += char
+    return result.upper()
+
+
+def to_snake_case(name: str) -> str:
+    name = re.sub(r'[\s-]+', '_', name)
+    name = re.sub(r'(?<!^)(?=[A-Z])', r'_', name)
+    return name.lower()
diff --git a/scripts/proto_structs/models/options.py b/scripts/proto_structs/models/options.py
new file mode 100644
index 000000000000..bff5cef00724
--- /dev/null
+++ b/scripts/proto_structs/models/options.py
@@ -0,0 +1,105 @@
+"""
+Options for proto-structs to generate.
+These can come from the proto file, as well as passed to the protoc plugin by the build system.
+"""
+
+import dataclasses
+import json
+import pathlib
+from typing import Annotated
+from typing import Any
+from typing import Dict
+from typing import Optional
+from typing import TypeVar
+
+import pydantic
+
+ShortName = Annotated[str, pydantic.StringConstraints(pattern=r'^[a-zA-Z_]\w*$')]
+FullName = Annotated[str, pydantic.StringConstraints(pattern=r'^[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*$')]
+
+
+class FileOptions(pydantic.BaseModel, extra='forbid'):
+    """Options that apply to all definitions or types in a file."""
+
+
+class MessageOptions(pydantic.BaseModel, extra='forbid'):
+    """Options that apply to struct definition or to all fields typed with this struct."""
+
+    #: True, if the struct's type should always be wrapped in `utils::Box`.
+    indirect: bool = False
+
+
+class OneofOptions(pydantic.BaseModel, extra='forbid'):
+    """Options that apply to oneof definition."""
+
+    #: Overrides the generated name of the C++ class to represent oneof.
+    generated_type_name: Optional[ShortName] = None
+
+
+class FieldOptions(pydantic.BaseModel, extra='forbid'):
+    """Options that apply to message fields."""
+
+    #: True, if the field's type should be wrapped in `utils::Box`.
+    indirect: bool = False
+
+
+class PluginOptions(pydantic.BaseModel, extra='forbid'):
+    """Options root."""
+
+    #: Proto file path (as in `import`) `full/file/name.proto` -> options.
+    file_options: Dict[FullName, FileOptions] = dataclasses.field(default_factory=dict)
+
+    #: Full message name in format `full.package.Message.SubMessage` -> options.
+    message_options: Dict[FullName, MessageOptions] = dataclasses.field(default_factory=dict)
+
+    #: Full oneof name in format `full.package.Message.Submessage.oneof_name` -> options.
+    oneof_options: Dict[FullName, OneofOptions] = dataclasses.field(default_factory=dict)
+
+    #: Full field name in format `full.package.Message.SubMessage.field` -> options.
+    field_options: Dict[FullName, FieldOptions] = dataclasses.field(default_factory=dict)
+
+
+# Some options for common plugins are there to avoid requiring passing the options in cmake for common library schemas.
+_DEFAULT_PLUGIN_OPTIONS = PluginOptions(
+    field_options={
+        # Built-in types.
+        'google.protobuf.Struct.fields': FieldOptions(indirect=True),
+        # Well-known types.
+        'google.api.BackendRule.overrides_by_request_protocol': FieldOptions(indirect=True),
+        # Protovalidate types.
+        'buf.validate.RepeatedRules.items': FieldOptions(indirect=True),
+        'buf.validate.MapRules.keys': FieldOptions(indirect=True),
+        'buf.validate.MapRules.values': FieldOptions(indirect=True),
+    },
+)
+
+
+def _merge_dicts_recursively(*, into: Dict[str, Any], overrides: Dict[str, Any]) -> None:
+    for key, value in overrides.items():
+        if key in into and isinstance(into[key], dict) and isinstance(value, dict):
+            sub_into: Dict[str, Any] = into[key]
+            sub_overrides: Dict[str, Any] = value
+            _merge_dicts_recursively(into=sub_into, overrides=sub_overrides)
+        else:
+            into[key] = value
+
+
+TBaseModelSubtype = TypeVar('TBaseModelSubtype', bound=pydantic.BaseModel)
+
+
+def merge_models(base: TBaseModelSubtype, *, overrides: TBaseModelSubtype) -> TBaseModelSubtype:
+    """Merge two pydantic models recursively."""
+    assert base.__class__ == overrides.__class__
+    merged = base.model_dump()
+    _merge_dicts_recursively(into=merged, overrides=overrides.model_dump())
+    return base.__class__(**merged)
+
+
+def load_plugin_options(file_path: Optional[pathlib.Path]) -> PluginOptions:
+    """Load `PluginOptions` from file."""
+    if not file_path:
+        return _DEFAULT_PLUGIN_OPTIONS
+
+    with open(file_path, 'r', encoding='utf-8') as file:
+        options = PluginOptions(**json.load(file))
+    return merge_models(_DEFAULT_PLUGIN_OPTIONS, overrides=options)
diff --git a/scripts/proto_structs/models/reserved_identifiers.py b/scripts/proto_structs/models/reserved_identifiers.py
new file mode 100644
index 000000000000..6ff9b44efbf6
--- /dev/null
+++ b/scripts/proto_structs/models/reserved_identifiers.py
@@ -0,0 +1,120 @@
+"""Lists of C++ reserved identifiers."""
+
+#: C++ Keywords (as of C++20/23).
+CPP_KEYWORDS = {
+    'alignas',
+    'alignof',
+    'and',
+    'and_eq',
+    'asm',
+    'auto',
+    'bitand',
+    'bitor',
+    'bool',
+    'break',
+    'case',
+    'catch',
+    'char',
+    'char8_t',
+    'char16_t',
+    'char32_t',
+    'class',
+    'compl',
+    'concept',
+    'const',
+    'consteval',
+    'constexpr',
+    'constinit',
+    'const_cast',
+    'continue',
+    'co_await',
+    'co_return',
+    'co_yield',
+    'decltype',
+    'default',
+    'delete',
+    'do',
+    'double',
+    'dynamic_cast',
+    'else',
+    'enum',
+    'explicit',
+    'export',
+    'extern',
+    'false',
+    'float',
+    'for',
+    'friend',
+    'goto',
+    'if',
+    'inline',
+    'int',
+    'long',
+    'mutable',
+    'namespace',
+    'new',
+    'noexcept',
+    'not',
+    'not_eq',
+    'nullptr',
+    'operator',
+    'or',
+    'or_eq',
+    'private',
+    'protected',
+    'public',
+    'register',
+    'reinterpret_cast',
+    'requires',
+    'return',
+    'short',
+    'signed',
+    'sizeof',
+    'static',
+    'static_assert',
+    'static_cast',
+    'struct',
+    'switch',
+    'template',
+    'this',
+    'thread_local',
+    'throw',
+    'true',
+    'try',
+    'typedef',
+    'typeid',
+    'typename',
+    'union',
+    'unsigned',
+    'using',
+    'virtual',
+    'void',
+    'volatile',
+    'wchar_t',
+    'while',
+    'xor',
+    'xor_eq',
+}
+
+#: Alternative identifiers with special meaning (contextual keywords).
+CPP_CONTEXTUAL_KEYWORDS = {
+    'final',
+    'override',
+    'import',
+    'module',
+}
+
+#: Identifiers reserved for possible future use.
+CPP_EXTRA_RESERVED_IDENTIFIERS = {
+    'reflexpr',  # Reflection TS
+}
+
+#: Popular macros from C++ standard library and userver.
+CPP_POPULAR_MACROS = {
+    'NULL',
+    'assert',
+    'LOG',
+}
+
+#: Combined set of all reserved identifiers.
+CPP_RESERVED_IDENTIFIERS = CPP_KEYWORDS | CPP_CONTEXTUAL_KEYWORDS | CPP_EXTRA_RESERVED_IDENTIFIERS | CPP_POPULAR_MACROS
diff --git a/scripts/proto_structs/models/sort_dependencies.py b/scripts/proto_structs/models/sort_dependencies.py
new file mode 100644
index 000000000000..9bf0b8ed670a
--- /dev/null
+++ b/scripts/proto_structs/models/sort_dependencies.py
@@ -0,0 +1,164 @@
+"""Graph of dependencies between types and a topology sort for that graph."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from collections.abc import Sequence
+import dataclasses
+import graphlib
+from typing import Dict
+from typing import List
+from typing import MutableSet
+from typing import Tuple
+
+from proto_structs.models import gen_node
+from proto_structs.models import toposort
+from proto_structs.models import type_ref
+from proto_structs.models import type_ref_consts
+
+#: Graph nodes are direct children of the scope (namespace or struct) that need to be sorted.
+#:
+#: "Node A depends on node B" means: a type defined in A (possibly A itself) refers to
+#: a type defined in B (possibly B itself).
+#:
+#: Guideline: write the type of some `TypeNode` as `_GraphNode` if and only if it is directly a graph node
+#: (not a nested type, not an unrelated type).
+_GraphNode = gen_node.TypeNode
+
+_MAX_CYCLE_BREAK_ATTEMPTS = 1000
+
+
+@dataclasses.dataclass
+class _Cycle:
+    #: A list of nodes forming a cycle, such that each node depends on the next node in the list.
+    #: The last node is guaranteed to be a duplicate of the first node, to make it clear that the list is cyclic.
+    nodes: List[_GraphNode]
+
+    @staticmethod
+    def from_exception(exception: graphlib.CycleError) -> _Cycle:
+        """Extracts cycle info from exception."""
+        cycle: List[_GraphNode] = exception.args[1]
+        assert len(cycle) >= 2
+        assert cycle[-1] is cycle[0]
+        return _Cycle(nodes=list(reversed(cycle)))
+
+    @property
+    def edges(self) -> Iterable[Tuple[_GraphNode, _GraphNode]]:
+        """Graph edges (node -> dependency) that form the cycle."""
+        return zip(self.nodes[:-1], self.nodes[1:])
+
+
+def _iter_struct_fields(node: gen_node.CodegenNode) -> Iterable[gen_node.StructField]:
+    for child in node.iter_all_children():
+        if isinstance(child, (gen_node.StructNode, gen_node.OneofNode)):
+            yield from child.fields
+
+
+class _Graph:
+    def __init__(self, nodes: Sequence[_GraphNode]) -> None:
+        # The nodes to sort. These are direct children of the scope (namespace or struct) that needs to be sorted.
+        self._nodes = nodes
+        # Allows to go from `TypeReference` to `TypeNode` for references to generated types.
+        self._types_by_names: Dict[str, gen_node.TypeNode] = {
+            child.full_cpp_name(): child for node in nodes for child in gen_node.iter_type_nodes(node)
+        }
+        # A map from all nested type definitions (including self) to their (possibly indirect) parents from `nodes`.
+        self._types_to_containing_graph_nodes: Dict[gen_node.TypeNode, _GraphNode] = {
+            child: node for node in nodes for child in gen_node.iter_type_nodes(node)
+        }
+        # Maps nodes to their dependencies, as required by `TopologicalSorter`.
+        self._graph: Dict[_GraphNode, MutableSet[_GraphNode]] = {}
+
+    def prepare(self) -> None:
+        for node in self._nodes:
+            self._graph.setdefault(node, set())
+
+        for node in self._nodes:
+            for dep in self.iter_referenced_type_nodes(entity=node, entity_graph_node=node):
+                self._graph[node].add(self._types_to_containing_graph_nodes[dep])
+
+    def iter_referenced_type_nodes(
+        self,
+        *,
+        entity: type_ref.HasTypeDependencies,
+        entity_graph_node: _GraphNode,
+    ) -> Iterable[gen_node.TypeNode]:
+        for dep in entity.type_dependencies():
+            # Select `TypeReference`s to types defined among `self._nodes`, get the corresponding `TypeNode`s.
+            if dep_node := self._types_by_names.get(dep.type_reference.full_cpp_name()):
+                dep_node_parent = self._types_to_containing_graph_nodes[dep_node]
+
+                # Dependency within a graph node will be resolved while sorting the node itself; skip it for now.
+                # However, cyclic dependency on the graph node itself needs to be accounted for.
+                #
+                # See examples in: libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto
+                if dep_node_parent is entity_graph_node:
+                    if dep_node is entity_graph_node and dep.kind == type_ref.TypeDependencyKind.STRONG:
+                        yield dep_node
+                    continue
+
+                # Dependency on a nested type holds even when WEAK.
+                # This is because the outer type needs to be defined to mention its nested type.
+                #
+                # See examples in: libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_self.proto
+                if dep_node != dep_node_parent:
+                    yield dep_node
+                    continue
+
+                if dep.kind == type_ref.TypeDependencyKind.STRONG:
+                    yield dep_node
+
+    def can_break_dependency(self, node: _GraphNode, *, dependency: _GraphNode) -> bool:
+        # Can break dependency if node only depends on the type itself, not on its nested types.
+        # This is because nested types cannot be forward declared, e.g. mentioning Foo::Bar requires definition of Foo.
+        #
+        # See examples in: libraries/proto-structs/codegen-tests/proto/box/autobox/dependency_on_nested.proto
+        return all(
+            dep_node is dependency
+            for dep_node in self.iter_referenced_type_nodes(entity=node, entity_graph_node=node)
+            if self._types_to_containing_graph_nodes[dep_node] is dependency
+        )
+
+    def break_dependency(self, node: _GraphNode, *, dependency: _GraphNode) -> None:
+        for field in _iter_struct_fields(node):
+            for dep_node in self.iter_referenced_type_nodes(entity=field.field_type, entity_graph_node=node):
+                if self._types_to_containing_graph_nodes[dep_node] is dependency:
+                    if dep_node is dependency:
+                        gen_node.wrap_field_in_box(field)
+                    else:
+                        field.field_type = type_ref_consts.UNBREAKABLE_DEPENDENCY_CYCLE
+
+    def sort_nodes(self) -> List[_GraphNode]:
+        attempts = 0
+        while True:
+            try:
+                # Need to at least ensure codegen output stability.
+                # Keeping the order close to the original proto file is also helpful.
+                return toposort.stable_toposort(items=self._nodes, graph=self._graph)
+            except graphlib.CycleError as exc:
+                cycle = _Cycle.from_exception(exc)
+
+            if attempts == _MAX_CYCLE_BREAK_ATTEMPTS:
+                names = (node.full_cpp_name() for node in cycle.nodes)
+                raise RuntimeError(f'Failed to break dependency cycle: {" -> ".join(names)}')
+            attempts += 1
+
+            can_break_dependencies = [
+                self.can_break_dependency(node, dependency=dependency) for node, dependency in cycle.edges
+            ]
+            can_break_any_dependency = any(can_break_dependencies)
+            for (node, dependency), can_break in zip(cycle.edges, can_break_dependencies):
+                if can_break or not can_break_any_dependency:
+                    self.break_dependency(node, dependency=dependency)
+                    self._graph[node].discard(dependency)
+
+
+def sort_types_topologically(nodes: Sequence[gen_node.TypeNode]) -> List[gen_node.TypeNode]:
+    """
+    Topologically sort `nodes`.
+    Wrap fields in `utils::Box` (as in `gen_node.wrap_field_in_box`) when necessary.
+    As a last resort, replace the field type with `proto_structs::UnbreakableDependencyCycle`.
+    """
+    graph = _Graph(nodes)
+    graph.prepare()
+    return graph.sort_nodes()
diff --git a/scripts/proto_structs/models/toposort.py b/scripts/proto_structs/models/toposort.py
new file mode 100644
index 000000000000..7da6bdc6c816
--- /dev/null
+++ b/scripts/proto_structs/models/toposort.py
@@ -0,0 +1,33 @@
+"""Utilities for sorting graphs topologically."""
+
+from collections.abc import Iterable
+from collections.abc import Sequence
+from graphlib import TopologicalSorter
+from typing import List
+from typing import Mapping
+from typing import TypeVar
+
+T = TypeVar('T')
+
+
+def stable_toposort(*, items: Sequence[T], graph: Mapping[T, Iterable[T]]) -> List[T]:
+    """
+    Stable topological sort using `graphlib.TopologicalSorter`.
+    items: original iterable of nodes (defines preferred order).
+    edges: iterable of (u, v) edges meaning u -> v.
+    Raises `graphlib.CycleError` if the graph contains a cycle.
+    """
+    ts = TopologicalSorter(graph)
+    ts.prepare()
+
+    item_to_index = {x: i for i, x in enumerate(items)}
+    result: List[T] = []
+
+    while ts.is_active():
+        ready = list(ts.get_ready())
+        ready.sort(key=lambda x: item_to_index[x])
+        for node in ready:
+            result.append(node)
+            ts.done(node)
+
+    return result
diff --git a/scripts/proto_structs/models/type_ref.py b/scripts/proto_structs/models/type_ref.py
new file mode 100644
index 000000000000..f1cc6c703ca2
--- /dev/null
+++ b/scripts/proto_structs/models/type_ref.py
@@ -0,0 +1,216 @@
+"""Models for usages of C++ types."""
+
+from __future__ import annotations
+
+import abc
+from collections.abc import Iterable
+from collections.abc import Sequence
+import dataclasses
+import enum
+import itertools
+import pathlib
+from typing import Optional
+
+from typing_extensions import override
+
+from proto_structs.models import includes
+from proto_structs.models import names
+
+
+class TypeDependencyKind(enum.Enum):
+    """The kind in which a C++ entity depends on another."""
+
+    #: A C++ type **definition** is required.
+    STRONG = enum.auto()
+    #: A C++ type **declaration** is required.
+    WEAK = enum.auto()
+
+
+@dataclasses.dataclass
+class TypeDependency:
+    """A dependency that a C++ entity has on a C++ type."""
+
+    #: The C++ type that is required.
+    type_reference: TypeReference
+    #: What is required from the type.
+    kind: TypeDependencyKind
+
+
+class HasTypeDependencies(abc.ABC):
+    """A C++ entity that requires type declarations or definitions."""
+
+    @abc.abstractmethod
+    def type_dependencies(self) -> Iterable[TypeDependency]:
+        """Returns types which this C++ entity requires."""
+        raise NotImplementedError()
+
+
+class TypeReference(names.HasCppName, includes.HasCppIncludes, HasTypeDependencies, abc.ABC):
+    """A usage of C++ type (not its definition)."""
+
+    @override
+    def type_dependencies(self) -> Iterable[TypeDependency]:
+        # Usage of a C++ type requires its definition by default.
+        return [TypeDependency(type_reference=self, kind=TypeDependencyKind.STRONG)]
+
+
+@dataclasses.dataclass
+class TemplateType(TypeReference):
+    """A usage of a compound template type, together with its template arguments."""
+
+    #: The type template without args.
+    template: TypeReference
+    #: Entities passed as template parameter values. May be empty, `Foo<>` can be a valid 0-arg template instantiation.
+    template_args: Sequence[TypeReference]
+    #: Template can be defined without template args definitions.
+    works_with_forward_references: bool = False
+
+    @override
+    def full_cpp_name(self) -> str:
+        own_name = self.template.full_cpp_name()
+        args = self.template_args
+        return f'{own_name}<{", ".join(arg.full_cpp_name() for arg in args)}>'
+
+    @override
+    def contextual_cpp_name(self, *, context: names.HasCppName) -> str:
+        own_name = self.template.contextual_cpp_name(context=context)
+        args = self.template_args
+        return f'{own_name}<{", ".join(arg.contextual_cpp_name(context=context) for arg in args)}>'
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        # Example: `foo::Bar::Baz<A, B> -> ['foo', 'Bar', 'Baz<A, B>']
+        template_name_segments = self.template.full_cpp_name_segments()
+        assert template_name_segments
+        args = self.template_args
+        last_segment = f'{template_name_segments[-1]}<{", ".join(arg.full_cpp_name() for arg in args)}>'
+        return *itertools.islice(template_name_segments, len(template_name_segments) - 1), last_segment
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        yield from self.template.collect_includes()
+        for arg in self.template_args:
+            yield from arg.collect_includes()
+
+    @override
+    def type_dependencies(self) -> Iterable[TypeDependency]:
+        yield from self.template.type_dependencies()
+        for arg in self.template_args:
+            if self.works_with_forward_references:
+                for sub_arg in arg.type_dependencies():
+                    yield TypeDependency(sub_arg.type_reference, TypeDependencyKind.WEAK)
+            else:
+                yield from arg.type_dependencies()
+
+
+class KeywordType(TypeReference, names.HasCppName):
+    """A C++ keyword that is represents a type."""
+
+    def __init__(self, *, full_cpp_name: str) -> None:
+        super().__init__()
+        self._full_cpp_name = full_cpp_name
+
+    @override
+    def full_cpp_name(self) -> str:
+        return self._full_cpp_name
+
+    @override
+    def contextual_cpp_name(self, *, context: names.HasCppName) -> str:
+        return self._full_cpp_name
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        return (self._full_cpp_name,)
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        yield includes.Include(path='userver/proto-structs/io/std/scalar_conv.hpp', kind=includes.IncludeKind.FOR_CPP)
+
+
+class BuiltinType(TypeReference, names.HasCppNameImpl):
+    """A usage of a non-code-generated C++ type: std* and libraries types."""
+
+    def __init__(self, *, full_cpp_name: str) -> None:
+        super().__init__()
+        self._full_cpp_name = full_cpp_name
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        # Return a single segment so that `contextual_cpp_name(context) == full_cpp_name`.
+        return (self._full_cpp_name,)
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        prefix: str = 'userver/proto-structs/io/'
+        yield from includes.io_includes_by_full_name(self.full_cpp_name(), prefix=prefix)
+
+
+_hardcoded_userver_namespace: Optional[str] = None
+
+
+def set_hardcoded_userver_namespace(namespace: Optional[str]) -> None:
+    global _hardcoded_userver_namespace
+    _hardcoded_userver_namespace = namespace
+
+
+class UserverLibraryType(TypeReference, names.HasCppNameImpl):
+    """A usage of a non-code-generated type from userver."""
+
+    def __init__(self, full_cpp_name_wo_userver: str) -> None:
+        super().__init__()
+        self._full_cpp_name_wo_userver = full_cpp_name_wo_userver
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        if _hardcoded_userver_namespace is not None:
+            userver_namespace = _hardcoded_userver_namespace
+        else:
+            userver_namespace = 'USERVER_NAMESPACE'
+
+        # Return a single segment so that `contextual_cpp_name(context) == full_cpp_name`.
+        return (f'{userver_namespace}::{self._full_cpp_name_wo_userver}',)
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        prefix: str = 'userver/proto-structs/io/userver'
+        yield from includes.io_includes_by_full_name(self.full_cpp_name(), prefix=prefix)
+
+
+class UserverCodegenType(TypeReference, names.HasCppNameImpl):
+    """A usage of a C++ type generated by userver proto_structs plugin."""
+
+    def __init__(self, *, name: names.TypeName, proto_file: pathlib.Path) -> None:
+        super().__init__()
+        self._name = name
+        self._proto_file = proto_file
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        return self._name.name_segments()
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        yield includes.Include(
+            path=str(includes.proto_path_to_structs_path(self._proto_file, ext='hpp')),
+            kind=includes.IncludeKind.FOR_HPP,
+        )
+        yield includes.Include(
+            path=includes.proto_path_to_vanilla_pb_h(self._proto_file), kind=includes.IncludeKind.FOR_CPP
+        )
+
+
+class VanillaCodegenType(TypeReference, names.HasCppNameImpl):
+    """A usage of a C++ type generated by base protoc C++ plugin."""
+
+    def __init__(self, *, name: names.TypeName, proto_file: pathlib.Path) -> None:
+        super().__init__()
+        self._name = name
+        self._proto_file = proto_file
+
+    @override
+    def full_cpp_name_segments(self) -> Sequence[str]:
+        return self._name.name_segments()
+
+    @override
+    def collect_includes(self) -> Iterable[includes.Include]:
+        yield includes.Include(path=str(self._proto_file.with_suffix('.pb.h')), kind=includes.IncludeKind.FOR_HPP)
diff --git a/scripts/proto_structs/models/type_ref_consts.py b/scripts/proto_structs/models/type_ref_consts.py
new file mode 100644
index 000000000000..297aa148c343
--- /dev/null
+++ b/scripts/proto_structs/models/type_ref_consts.py
@@ -0,0 +1,50 @@
+"""`TypeReference` constants for common built-in C++ types."""
+
+from proto_structs.models import type_ref
+
+#: `std::optional`
+OPTIONAL_TEMPLATE = type_ref.BuiltinType(full_cpp_name='std::optional')
+#: `std::vector`
+VECTOR_TEMPLATE = type_ref.BuiltinType(full_cpp_name='std::vector')
+#: `USERVER_NAMESPACE::proto_structs::HashMap`
+HASH_MAP_TEMPLATE = type_ref.UserverLibraryType(full_cpp_name_wo_userver='proto_structs::HashMap')
+
+#: `USERVER_NAMESPACE::utils::Box`
+BOX_TEMPLATE = type_ref.UserverLibraryType(full_cpp_name_wo_userver='utils::Box')
+#: `USERVER_NAMESPACE::proto_structs::UnbreakableDependencyCycle`
+UNBREAKABLE_DEPENDENCY_CYCLE = type_ref.UserverLibraryType(
+    full_cpp_name_wo_userver='proto_structs::UnbreakableDependencyCycle',
+)
+
+#: `USERVER_NAMESPACE::proto_structs::Oneof`
+ONEOF_BASE_CLASS = type_ref.UserverLibraryType(full_cpp_name_wo_userver='proto_structs::Oneof')
+
+
+def make_optional(value: type_ref.TypeReference) -> type_ref.TypeReference:
+    """Makes `std::optional<T>` type."""
+    return type_ref.TemplateType(template=OPTIONAL_TEMPLATE, template_args=(value,))
+
+
+def make_vector(value: type_ref.TypeReference) -> type_ref.TypeReference:
+    """Makes `std::vector<T>` type."""
+    return type_ref.TemplateType(
+        template=VECTOR_TEMPLATE,
+        template_args=(value,),
+        works_with_forward_references=True,
+    )
+
+
+def make_hash_map(key: type_ref.TypeReference, value: type_ref.TypeReference) -> type_ref.TypeReference:
+    """Makes `USERVER_NAMESPACE::proto_structs::HashMap<K, V>` type."""
+    return type_ref.TemplateType(
+        template=HASH_MAP_TEMPLATE,
+        template_args=(
+            key,
+            value,
+        ),
+    )
+
+
+def make_box(value: type_ref.TypeReference) -> type_ref.TypeReference:
+    """Makes `USERVER_NAMESPACE::utils::Box<T>` type."""
+    return type_ref.TemplateType(template=BOX_TEMPLATE, template_args=(value,), works_with_forward_references=True)
diff --git a/scripts/proto_structs/models/vanilla.py b/scripts/proto_structs/models/vanilla.py
new file mode 100644
index 000000000000..c708df72b777
--- /dev/null
+++ b/scripts/proto_structs/models/vanilla.py
@@ -0,0 +1,16 @@
+"""Collect vanilla types."""
+
+from typing import List
+
+from proto_structs.models import gen_node
+from proto_structs.models import names
+
+
+def collect_vanilla_types(*, types: List[gen_node.TypeNode]) -> List[gen_node.VanillaTypeDeclaration]:
+    vanillas: List[gen_node.VanillaTypeDeclaration] = []
+    for type_node in types:
+        for child in type_node.iter_all_children():
+            if isinstance(child, gen_node.StructNode):
+                vanilla_name: names.TypeName = names.get_vanilla_fwd_type_name(name=child.vanilla_name)
+                vanillas.append(gen_node.VanillaClassDeclaration(vanilla_name=vanilla_name))
+    return vanillas
diff --git a/scripts/proto_structs/templates/io.inc.jinja b/scripts/proto_structs/templates/io.inc.jinja
new file mode 100644
index 000000000000..091fef976d71
--- /dev/null
+++ b/scripts/proto_structs/templates/io.inc.jinja
@@ -0,0 +1,203 @@
+{% import "utils.inc.jinja" as utils %}
+
+{% macro render_gen_node(node, context) %}
+{% if node.kind == "namespace" %}
+{{ do_render_namespace(node) -}}
+{% elif node.kind == "struct" %}
+{{ do_render_struct(node, context) -}}
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_namespace(namespace) %}
+
+{% call utils.optional_namespace(namespace.short_name) %}
+{% for child in namespace.children %}
+{{ render_gen_node(child, namespace) -}}
+{% endfor %}
+
+{% endcall %}  {#- optional namespace -#}
+{% endmacro %}
+
+
+{% macro do_render_struct(node, context) %}
+
+// ---------- IO for {{ node.full_cpp_name() }} ----------
+{{ do_render_read(node, context) -}}
+{{ do_render_write_impl(node) -}}
+{{ do_render_write_const_ref(node, context) -}}
+{{ do_render_write_rvalue(node, context) -}}
+{% for child in node.nested_types %}
+{{ render_gen_node(child, context) -}}
+{% endfor %}
+{% endmacro %}
+
+{% macro do_render_vanilla(struct) %}
+::{{ struct.vanilla_full_name -}}
+{%- endmacro %}
+
+{% macro do_render_field_number(struct, field) %}
+{{ do_render_vanilla(struct) -}}::{{ field.field_number_name }}
+{%- endmacro %}
+
+{% macro do_render_field_set(struct, field) %}
+&{{ do_render_vanilla(struct) -}}::set_{{ field.short_vanilla_name }}
+{%- endmacro %}
+
+{% macro do_render_field_clear(struct, field) %}
+&{{ do_render_vanilla(struct)  -}}::clear_{{ field.short_vanilla_name }}
+{%- endmacro %}
+
+{% macro do_render_field_mutable(struct, field) %}
+&{{ do_render_vanilla(struct) -}}::mutable_{{ field.short_vanilla_name }}
+{%- endmacro %}
+
+{% macro do_render_ptr_getter(struct, field) %}
+&{{ do_render_vanilla(struct) -}}::{{ field.short_vanilla_name }}
+{%- endmacro %}
+
+{% macro do_render_ptr_has(struct, field) %}
+&{{ do_render_vanilla(struct) -}}::has_{{ field.short_vanilla_name }}
+{%- endmacro %}
+
+{% macro do_render_field_getter(struct, field, pass_has) %}
+USERVER_NAMESPACE::proto_structs::io::impl::CreateFieldGetter(msg, ::{{ struct.vanilla_full_name }}::{{ field.field_number_name }},
+{% filter indent(width=4, first=True) %}
+{{ do_render_ptr_getter(struct, field) -}} 
+{%- if pass_has -%},{{ do_render_ptr_has(struct, field) -}}{% endif %}
+)
+{% endfilter %}
+{%- endmacro %}
+
+{% macro do_render_read_field(struct, context, field) %}
+.{{ field.short_name }} = USERVER_NAMESPACE::proto_structs::io::impl::ReadField<decltype({{ struct.contextual_cpp_name(context=context) }}::{{ field.short_name }})>(ctx, 
+{% filter indent(width=4, first=True) %}
+{%- if field.read_kind == "other" %}
+{{ do_render_field_getter(struct, field, False) }}
+{%- elif field.read_kind == "optional" %}
+{{ do_render_field_getter(struct, field, True) }}
+{%- elif field.read_kind == "oneof" %}
+{%- for oneof_field in field.oneof_fields %} 
+{{ do_render_field_getter(struct, oneof_field, True) }}
+{%- if not loop.last -%},{%- endif %}
+{% endfor %}
+{% endif %}
+),
+{% endfilter %}
+{% endmacro %}
+
+{% macro do_render_read(struct, context) %}
+
+{{ struct.contextual_cpp_name(context=context) }} ReadProtoStruct(
+{% filter indent(width=4, first=True) %}
+[[maybe_unused]] USERVER_NAMESPACE::proto_structs::io::ReadContext& ctx,
+USERVER_NAMESPACE::proto_structs::io::To<{{ struct.contextual_cpp_name(context=context) }}>,
+[[maybe_unused]] const ::{{ struct.vanilla_full_name }}& msg) {
+return {
+{% filter indent(width=4, first=True) %}
+{%- for field in struct.fields %} 
+{{ do_render_read_field(struct, context, field) }}
+{% endfor %}
+{% endfilter %}
+};
+{% endfilter %}
+}
+{% endmacro %}
+
+
+{% macro do_render_string_setter(struct, field) %}
+USERVER_NAMESPACE::proto_structs::io::impl::CreateFieldSetter(
+{% filter indent(width=4, first=True) %}
+msg,
+{{ do_render_field_number(struct, field) }},
+{{ do_render_field_set(struct, field) }}<const std::string&>,
+{{ do_render_field_clear(struct, field) }}
+{% endfilter %}
+)
+{% endmacro %}
+
+{% macro do_render_simple_setter(struct, field) %}
+USERVER_NAMESPACE::proto_structs::io::impl::CreateFieldSetter(
+{% filter indent(width=4, first=True) %}
+msg, 
+{{ do_render_field_number(struct, field) }},
+{{ do_render_field_set(struct, field) }},
+{{ do_render_field_clear(struct, field)}}
+{% endfilter %}
+)
+{% endmacro %}
+
+{% macro do_render_message_setter(struct, field) %}
+USERVER_NAMESPACE::proto_structs::io::impl::CreateFieldSetter(
+{% filter indent(width=4, first=True) %}
+msg, 
+{{ do_render_field_number(struct, field) }},
+{{ do_render_field_mutable(struct, field) }},
+{{ do_render_field_clear(struct, field) }}
+{% endfilter %}
+)
+{% endmacro %}
+
+{% macro do_render_field_setter(struct, field) %}
+{% filter indent(width=4, first=True) %}
+{%- if field.write_kind == "other" %}
+{{ do_render_simple_setter(struct, field) }}
+{%- elif field.write_kind == "string" %}
+{{ do_render_string_setter(struct, field) }}
+{%- elif field.write_kind == "vector_map_message" %}
+{{ do_render_message_setter(struct, field) }}
+{%- elif field.write_kind == "oneof" %}
+{%- for oneof_field in field.oneof_fields %} 
+{{ do_render_field_setter(struct, oneof_field) }}
+{%- if not loop.last %},{% endif %}
+{% endfor %}
+{% endif %}
+{% endfilter %}
+{% endmacro %}
+
+{% macro do_render_write_field(struct, field) %}
+USERVER_NAMESPACE::proto_structs::io::impl::WriteField(ctx, std::forward<T>(obj).{{ field.short_name }},
+{{ do_render_field_setter(struct, field) }}
+);
+{% endmacro %}
+
+{% macro do_render_write_impl(struct) %}
+
+template<typename T>
+void WriteProtoStructImpl(
+{% filter indent(width=4, first=True) %}
+[[maybe_unused]] USERVER_NAMESPACE::proto_structs::io::WriteContext& ctx,
+[[maybe_unused]] T&& obj,
+[[maybe_unused]] ::{{ struct.vanilla_full_name }}& msg
+{% endfilter %}
+) {
+{% filter indent(width=4, first=True) %}
+{%- for field in struct.fields %} 
+{{ do_render_write_field(struct, field) }}
+{% endfor %}
+{% endfilter %}
+}
+{% endmacro %}
+
+{% macro do_render_write_const_ref(struct, context) %}
+
+void WriteProtoStruct(
+{% filter indent(width=4, first=True) %}
+USERVER_NAMESPACE::proto_structs::io::WriteContext& ctx,
+const {{ struct.contextual_cpp_name(context=context) }}& obj,
+::{{ struct.vanilla_full_name }}& msg) {
+WriteProtoStructImpl(ctx, obj, msg);
+{% endfilter %}
+}
+{% endmacro %}
+
+{% macro do_render_write_rvalue(struct, context) %}
+
+void WriteProtoStruct(
+{% filter indent(width=4, first=True) %}
+USERVER_NAMESPACE::proto_structs::io::WriteContext& ctx,
+{{ struct.contextual_cpp_name(context=context) }}&& obj,
+::{{ struct.vanilla_full_name }}& msg) {
+WriteProtoStructImpl(ctx, std::move(obj), msg);
+{% endfilter %}
+}
+{% endmacro %}
diff --git a/scripts/proto_structs/templates/io_forward_declarations.inc.jinja b/scripts/proto_structs/templates/io_forward_declarations.inc.jinja
new file mode 100644
index 000000000000..594caf59668d
--- /dev/null
+++ b/scripts/proto_structs/templates/io_forward_declarations.inc.jinja
@@ -0,0 +1,76 @@
+{% import "utils.inc.jinja" as utils %}
+
+{% macro render_gen_node(node, context) %}
+{% if node.kind == "namespace" %}
+{{ do_render_namespace(node) -}}
+{% elif node.kind == "struct" %}
+{{ do_render_struct(node, context) -}}
+{% elif node.kind == "oneof" %}
+{{ do_render_oneof(node, context) -}}
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_namespace(namespace) %}
+
+{% call utils.optional_namespace(namespace.short_name) %}
+{% for child in namespace.children %}
+{{ render_gen_node(child, namespace) -}}
+{% endfor %}
+
+{% endcall %}  {#- optional namespace -#}
+{% endmacro %}
+
+{% macro do_render_struct(node, context) %}
+
+// ---------- IO for {{ node.full_cpp_name() }} ----------
+{{ do_render_read(node, context) -}}
+{{ do_render_write_const_ref(node, context) -}}
+{{ do_render_write_rvalue(node, context) -}}
+{% for nested in node.nested_types %}
+{{ render_gen_node(nested, context) -}}
+{% endfor %}
+{% endmacro %}
+
+{% macro do_render_read(type_node, context) %}
+
+{{ type_node.contextual_cpp_name(context=context) }} ReadProtoStruct(
+{% filter indent(width=4, first=True) %}
+USERVER_NAMESPACE::proto_structs::io::ReadContext&,
+USERVER_NAMESPACE::proto_structs::io::To<{{ type_node.contextual_cpp_name(context=context) }}>,
+const ::{{ type_node.vanilla_full_name_fwd }}&
+{% endfilter %}
+);
+{% endmacro %}
+
+{% macro do_render_write_const_ref(type_node, context) %}
+
+void WriteProtoStruct(
+{% filter indent(width=4, first=True) %}
+USERVER_NAMESPACE::proto_structs::io::WriteContext&,
+const {{ type_node.contextual_cpp_name(context=context) }}&,
+::{{ type_node.vanilla_full_name_fwd }}&
+{% endfilter %}
+);
+{% endmacro %}
+
+{% macro do_render_write_rvalue(type_node, context) %}
+
+void WriteProtoStruct(
+{% filter indent(width=4, first=True) %}
+USERVER_NAMESPACE::proto_structs::io::WriteContext&,
+{{ type_node.contextual_cpp_name(context=context) }}&&,
+::{{ type_node.vanilla_full_name_fwd }}&
+{% endfilter %}
+);
+{% endmacro %}
+
+{% macro do_render_oneof(oneof, context) %}
+
+// ---------- IO for {{ oneof.full_cpp_name() }} ----------
+
+{% set oneof_type_name = oneof.contextual_cpp_name(context=context) %}
+{% for field in oneof.fields %}
+{% set field_type_name = field.field_type.contextual_cpp_name(context=context) %}
+UPROTO_ONEOF_DEFINE_FIELD_FUNCTIONS({{ oneof_type_name }}, {{ field_type_name }}, {{ field.short_name }})
+{% endfor %} {#- for field -#}
+{% endmacro %}
diff --git a/scripts/proto_structs/templates/structs.usrv.cpp.jinja b/scripts/proto_structs/templates/structs.usrv.cpp.jinja
index 9259b5158631..9fdc5b18335b 100644
--- a/scripts/proto_structs/templates/structs.usrv.cpp.jinja
+++ b/scripts/proto_structs/templates/structs.usrv.cpp.jinja
@@ -1,6 +1,14 @@
 {% import "utils.inc.jinja" as utils %}
-{{- utils.do_not_edit() }}
+{% import "io.inc.jinja" as io %}
+{{ utils.do_not_edit(file_name_wo_ext) }}
+#include <{{ file_name_wo_ext }}.structs.usrv.pb.hpp>
 
-#include <{{ name_wo_ext }}.structs.usrv.pb.hpp>
-
-// I AM CPP
+#include <userver/proto-structs/impl/bundles/structs_cpp.hpp>
+{% call utils.prepend_empty_line_if_not_empty() %}
+{% for include in includes_cpp %}
+#include <{{ include }}>
+{% endfor %}
+{% endcall %}
+{% for node in file.children %}
+{{ io.render_gen_node(node, file) -}}
+{% endfor -%}
diff --git a/scripts/proto_structs/templates/structs.usrv.hpp.jinja b/scripts/proto_structs/templates/structs.usrv.hpp.jinja
index 6c39ead3ccef..369b7e1a9975 100644
--- a/scripts/proto_structs/templates/structs.usrv.hpp.jinja
+++ b/scripts/proto_structs/templates/structs.usrv.hpp.jinja
@@ -1,10 +1,20 @@
+{% import "io_forward_declarations.inc.jinja" as io_forward_declarations %}
+{% import "types.inc.jinja" as types with context %}
 {% import "utils.inc.jinja" as utils %}
-{{- utils.do_not_edit() }}
-
+{{ utils.do_not_edit(file_name_wo_ext) }}
 #pragma once
 
-{% for dep in dependency %}
-#include <{{ dep }}.structs.usrv.pb.hpp>
+#include <userver/proto-structs/impl/bundles/structs_hpp.hpp>
+{% call utils.prepend_empty_line_if_not_empty() %}
+{% for include in includes_hpp %}
+#include <{{ include }}>
+{% endfor %}
+{% endcall %}
+{% for node in file.children %}
+{{ types.render_gen_node(node) -}}
 {% endfor %}
 
-// I AM HPP
+// ======================================== IO implementation ========================================
+{% for child in file.children %}
+{{ io_forward_declarations.render_gen_node(child, file) -}}
+{% endfor -%}
diff --git a/scripts/proto_structs/templates/types.inc.jinja b/scripts/proto_structs/templates/types.inc.jinja
new file mode 100644
index 000000000000..a33ef21d31e7
--- /dev/null
+++ b/scripts/proto_structs/templates/types.inc.jinja
@@ -0,0 +1,94 @@
+{% import "types_forward_declarations.inc.jinja" as types_forward_declarations %}
+{% import "utils.inc.jinja" as utils %}
+
+{% macro render_gen_node(node) %}
+{% if node.kind == "namespace" %}
+{{ do_render_namespace(node) -}}
+{% elif node.kind == "struct" %}
+{{ do_render_struct(node) -}}
+{% elif node.kind == "enum" %}
+{{ do_render_enum(node) -}}
+{% elif node.kind == "oneof" %}
+{{ do_render_oneof(node) -}}
+{% elif node.kind == "vanilla_class" %}
+{% else %}
+NOT_IMPLEMENTED_ERROR()
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_namespace(namespace) %}
+
+{% call utils.optional_namespace(namespace.short_name) %}
+{% call utils.prepend_empty_line_if_not_empty() %}
+{% for child in namespace.children %}
+{{ types_forward_declarations.render_gen_node(child) -}}
+{% endfor %}
+{% endcall %}
+{% for child in namespace.children %}
+{{ render_gen_node(child) -}}
+{% endfor %}
+
+{% endcall %}  {#- optional namespace -#}
+{% endmacro %}
+
+{% macro do_render_struct(struct) %}
+
+struct {{ struct.name.short_name }} final {
+{% filter indent(width=4, first=True) %}
+using ProtobufMessage = ::{{ struct.vanilla_full_name_fwd }};
+{% call utils.prepend_empty_line_if_not_empty() %}
+{% for nested in struct.nested_types %}
+{{ types_forward_declarations.render_gen_node(nested) -}}
+{% endfor %}
+{% endcall %}  {#- prepend empty line -#}
+{% for nested in struct.nested_types %}
+{{ render_gen_node(nested) -}}
+{% endfor %}
+{% call utils.prepend_empty_line_if_not_empty() %}
+{% for field in struct.fields %}
+{{ do_render_field(struct, field) -}}
+{% endfor %}
+{% endcall %}  {#- prepend empty line -#}
+{% endfilter %}  {#- indent #}
+};
+{% endmacro %}
+
+{% macro do_render_enum(enum) %}
+
+enum class {{ enum.name.short_name }} : std::int32_t {
+{% filter indent(width=4, first=True) %}
+{% for value in enum.values %}
+{{ value.short_name }} = {{ value.number }},
+{% endfor %}
+INTERNAL_DO_NOT_USE_ = std::numeric_limits<std::int32_t>::max(),  // Write default: instead.
+{% endfilter %}
+};
+{% endmacro %}
+
+{% macro do_render_oneof(oneof) %}
+
+struct {{ oneof.name.short_name }} final : {{ type_ref_consts.ONEOF_BASE_CLASS.contextual_cpp_name(context=oneof) }}<
+{% filter indent(width=4, first=True) %}
+{% for field in oneof.fields %}
+{{ field.field_type.contextual_cpp_name(context=oneof) }}
+{%- if not loop.last -%}
+,
+{%- endif %}
+
+{% endfor %} {#- for field #}
+{% endfilter %} {#- filter indent (template args) #}
+> {
+{% filter indent(width=4, first=True) %}
+UPROTO_ONEOF_HEADER({{ oneof.name.short_name }})
+
+// For each field {name}, there are methods: has_{name}, {name} (const& and &&), set_{name}, mutable_{name}.
+{% for field in oneof.fields %}
+UPROTO_ONEOF_FIELD({{ oneof.name.short_name }}, {{ field.field_type.contextual_cpp_name(context=oneof) }}, {{ field.short_name }})
+{% endfor %} {#- for field #}
+{% endfilter %} {#- filter indent (struct contents) #}
+};
+{% endmacro %} {#- do_render_oneof -#}
+
+{% macro do_render_field(struct, field) %}
+{{ field.field_type.contextual_cpp_name(context=struct) }} {{ field.short_name }}{{ field.initializer }};
+{% endmacro %}
diff --git a/scripts/proto_structs/templates/types_forward_declarations.inc.jinja b/scripts/proto_structs/templates/types_forward_declarations.inc.jinja
new file mode 100644
index 000000000000..5b951aae3b8c
--- /dev/null
+++ b/scripts/proto_structs/templates/types_forward_declarations.inc.jinja
@@ -0,0 +1,39 @@
+{% macro render_gen_node(node) %}
+{% if node.kind == "namespace" %}
+{# For nested scopes, only render forward declarations in them, but not in their parent namespaces -#}
+{% elif node.kind == "struct" %}
+{{ do_render_struct(node) -}}
+{% elif node.kind == "vanilla_class" %}
+{{ do_render_vanilla_class(node) -}}
+{% elif node.kind == "oneof" %}
+{{ do_render_oneof(node) -}}
+{% elif node.kind == "enum" %}
+{{ do_render_enum(node) -}}
+{% else %}
+NOT_IMPLEMENTED_ERROR()
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_struct(struct) %}
+{% if struct.should_forward_declare %}
+struct {{ struct.name.short_name }};
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_vanilla_class(node) %}
+{% if node.should_forward_declare %}
+class {{ node.name.short_name }};
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_oneof(oneof) %}
+{% if oneof.should_forward_declare %}
+struct {{ oneof.name.short_name }};
+{% endif %}
+{% endmacro %}
+
+{% macro do_render_enum(enum) %}
+{% if enum.should_forward_declare %}
+enum class {{ enum.name.short_name }} : std::int32_t;
+{% endif %}
+{% endmacro %}
diff --git a/scripts/proto_structs/templates/utils.inc.jinja b/scripts/proto_structs/templates/utils.inc.jinja
index 64547d3497eb..a222681e5d3c 100644
--- a/scripts/proto_structs/templates/utils.inc.jinja
+++ b/scripts/proto_structs/templates/utils.inc.jinja
@@ -1,3 +1,22 @@
-{% macro do_not_edit() %}
+{% macro do_not_edit(file_name_wo_ext) %}
 // THIS FILE IS AUTOGENERATED, DON'T EDIT!
-{%- endmacro %}
+// Source: {{ file_name_wo_ext }}.proto
+{% endmacro %}
+
+{% macro optional_namespace(namespace) %}
+{% if namespace %}
+namespace {{ namespace }} {
+{% endif %}
+{{ caller() -}}
+{% if namespace %}
+}  // namespace {{ namespace }}
+{% endif %}
+{% endmacro %}
+
+{% macro prepend_empty_line_if_not_empty() %}
+{% set text = caller() %}
+{% if text | trim %}
+
+{{ text -}}
+{% endif %}
+{% endmacro %}
diff --git a/scripts/proto_structs/ya.make b/scripts/proto_structs/ya.make
deleted file mode 100644
index 639370c00d22..000000000000
--- a/scripts/proto_structs/ya.make
+++ /dev/null
@@ -1,24 +0,0 @@
-PY3_LIBRARY()
-
-SUBSCRIBER(
-    g:taxi-common
-)
-
-PEERDIR(
-    contrib/python/Jinja2
-    contrib/python/protobuf
-)
-
-RESOURCE_FILES(
-    PREFIX taxi/uservices/userver/scripts/proto_structs/
-    templates/structs.usrv.cpp.jinja
-    templates/structs.usrv.hpp.jinja
-    templates/utils.inc.jinja
-)
-
-PY_SRCS(
-    __init__.py
-    generator.py
-)
-
-END()
diff --git a/scripts/sql/generator.py b/scripts/sql/generator.py
index f777ecb8cc3f..552d762adfb3 100644
--- a/scripts/sql/generator.py
+++ b/scripts/sql/generator.py
@@ -34,11 +34,17 @@ def parse_args():
         required=True,
         help='C++ namespace to use',
     )
+    parser.add_argument(
+        '--source-dir',
+        type=str,
+        required=True,
+        help='path to the directory with .sql files',
+    )
     parser.add_argument(
         '--output-dir',
         type=str,
         required=True,
-        help='full path to output .hpp file',
+        help='path to the directory with .hpp-.cpp files to generate',
     )
     parser.add_argument(
         '--query-log-mode',
@@ -53,7 +59,7 @@ def parse_args():
         required=True,
         help='full path to generated tests',
     )
-    parser.add_argument('files', nargs='*', help='input .sql files to process')
+    parser.add_argument('files', nargs='*', help='input .sql files to process (relative to the cwd, not source-dir)')
     return parser.parse_args()
 
 
@@ -97,7 +103,7 @@ def read_items(args) -> List[SqlQuery]:
         name = pathlib.Path(filename).stem  # TODO: CamelCase
         items.append(
             SqlQuery(
-                source=filename,
+                source=os.path.relpath(filename, args.source_dir),
                 contents=content,
                 name=name,
                 variable=('k' + camel_case(name)),
diff --git a/security/authentication.md b/security/authentication.md
new file mode 100644
index 000000000000..87ee2efab598
--- /dev/null
+++ b/security/authentication.md
@@ -0,0 +1,721 @@
+# Authentication Patterns
+
+## Overview
+
+Comprehensive authentication patterns for userver applications, covering JWT token authentication, API key authentication, OAuth2 integration, session management, and multi-factor authentication patterns.
+
+## Core Authentication Components
+
+### JWT Authentication
+- [`crypto::jwt::Jwt`](https://userver.tech/d7/d32/classcrypto_1_1jwt_1_1Jwt.html) - JWT token handling and validation
+- [`server::handlers::auth::AuthCheckerBase`](https://userver.tech/d6/db7/classserver_1_1handlers_1_1auth_1_1AuthCheckerBase.html) - Base class for custom authentication checkers
+- [`crypto::algorithm::StringsEqualConstTimeComparator`](https://userver.tech/de/d55/structcrypto_1_1algorithm_1_1StringsEqualConstTimeComparator.html) - Timing attack prevention for token comparison
+
+### API Key Authentication
+- [`components::PostgreCache`](https://userver.tech/d2/d8d/classcomponents_1_1PostgreCache.html) - Caching authentication data
+- [`server::auth::UserAuthInfo::Ticket`](https://userver.tech/d4/d67/classutils_1_1StrongTypedef.html) - Strongly typed authentication tickets
+- [`crypto::algorithm`](https://userver.tech/de/d55/algorithm_8hpp.html) - Cryptographic algorithms for secure comparisons
+
+### OAuth2 Integration
+- [`clients::http::Client`](https://userver.tech/d5/dee/classclients_1_1http_1_1Client.html) - HTTP client for OAuth2 provider communication
+- [`formats::json`](https://userver.tech/d2/d20/md_en_2userver_2formats.html) - JSON parsing for OAuth2 responses
+- [`server::http::HttpRequest`](https://userver.tech/d3/d44/classserver_1_1http_1_1HttpRequest.html) - HTTP request handling for OAuth2 flows
+
+## JWT Authentication Implementation
+
+### JWT Token Structure and Validation
+```cpp
+#include <userver/crypto/jwt/jwt.hpp>
+#include <userver/crypto/algorithm.hpp>
+#include <userver/server/handlers/auth/auth_checker_base.hpp>
+#include <userver/formats/json.hpp>
+
+class JwtAuthChecker : public server::handlers::auth::AuthCheckerBase {
+public:
+  using AuthCheckResult = server::handlers::auth::AuthCheckResult;
+  
+  JwtAuthChecker(const components::ComponentConfig& config,
+                 const components::ComponentContext& context)
+    : AuthCheckerBase(config, context) {
+    
+    jwt_secret_ = config["jwt-secret"].As<std::string>();
+    jwt_algorithm_ = config["jwt-algorithm"].As<std::string>("HS256");
+    token_expiry_seconds_ = config["token-expiry"].As<int>(3600);
+  }
+  
+  AuthCheckResult CheckAuth(const server::http::HttpRequest& request,
+                           server::request::RequestContext& context) const override {
+    try {
+      // Extract JWT token from Authorization header
+      auto auth_header = request.GetHeader("Authorization");
+      if (auth_header.empty()) {
+        return AuthCheckResult::kTokenNotFound;
+      }
+      
+      if (!auth_header.starts_with("Bearer ")) {
+        return AuthCheckResult::kTokenNotFound;
+      }
+      
+      auto token = auth_header.substr(7); // Remove "Bearer " prefix
+      
+      // Verify JWT token
+      auto jwt = crypto::jwt::Jwt::Parse(token);
+      if (!jwt.Verify(jwt_secret_, jwt_algorithm_)) {
+        return AuthCheckResult::kTokenInvalid;
+      }
+      
+      // Check expiration
+      auto exp_claim = jwt.GetPayloadClaim("exp");
+      if (exp_claim.has_value()) {
+        auto exp_time = std::chrono::system_clock::from_time_t(exp_claim->As<int64_t>());
+        if (std::chrono::system_clock::now() > exp_time) {
+          return AuthCheckResult::kTokenExpired;
+        }
+      }
+      
+      // Extract user information
+      auto user_id = jwt.GetPayloadClaim("sub");
+      auto roles = jwt.GetPayloadClaim("roles");
+      
+      if (user_id.has_value()) {
+        context.SetData("user_id", user_id->As<std::string>());
+      }
+      
+      if (roles.has_value()) {
+        context.SetData("user_roles", roles->As<std::vector<std::string>>());
+      }
+      
+      return AuthCheckResult::kOk;
+      
+    } catch (const std::exception& e) {
+      LOG_WARNING() << "JWT authentication failed: " << e.what();
+      return AuthCheckResult::kTokenInvalid;
+    }
+  }
+  
+  bool SupportsUserAuth() const noexcept override { return true; }
+
+private:
+  std::string jwt_secret_;
+  std::string jwt_algorithm_;
+  int token_expiry_seconds_;
+};
+```
+
+### JWT Token Generation
+```cpp
+#include <userver/crypto/jwt/jwt.hpp>
+#include <userver/formats/json.hpp>
+
+class JwtTokenGenerator {
+public:
+  JwtTokenGenerator(const std::string& secret, const std::string& algorithm = "HS256")
+    : secret_(secret), algorithm_(algorithm) {}
+  
+  std::string GenerateToken(const std::string& user_id,
+                           const std::vector<std::string>& roles,
+                           int expiry_seconds = 3600) {
+    auto jwt = crypto::jwt::Jwt::Create();
+    
+    // Set standard claims
+    jwt.SetSubject(user_id);
+    jwt.SetIssuedAt(std::chrono::system_clock::now());
+    jwt.SetExpiration(std::chrono::system_clock::now() + 
+                     std::chrono::seconds(expiry_seconds));
+    
+    // Set custom claims
+    jwt.SetPayloadClaim("roles", formats::json::ValueBuilder(roles).ExtractValue());
+    
+    // Sign and return token
+    return jwt.Sign(secret_, algorithm_);
+  }
+
+private:
+  std::string secret_;
+  std::string algorithm_;
+};
+```
+
+## API Key Authentication Implementation
+
+### API Key Authentication Checker
+```cpp
+#include <userver/server/handlers/auth/auth_checker_base.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/crypto/algorithm.hpp>
+
+class ApiKeyAuthChecker : public server::handlers::auth::AuthCheckerBase {
+public:
+  ApiKeyAuthChecker(const components::ComponentConfig& config,
+                    const components::ComponentContext& context)
+    : AuthCheckerBase(config, context) {
+    
+    // Load API keys from configuration or database
+    LoadApiKeys(config);
+  }
+  
+  AuthCheckResult CheckAuth(const server::http::HttpRequest& request,
+                           server::request::RequestContext& context) const override {
+    // Try different API key locations
+    std::string api_key;
+    
+    // 1. Check X-API-Key header
+    api_key = request.GetHeader("X-API-Key");
+    
+    // 2. Check Authorization header with API key scheme
+    if (api_key.empty()) {
+      auto auth_header = request.GetHeader("Authorization");
+      if (auth_header.starts_with("ApiKey ")) {
+        api_key = auth_header.substr(7);
+      }
+    }
+    
+    // 3. Check query parameter
+    if (api_key.empty()) {
+      api_key = request.GetArg("api_key");
+    }
+    
+    if (api_key.empty()) {
+      return AuthCheckResult::kTokenNotFound;
+    }
+    
+    // Validate API key
+    auto api_keys = api_keys_.Lock();
+    auto it = api_keys->find(api_key);
+    
+    if (it == api_keys->end()) {
+      RecordFailedAuth(request.GetRemoteAddress(), "invalid_api_key");
+      return AuthCheckResult::kTokenInvalid;
+    }
+    
+    const auto& key_info = it->second;
+    
+    // Check if key is active
+    if (!key_info.is_active) {
+      return AuthCheckResult::kTokenInvalid;
+    }
+    
+    // Check expiration
+    auto now = std::chrono::system_clock::now();
+    if (key_info.expires_at && now > *key_info.expires_at) {
+      return AuthCheckResult::kTokenExpired;
+    }
+    
+    // Check rate limits
+    if (!CheckRateLimit(api_key, key_info.rate_limit)) {
+      return AuthCheckResult::kRateLimited;
+    }
+    
+    // Set context data
+    context.SetData("api_key_id", key_info.id);
+    context.SetData("client_name", key_info.client_name);
+    context.SetData("permissions", key_info.permissions);
+    
+    RecordSuccessfulAuth(api_key);
+    
+    return AuthCheckResult::kOk;
+  }
+
+private:
+  struct ApiKeyInfo {
+    std::string id;
+    std::string client_name;
+    bool is_active = true;
+    std::optional<std::chrono::system_clock::time_point> expires_at;
+    std::vector<std::string> permissions;
+    int rate_limit = 1000; // requests per hour
+  };
+  
+  void LoadApiKeys(const components::ComponentConfig& config) {
+    auto keys_config = config["api-keys"];
+    auto keys = api_keys_.Lock();
+    
+    for (const auto& [key, info] : keys_config.Items()) {
+      ApiKeyInfo key_info;
+      key_info.id = info["id"].As<std::string>();
+      key_info.client_name = info["client-name"].As<std::string>();
+      key_info.is_active = info["active"].As<bool>(true);
+      key_info.permissions = info["permissions"].As<std::vector<std::string>>();
+      key_info.rate_limit = info["rate-limit"].As<int>(1000);
+      
+      (*keys)[key] = std::move(key_info);
+    }
+  }
+  
+  bool CheckRateLimit(const std::string& api_key, int limit) const {
+    // Implement rate limiting logic
+    // This is a simplified example
+    return true;
+  }
+  
+  void RecordFailedAuth(const std::string& remote_addr, const std::string& reason) const {
+    LOG_WARNING() << "Failed API key authentication from " << remote_addr 
+                  << ", reason: " << reason;
+  }
+  
+  void RecordSuccessfulAuth(const std::string& api_key) const {
+    // Record successful authentication for monitoring
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, ApiKeyInfo>> api_keys_;
+};
+```
+
+## OAuth2 Authentication Implementation
+
+### OAuth2 Authorization Code Flow
+```cpp
+#include <userver/clients/http/client.hpp>
+#include <userver/formats/json.hpp>
+#include <userver/server/handlers/http_handler_base.hpp>
+
+class OAuth2Handler : public server::handlers::HttpHandlerBase {
+public:
+  static constexpr std::string_view kName = "handler-oauth2";
+  
+  OAuth2Handler(const components::ComponentConfig& config,
+                const components::ComponentContext& context)
+    : HttpHandlerBase(config, context),
+      http_client_(context.FindComponent<clients::http::Client>()),
+      client_id_(config["client-id"].As<std::string>()),
+      client_secret_(config["client-secret"].As<std::string>()),
+      redirect_uri_(config["redirect-uri"].As<std::string>()),
+      auth_provider_url_(config["auth-provider-url"].As<std::string>()),
+      token_endpoint_(config["token-endpoint"].As<std::string>()) {}
+  
+  std::string HandleRequestThrow(const server::http::HttpRequest& request,
+                                server::request::RequestContext&) const override {
+    if (request.GetMethod() == server::http::HttpMethod::kGet) {
+      // Authorization request - redirect to OAuth2 provider
+      return HandleAuthorizationRequest(request);
+    } else if (request.GetMethod() == server::http::HttpMethod::kPost) {
+      // Token exchange - handle callback from OAuth2 provider
+      return HandleTokenExchange(request);
+    }
+    
+    throw server::handlers::ClientError(
+      server::handlers::HandlerErrorCode::kMethodNotAllowed,
+      "Method not allowed"
+    );
+  }
+
+private:
+  std::string HandleAuthorizationRequest(const server::http::HttpRequest& request) const {
+    // Generate state parameter for CSRF protection
+    auto state = GenerateRandomState();
+    
+    // Store state in session or cache for validation
+    StoreState(state, request.GetRemoteAddress());
+    
+    // Build authorization URL
+    std::string auth_url = auth_provider_url_ + 
+      "?response_type=code" +
+      "&client_id=" + client_id_ +
+      "&redirect_uri=" + redirect_uri_ +
+      "&state=" + state +
+      "&scope=read write";
+    
+    // Redirect to OAuth2 provider
+    request.GetHttpResponse().SetStatus(server::http::HttpStatus::kFound);
+    request.GetHttpResponse().SetHeader("Location", auth_url);
+    
+    return "";
+  }
+  
+  std::string HandleTokenExchange(const server::http::HttpRequest& request) const {
+    auto code = request.GetArg("code");
+    auto state = request.GetArg("state");
+    
+    // Validate state parameter
+    if (!ValidateState(state, request.GetRemoteAddress())) {
+      throw server::handlers::ClientError(
+        server::handlers::HandlerErrorCode::kBadRequest,
+        "Invalid state parameter"
+      );
+    }
+    
+    // Exchange authorization code for access token
+    auto token_response = ExchangeCodeForToken(code);
+    
+    // Store tokens in session or database
+    auto user_info = GetUserInfo(token_response.access_token);
+    StoreUserSession(user_info, token_response);
+    
+    // Redirect to application
+    request.GetHttpResponse().SetStatus(server::http::HttpStatus::kFound);
+    request.GetHttpResponse().SetHeader("Location", "/dashboard");
+    
+    return "";
+  }
+  
+  struct TokenResponse {
+    std::string access_token;
+    std::string refresh_token;
+    int expires_in;
+    std::string token_type;
+  };
+  
+  TokenResponse ExchangeCodeForToken(const std::string& code) const {
+    formats::json::ValueBuilder request_body;
+    request_body["grant_type"] = "authorization_code";
+    request_body["code"] = code;
+    request_body["redirect_uri"] = redirect_uri_;
+    request_body["client_id"] = client_id_;
+    request_body["client_secret"] = client_secret_;
+    
+    auto response = http_client_.CreatePost(token_endpoint_)
+      .body(formats::json::ToString(request_body.ExtractValue()))
+      .header("Content-Type", "application/x-www-form-urlencoded")
+      .timeout(std::chrono::seconds(30))
+      .perform();
+    
+    if (response->GetStatusCode() != 200) {
+      throw std::runtime_error("Token exchange failed: " + 
+                              std::to_string(response->GetStatusCode()));
+    }
+    
+    auto json_response = formats::json::FromString(response->GetBody());
+    
+    TokenResponse token_response;
+    token_response.access_token = json_response["access_token"].As<std::string>();
+    token_response.refresh_token = json_response["refresh_token"].As<std::string>("");
+    token_response.expires_in = json_response["expires_in"].As<int>();
+    token_response.token_type = json_response["token_type"].As<std::string>();
+    
+    return token_response;
+  }
+  
+  struct UserInfo {
+    std::string user_id;
+    std::string email;
+    std::string name;
+    std::vector<std::string> roles;
+  };
+  
+  UserInfo GetUserInfo(const std::string& access_token) const {
+    auto response = http_client_.CreateGet(auth_provider_url_ + "/userinfo")
+      .header("Authorization", "Bearer " + access_token)
+      .timeout(std::chrono::seconds(30))
+      .perform();
+    
+    if (response->GetStatusCode() != 200) {
+      throw std::runtime_error("Failed to get user info: " + 
+                              std::to_string(response->GetStatusCode()));
+    }
+    
+    auto json_response = formats::json::FromString(response->GetBody());
+    
+    UserInfo user_info;
+    user_info.user_id = json_response["sub"].As<std::string>();
+    user_info.email = json_response["email"].As<std::string>();
+    user_info.name = json_response["name"].As<std::string>();
+    // Extract roles from claims
+    
+    return user_info;
+  }
+  
+  std::string GenerateRandomState() const {
+    // Generate cryptographically secure random state
+    return "random_state_string"; // Simplified for example
+  }
+  
+  void StoreState(const std::string& state, const std::string& remote_addr) const {
+    // Store state for validation
+  }
+  
+  bool ValidateState(const std::string& state, const std::string& remote_addr) const {
+    // Validate state parameter
+    return true; // Simplified for example
+  }
+  
+  void StoreUserSession(const UserInfo& user_info, const TokenResponse& tokens) const {
+    // Store user session
+  }
+  
+  const clients::http::Client& http_client_;
+  std::string client_id_;
+  std::string client_secret_;
+  std::string redirect_uri_;
+  std::string auth_provider_url_;
+  std::string token_endpoint_;
+};
+```
+
+## Session Management Implementation
+
+### Secure Session Handler
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/crypto/algorithm.hpp>
+
+class SessionManager {
+public:
+  struct SessionData {
+    std::string user_id;
+    std::vector<std::string> roles;
+    std::chrono::system_clock::time_point created_at;
+    std::chrono::system_clock::time_point expires_at;
+    std::string remote_address;
+  };
+  
+  SessionManager(const components::ComponentConfig& config,
+                 const components::ComponentContext& context)
+    : session_timeout_(config["session-timeout"].As<int>(3600)) {}
+  
+  std::string CreateSession(const std::string& user_id,
+                           const std::vector<std::string>& roles,
+                           const std::string& remote_address) {
+    auto session_id = GenerateSecureSessionId();
+    
+    SessionData session_data;
+    session_data.user_id = user_id;
+    session_data.roles = roles;
+    session_data.created_at = std::chrono::system_clock::now();
+    session_data.expires_at = session_data.created_at + 
+                             std::chrono::seconds(session_timeout_);
+    session_data.remote_address = remote_address;
+    
+    auto sessions = sessions_.Lock();
+    (*sessions)[session_id] = std::move(session_data);
+    
+    return session_id;
+  }
+  
+  std::optional<SessionData> ValidateSession(const std::string& session_id,
+                                            const std::string& remote_address) {
+    auto sessions = sessions_.Lock();
+    auto it = sessions->find(session_id);
+    
+    if (it == sessions->end()) {
+      return std::nullopt;
+    }
+    
+    auto& session_data = it->second;
+    
+    // Check expiration
+    if (std::chrono::system_clock::now() > session_data.expires_at) {
+      sessions->erase(it);
+      return std::nullopt;
+    }
+    
+    // Check IP address binding (optional security feature)
+    if (!session_data.remote_address.empty() && 
+        session_data.remote_address != remote_address) {
+      // Session hijacking attempt
+      sessions->erase(it);
+      return std::nullopt;
+    }
+    
+    return session_data;
+  }
+  
+  void DestroySession(const std::string& session_id) {
+    auto sessions = sessions_.Lock();
+    sessions->erase(session_id);
+  }
+  
+  void CleanupExpiredSessions() {
+    auto sessions = sessions_.Lock();
+    auto now = std::chrono::system_clock::now();
+    
+    for (auto it = sessions->begin(); it != sessions->end();) {
+      if (now > it->second.expires_at) {
+        it = sessions->erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
+private:
+  std::string GenerateSecureSessionId() const {
+    // Generate cryptographically secure session ID
+    return "secure_session_id"; // Simplified for example
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, SessionData>> sessions_;
+  int session_timeout_;
+};
+```
+
+## Multi-Factor Authentication Implementation
+
+### TOTP (Time-based One-Time Password) Implementation
+```cpp
+#include <userver/crypto/hmac.hpp>
+#include <userver/formats/json.hpp>
+
+class TotpAuthenticator {
+public:
+  static constexpr int TIME_STEP = 30; // 30 seconds
+  static constexpr int CODE_DIGITS = 6;
+  
+  TotpAuthenticator(const std::string& secret)
+    : secret_(secret) {}
+  
+  std::string GenerateSecret() {
+    // Generate base32 encoded secret
+    return "base32_encoded_secret"; // Simplified for example
+  }
+  
+  std::string GenerateTotp() const {
+    auto counter = GetCurrentCounter();
+    return GenerateHotp(counter);
+  }
+  
+  bool ValidateTotp(const std::string& totp_code) const {
+    auto counter = GetCurrentCounter();
+    
+    // Check current and previous time steps for clock drift tolerance
+    for (int i = -1; i <= 1; ++i) {
+      auto code = GenerateHotp(counter + i);
+      if (crypto::algorithm::StringsEqualConstTimeComparator{}(code, totp_code)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  std::string GetQrCodeUrl(const std::string& user, 
+                          const std::string& issuer) const {
+    // Generate QR code URL for authenticator apps
+    return "otpauth://totp/" + issuer + ":" + user + 
+           "?secret=" + secret_ + 
+           "&issuer=" + issuer +
+           "&algorithm=SHA1&digits=6&period=30";
+  }
+
+private:
+  uint64_t GetCurrentCounter() const {
+    auto now = std::chrono::duration_cast<std::chrono::seconds>(
+      std::chrono::system_clock::now().time_since_epoch()
+    ).count();
+    
+    return now / TIME_STEP;
+  }
+  
+  std::string GenerateHotp(uint64_t counter) const {
+    // Convert counter to big-endian bytes
+    std::array<uint8_t, 8> counter_bytes = {
+      static_cast<uint8_t>(counter >> 56),
+      static_cast<uint8_t>(counter >> 48),
+      static_cast<uint8_t>(counter >> 40),
+      static_cast<uint8_t>(counter >> 32),
+      static_cast<uint8_t>(counter >> 24),
+      static_cast<uint8_t>(counter >> 16),
+      static_cast<uint8_t>(counter >> 8),
+      static_cast<uint8_t>(counter)
+    };
+    
+    // Generate HMAC-SHA1
+    auto hmac = crypto::hmac::HmacSha1(secret_, 
+                                      std::string_view(reinterpret_cast<const char*>(counter_bytes.data()), 
+                                                      counter_bytes.size()));
+    
+    // Dynamic truncation
+    uint8_t offset = hmac[19] & 0x0F;
+    uint32_t binary = ((hmac[offset] & 0x7F) << 24) |
+                      ((hmac[offset + 1] & 0xFF) << 16) |
+                      ((hmac[offset + 2] & 0xFF) << 8) |
+                      (hmac[offset + 3] & 0xFF);
+    
+    // Generate code
+    uint32_t code = binary % static_cast<uint32_t>(std::pow(10, CODE_DIGITS));
+    
+    // Pad with leading zeros
+    return fmt::format("{:06d}", code);
+  }
+  
+  std::string secret_;
+};
+```
+
+## Authentication Configuration
+
+### Static Configuration
+```yaml
+# Authentication component configuration
+auth-jwt:
+  jwt-secret: "your-jwt-secret-key"
+  jwt-algorithm: "HS256"
+  token-expiry: 3600
+
+auth-api-keys:
+  api-keys:
+    client1-api-key:
+      id: "client1"
+      client-name: "Client One"
+      active: true
+      permissions: ["read", "write"]
+      rate-limit: 1000
+    client2-api-key:
+      id: "client2"
+      client-name: "Client Two"
+      active: true
+      permissions: ["read"]
+      rate-limit: 500
+
+auth-oauth2:
+  client-id: "your-client-id"
+  client-secret: "your-client-secret"
+  redirect-uri: "https://your-app.com/oauth2/callback"
+  auth-provider-url: "https://oauth2-provider.com"
+  token-endpoint: "https://oauth2-provider.com/token"
+
+auth-session:
+  session-timeout: 3600
+  bind-to-ip: true
+
+auth-totp:
+  time-step: 30
+  code-digits: 6
+```
+
+### Handler Authentication Configuration
+```yaml
+# Handler-specific authentication configuration
+handler-protected-api:
+  path: /api/protected
+  task_processor: main-task-processor
+  method: GET,POST
+  auth:
+    types: [bearer, api-key]
+    scopes: [read, write]
+
+handler-public-api:
+  path: /api/public
+  task_processor: main-task-processor
+  method: GET
+  auth:
+    types: [bearer, api-key]
+    scopes: [read]
+    optional: true
+
+handler-oauth2-callback:
+  path: /oauth2/callback
+  task_processor: main-task-processor
+  method: GET,POST
+  auth:
+    types: []
+```
+
+## Cross-References
+
+### Related Framework Components
+- [Network Security Patterns](../../networking/network-security.md) - TLS/SSL, rate limiting, input validation
+- [HTTP Server Security](../../networking/http-https.md) - HTTPS configuration, security headers
+- [Component System](../../../memory-bank/main/component-system.md) - Authentication component integration
+- [Framework Core](../../../memory-bank/main/framework-core.md) - Core security primitives
+
+### Security Best Practices
+- [Security Best Practices](security-best-practices.md) - Input validation, output encoding, security headers
+- [Vulnerability Prevention](vulnerability-prevention.md) - Common vulnerabilities and prevention strategies
+- [Encryption Patterns](encryption.md) - TLS/SSL, data encryption, key management
+
+### Implementation References
+- [`server::handlers::auth::AuthCheckerBase`](https://userver.tech/d6/db7/classserver_1_1handlers_1_1auth_1_1AuthCheckerBase.html)
+- [`crypto::jwt::Jwt`](https://userver.tech/d7/d32/classcrypto_1_1jwt_1_1Jwt.html)
+- [`components::PostgreCache`](https://userver.tech/d2/d8d/classcomponents_1_1PostgreCache.html)
+- [`clients::http::Client`](https://userver.tech/d5/dee/classclients_1_1http_1_1Client.html)
\ No newline at end of file
diff --git a/security/authorization.md b/security/authorization.md
new file mode 100644
index 000000000000..a50389ceaa6b
--- /dev/null
+++ b/security/authorization.md
@@ -0,0 +1,809 @@
+# Authorization Patterns
+
+## Overview
+
+Comprehensive authorization patterns for userver applications, covering Role-Based Access Control (RBAC), Attribute-Based Access Control (ABAC), permission management, resource-level authorization, and API endpoint protection.
+
+## Core Authorization Components
+
+### Role-Based Access Control (RBAC)
+- [`server::auth::UserScope`](https://userver.tech/d4/d67/classutils_1_1StrongTypedef.html) - Strongly typed user scopes/roles
+- [`server::handlers::auth::AuthCheckerBase`](https://userver.tech/d6/db7/classserver_1_1handlers_1_1auth_1_1AuthCheckerBase.html) - Base class for authorization checkers
+- [`server::request::RequestContext`](https://userver.tech/de/df6/classserver_1_1request_1_1RequestContext.html) - Request context for storing authorization data
+
+### Attribute-Based Access Control (ABAC)
+- [`formats::json::Value`](https://userver.tech/d2/d20/md_en_2userver_2formats.html) - JSON value handling for policy definitions
+- [`concurrent::Variable`](https://userver.tech/d8/dcc/namespaceconcurrent.html) - Thread-safe policy storage
+- [`crypto::algorithm`](https://userver.tech/de/d55/algorithm_8hpp.html) - Cryptographic algorithms for secure comparisons
+
+### Permission Management
+- [`components::PostgreCache`](https://userver.tech/d2/d8d/classcomponents_1_1PostgreCache.html) - Caching authorization policies
+- [`server::auth::UserAuthInfo`](https://userver.tech/d4/d67/classutils_1_1StrongTypedef.html) - User authentication information
+- [`utils::Async`](https://userver.tech/dc/db7/group__userver__concurrency.html#ga29b9a09eacda1ddf8b4440b3713f5e52) - Asynchronous policy updates
+
+## Role-Based Access Control (RBAC) Implementation
+
+### RBAC Core Components
+```cpp
+#include <userver/server/auth/user_auth_info.hpp>
+#include <userver/server/handlers/auth/auth_checker_base.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/formats/json.hpp>
+
+// Role definitions
+enum class UserRole {
+  kAdmin,
+  kUser,
+  kModerator,
+  kGuest
+};
+
+// Permission definitions
+enum class Permission {
+  kRead,
+  kWrite,
+  kDelete,
+  kAdminAccess,
+  kModerateContent
+};
+
+// Role-Permission mapping
+class RolePermissionManager {
+public:
+  RolePermissionManager() {
+    // Initialize role-permission mappings
+    role_permissions_[UserRole::kAdmin] = {
+      Permission::kRead, Permission::kWrite, Permission::kDelete,
+      Permission::kAdminAccess, Permission::kModerateContent
+    };
+    
+    role_permissions_[UserRole::kUser] = {
+      Permission::kRead, Permission::kWrite
+    };
+    
+    role_permissions_[UserRole::kModerator] = {
+      Permission::kRead, Permission::kWrite, Permission::kModerateContent
+    };
+    
+    role_permissions_[UserRole::kGuest] = {
+      Permission::kRead
+    };
+  }
+  
+  bool HasPermission(UserRole role, Permission permission) const {
+    auto it = role_permissions_.find(role);
+    if (it == role_permissions_.end()) {
+      return false;
+    }
+    
+    const auto& permissions = it->second;
+    return std::find(permissions.begin(), permissions.end(), permission) != 
+           permissions.end();
+  }
+  
+  std::vector<Permission> GetPermissions(UserRole role) const {
+    auto it = role_permissions_.find(role);
+    if (it != role_permissions_.end()) {
+      return it->second;
+    }
+    return {};
+  }
+
+private:
+  std::unordered_map<UserRole, std::vector<Permission>> role_permissions_;
+};
+
+// User-Role mapping with caching
+struct UserRoles {
+  std::vector<UserRole> roles;
+  std::chrono::system_clock::time_point last_updated;
+  std::chrono::seconds cache_ttl{300}; // 5 minutes
+};
+
+class UserRoleCache {
+public:
+  UserRoleCache(const components::ComponentConfig& config,
+                const components::ComponentContext& context)
+    : cache_ttl_(config["cache-ttl"].As<int>(300)) {
+    // Initialize database connection or other dependencies
+  }
+  
+  std::vector<UserRole> GetUserRoles(const std::string& user_id) {
+    auto cache = user_roles_cache_.Lock();
+    
+    auto it = cache->find(user_id);
+    if (it != cache->end()) {
+      auto& user_roles = it->second;
+      auto now = std::chrono::system_clock::now();
+      
+      // Check if cache is still valid
+      if (now - user_roles.last_updated < user_roles.cache_ttl) {
+        return user_roles.roles;
+      }
+    }
+    
+    // Cache miss or expired - fetch from database
+    auto roles = FetchUserRolesFromDatabase(user_id);
+    
+    // Update cache
+    UserRoles user_roles;
+    user_roles.roles = roles;
+    user_roles.last_updated = std::chrono::system_clock::now();
+    user_roles.cache_ttl = cache_ttl_;
+    
+    (*cache)[user_id] = std::move(user_roles);
+    
+    return roles;
+  }
+  
+  void InvalidateUserRoles(const std::string& user_id) {
+    auto cache = user_roles_cache_.Lock();
+    cache->erase(user_id);
+  }
+
+private:
+  std::vector<UserRole> FetchUserRolesFromDatabase(const std::string& user_id) {
+    // Implementation to fetch user roles from database
+    // This is a simplified example
+    return {UserRole::kUser};
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, UserRoles>> user_roles_cache_;
+  std::chrono::seconds cache_ttl_;
+};
+```
+
+### RBAC Authorization Checker
+```cpp
+#include <userver/server/handlers/auth/auth_checker_base.hpp>
+#include <userver/server/auth/user_auth_info.hpp>
+
+class RbacAuthChecker : public server::handlers::auth::AuthCheckerBase {
+public:
+  using AuthCheckResult = server::handlers::auth::AuthCheckResult;
+  
+  RbacAuthChecker(const components::ComponentConfig& config,
+                  const components::ComponentContext& context)
+    : AuthCheckerBase(config, context),
+      role_permission_manager_(std::make_unique<RolePermissionManager>()),
+      user_role_cache_(std::make_unique<UserRoleCache>(config, context)) {
+    
+    // Parse required roles from configuration
+    auto required_roles_config = config["required-roles"];
+    for (const auto& role : required_roles_config.As<std::vector<std::string>>()) {
+      required_roles_.push_back(ParseUserRole(role));
+    }
+  }
+  
+  AuthCheckResult CheckAuth(const server::http::HttpRequest& request,
+                           server::request::RequestContext& context) const override {
+    try {
+      // Get user ID from authentication context
+      auto user_id_opt = context.GetData<std::string>("user_id");
+      if (!user_id_opt.has_value()) {
+        return AuthCheckResult::kUserNotFound;
+      }
+      
+      auto user_id = user_id_opt.value();
+      
+      // Get user roles
+      auto user_roles = user_role_cache_->GetUserRoles(user_id);
+      
+      // Check if user has any of the required roles
+      bool has_required_role = false;
+      for (const auto& required_role : required_roles_) {
+        if (std::find(user_roles.begin(), user_roles.end(), required_role) != 
+            user_roles.end()) {
+          has_required_role = true;
+          break;
+        }
+      }
+      
+      if (!has_required_role) {
+        return AuthCheckResult::kForbidden;
+      }
+      
+      // Store user roles in context for further authorization checks
+      context.SetData("user_roles", user_roles);
+      
+      return AuthCheckResult::kOk;
+      
+    } catch (const std::exception& e) {
+      LOG_WARNING() << "RBAC authorization failed: " << e.what();
+      return AuthCheckResult::kForbidden;
+    }
+  }
+  
+  bool SupportsUserAuth() const noexcept override { return true; }
+
+private:
+  UserRole ParseUserRole(const std::string& role_str) const {
+    if (role_str == "admin") return UserRole::kAdmin;
+    if (role_str == "user") return UserRole::kUser;
+    if (role_str == "moderator") return UserRole::kModerator;
+    if (role_str == "guest") return UserRole::kGuest;
+    
+    throw std::invalid_argument("Unknown role: " + role_str);
+  }
+  
+  std::unique_ptr<RolePermissionManager> role_permission_manager_;
+  std::unique_ptr<UserRoleCache> user_role_cache_;
+  std::vector<UserRole> required_roles_;
+};
+```
+
+## Attribute-Based Access Control (ABAC) Implementation
+
+### ABAC Policy Engine
+```cpp
+#include <userver/formats/json.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/crypto/algorithm.hpp>
+
+// Policy definition
+struct AbacPolicy {
+  std::string id;
+  std::string description;
+  std::unordered_map<std::string, std::string> conditions;
+  std::vector<std::string> permissions;
+  std::chrono::system_clock::time_point created_at;
+  bool is_active = true;
+};
+
+// Resource definition
+struct Resource {
+  std::string type;
+  std::string id;
+  std::unordered_map<std::string, std::string> attributes;
+};
+
+// Subject definition (user or service)
+struct Subject {
+  std::string id;
+  std::string type; // user, service, etc.
+  std::unordered_map<std::string, std::string> attributes;
+};
+
+class AbacPolicyEngine {
+public:
+  AbacPolicyEngine(const components::ComponentConfig& config,
+                   const components::ComponentContext& context)
+    : policy_cache_ttl_(config["policy-cache-ttl"].As<int>(300)) {}
+  
+  bool CheckAccess(const Subject& subject, 
+                   const Resource& resource, 
+                   const std::string& action) {
+    // Get applicable policies
+    auto policies = GetApplicablePolicies(subject, resource, action);
+    
+    // Evaluate policies
+    for (const auto& policy : policies) {
+      if (EvaluatePolicy(policy, subject, resource, action)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  void AddPolicy(const AbacPolicy& policy) {
+    auto policies = policies_.Lock();
+    (*policies)[policy.id] = policy;
+    
+    // Invalidate cache for this resource type
+    InvalidatePolicyCache(policy);
+  }
+  
+  void RemovePolicy(const std::string& policy_id) {
+    auto policies = policies_.Lock();
+    policies->erase(policy_id);
+    
+    // Invalidate related caches
+    InvalidateAllCaches();
+  }
+
+private:
+  std::vector<AbacPolicy> GetApplicablePolicies(const Subject& subject,
+                                               const Resource& resource,
+                                               const std::string& action) {
+    // Check cache first
+    std::string cache_key = GenerateCacheKey(subject, resource, action);
+    auto cache = policy_cache_.Lock();
+    
+    auto it = cache->find(cache_key);
+    if (it != cache->end()) {
+      auto& cached_result = it->second;
+      auto now = std::chrono::system_clock::now();
+      
+      if (now - cached_result.timestamp < policy_cache_ttl_) {
+        return cached_result.policies;
+      }
+    }
+    
+    // Cache miss or expired - evaluate all policies
+    std::vector<AbacPolicy> applicable_policies;
+    
+    auto policies = policies_.Lock();
+    for (const auto& [id, policy] : *policies) {
+      if (!policy.is_active) continue;
+      
+      if (IsPolicyApplicable(policy, subject, resource, action)) {
+        applicable_policies.push_back(policy);
+      }
+    }
+    
+    // Cache the result
+    CachedPolicyResult result;
+    result.policies = applicable_policies;
+    result.timestamp = std::chrono::system_clock::now();
+    
+    (*cache)[cache_key] = std::move(result);
+    
+    return applicable_policies;
+  }
+  
+  bool EvaluatePolicy(const AbacPolicy& policy,
+                     const Subject& subject,
+                     const Resource& resource,
+                     const std::string& action) const {
+    // Evaluate all conditions
+    for (const auto& [attribute, expected_value] : policy.conditions) {
+      std::string actual_value;
+      
+      // Check subject attributes
+      auto subject_it = subject.attributes.find(attribute);
+      if (subject_it != subject.attributes.end()) {
+        actual_value = subject_it->second;
+      } else {
+        // Check resource attributes
+        auto resource_it = resource.attributes.find(attribute);
+        if (resource_it != resource.attributes.end()) {
+          actual_value = resource_it->second;
+        } else {
+          // Attribute not found - policy doesn't apply
+          return false;
+        }
+      }
+      
+      // Check condition (simple equality for this example)
+      if (actual_value != expected_value) {
+        return false;
+      }
+    }
+    
+    // All conditions met - check if action is permitted
+    return std::find(policy.permissions.begin(), policy.permissions.end(), action) != 
+           policy.permissions.end();
+  }
+  
+  bool IsPolicyApplicable(const AbacPolicy& policy,
+                         const Subject& subject,
+                         const Resource& resource,
+                         const std::string& action) const {
+    // Simple applicability check - in a real implementation, this would be more complex
+    return true;
+  }
+  
+  std::string GenerateCacheKey(const Subject& subject,
+                              const Resource& resource,
+                              const std::string& action) const {
+    return subject.id + ":" + resource.type + ":" + resource.id + ":" + action;
+  }
+  
+  void InvalidatePolicyCache(const AbacPolicy& policy) {
+    // Invalidate cache entries related to this policy
+    auto cache = policy_cache_.Lock();
+    // Implementation depends on policy structure
+  }
+  
+  void InvalidateAllCaches() {
+    auto cache = policy_cache_.Lock();
+    cache->clear();
+  }
+  
+  struct CachedPolicyResult {
+    std::vector<AbacPolicy> policies;
+    std::chrono::system_clock::time_point timestamp;
+  };
+  
+  concurrent::Variable<std::unordered_map<std::string, AbacPolicy>> policies_;
+  concurrent::Variable<std::unordered_map<std::string, CachedPolicyResult>> policy_cache_;
+  std::chrono::seconds policy_cache_ttl_;
+};
+
+// ABAC Authorization Checker
+class AbacAuthChecker : public server::handlers::auth::AuthCheckerBase {
+public:
+  using AuthCheckResult = server::handlers::auth::AuthCheckResult;
+  
+  AbacAuthChecker(const components::ComponentConfig& config,
+                  const components::ComponentContext& context)
+    : AuthCheckerBase(config, context),
+      policy_engine_(std::make_unique<AbacPolicyEngine>(config, context)) {}
+  
+  AuthCheckResult CheckAuth(const server::http::HttpRequest& request,
+                           server::request::RequestContext& context) const override {
+    try {
+      // Get subject information from authentication context
+      Subject subject;
+      auto user_id_opt = context.GetData<std::string>("user_id");
+      if (!user_id_opt.has_value()) {
+        return AuthCheckResult::kUserNotFound;
+      }
+      
+      subject.id = user_id_opt.value();
+      subject.type = "user";
+      
+      // Get subject attributes (roles, groups, etc.)
+      auto user_roles_opt = context.GetData<std::vector<std::string>>("user_roles");
+      if (user_roles_opt.has_value()) {
+        subject.attributes["roles"] = JoinStrings(user_roles_opt.value(), ",");
+      }
+      
+      // Get resource information from request
+      Resource resource;
+      resource.type = "api_endpoint";
+      resource.id = std::string(request.GetUrl());
+      
+      // Add resource attributes
+      resource.attributes["method"] = ToString(request.GetMethod());
+      resource.attributes["path"] = request.GetPath();
+      
+      // Get action from HTTP method
+      std::string action = GetActionFromMethod(request.GetMethod());
+      
+      // Check access
+      if (!policy_engine_->CheckAccess(subject, resource, action)) {
+        return AuthCheckResult::kForbidden;
+      }
+      
+      return AuthCheckResult::kOk;
+      
+    } catch (const std::exception& e) {
+      LOG_WARNING() << "ABAC authorization failed: " << e.what();
+      return AuthCheckResult::kForbidden;
+    }
+  }
+  
+  bool SupportsUserAuth() const noexcept override { return true; }
+
+private:
+  std::string GetActionFromMethod(server::http::HttpMethod method) const {
+    switch (method) {
+      case server::http::HttpMethod::kGet: return "read";
+      case server::http::HttpMethod::kPost: return "create";
+      case server::http::HttpMethod::kPut: return "update";
+      case server::http::HttpMethod::kDelete: return "delete";
+      case server::http::HttpMethod::kPatch: return "update";
+      default: return "unknown";
+    }
+  }
+  
+  std::string JoinStrings(const std::vector<std::string>& strings, 
+                         const std::string& delimiter) const {
+    if (strings.empty()) return "";
+    
+    std::string result = strings[0];
+    for (size_t i = 1; i < strings.size(); ++i) {
+      result += delimiter + strings[i];
+    }
+    return result;
+  }
+  
+  std::unique_ptr<AbacPolicyEngine> policy_engine_;
+};
+```
+
+## Resource-Level Authorization Implementation
+
+### Resource Ownership and Access Control
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/concurrent/variable.hpp>
+
+// Resource ownership information
+struct ResourceOwnership {
+  std::string resource_id;
+  std::string resource_type;
+  std::string owner_id;
+  std::vector<std::string> shared_with; // User IDs with access
+  std::unordered_map<std::string, std::vector<std::string>> permissions; // user_id -> permissions
+  std::chrono::system_clock::time_point created_at;
+};
+
+class ResourceAccessManager {
+public:
+  ResourceAccessManager(const components::ComponentConfig& config,
+                       const components::ComponentContext& context) {}
+  
+  bool CanAccessResource(const std::string& user_id,
+                        const std::string& resource_id,
+                        const std::string& resource_type,
+                        const std::string& permission) {
+    // Check if user is the owner
+    auto ownership = GetResourceOwnership(resource_id, resource_type);
+    if (!ownership.has_value()) {
+      return false;
+    }
+    
+    if (ownership->owner_id == user_id) {
+      return true; // Owner has full access
+    }
+    
+    // Check explicit permissions
+    auto perm_it = ownership->permissions.find(user_id);
+    if (perm_it != ownership->permissions.end()) {
+      const auto& user_permissions = perm_it->second;
+      if (std::find(user_permissions.begin(), user_permissions.end(), permission) != 
+          user_permissions.end()) {
+        return true;
+      }
+    }
+    
+    // Check shared access
+    if (std::find(ownership->shared_with.begin(), ownership->shared_with.end(), user_id) != 
+        ownership->shared_with.end()) {
+      // Shared users have read access by default
+      if (permission == "read") {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  void GrantResourceAccess(const std::string& resource_id,
+                          const std::string& resource_type,
+                          const std::string& owner_id,
+                          const std::string& user_id,
+                          const std::vector<std::string>& permissions) {
+    auto ownership_map = resource_ownership_.Lock();
+    
+    std::string key = resource_type + ":" + resource_id;
+    auto& ownership = (*ownership_map)[key];
+    
+    ownership.resource_id = resource_id;
+    ownership.resource_type = resource_type;
+    ownership.owner_id = owner_id;
+    
+    if (!permissions.empty()) {
+      ownership.permissions[user_id] = permissions;
+    } else {
+      // Default to shared access
+      ownership.shared_with.push_back(user_id);
+    }
+    
+    ownership.created_at = std::chrono::system_clock::now();
+  }
+  
+  void RevokeResourceAccess(const std::string& resource_id,
+                           const std::string& resource_type,
+                           const std::string& user_id) {
+    auto ownership_map = resource_ownership_.Lock();
+    
+    std::string key = resource_type + ":" + resource_id;
+    auto it = ownership_map->find(key);
+    if (it != ownership_map->end()) {
+      auto& ownership = it->second;
+      
+      // Remove from permissions
+      ownership.permissions.erase(user_id);
+      
+      // Remove from shared_with
+      auto& shared = ownership.shared_with;
+      shared.erase(std::remove(shared.begin(), shared.end(), user_id), shared.end());
+    }
+  }
+
+private:
+  std::optional<ResourceOwnership> GetResourceOwnership(const std::string& resource_id,
+                                                       const std::string& resource_type) {
+    auto ownership_map = resource_ownership_.Lock();
+    
+    std::string key = resource_type + ":" + resource_id;
+    auto it = ownership_map->find(key);
+    if (it != ownership_map->end()) {
+      return it->second;
+    }
+    
+    return std::nullopt;
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, ResourceOwnership>> resource_ownership_;
+};
+
+// Resource-level authorization checker
+class ResourceAuthChecker : public server::handlers::auth::AuthCheckerBase {
+public:
+  using AuthCheckResult = server::handlers::auth::AuthCheckResult;
+  
+  ResourceAuthChecker(const components::ComponentConfig& config,
+                     const components::ComponentContext& context)
+    : AuthCheckerBase(config, context),
+      access_manager_(std::make_unique<ResourceAccessManager>(config, context)) {}
+  
+  AuthCheckResult CheckAuth(const server::http::HttpRequest& request,
+                           server::request::RequestContext& context) const override {
+    try {
+      // Get user ID from authentication context
+      auto user_id_opt = context.GetData<std::string>("user_id");
+      if (!user_id_opt.has_value()) {
+        return AuthCheckResult::kUserNotFound;
+      }
+      
+      auto user_id = user_id_opt.value();
+      
+      // Extract resource information from request
+      auto resource_info = ExtractResourceInfo(request);
+      if (!resource_info.has_value()) {
+        // No resource-specific authorization needed
+        return AuthCheckResult::kOk;
+      }
+      
+      // Determine required permission based on HTTP method
+      std::string required_permission = GetPermissionForMethod(request.GetMethod());
+      
+      // Check resource access
+      if (!access_manager_->CanAccessResource(user_id,
+                                            resource_info->id,
+                                            resource_info->type,
+                                            required_permission)) {
+        return AuthCheckResult::kForbidden;
+      }
+      
+      return AuthCheckResult::kOk;
+      
+    } catch (const std::exception& e) {
+      LOG_WARNING() << "Resource authorization failed: " << e.what();
+      return AuthCheckResult::kForbidden;
+    }
+  }
+  
+  bool SupportsUserAuth() const noexcept override { return true; }
+
+private:
+  struct ResourceInfo {
+    std::string id;
+    std::string type;
+  };
+  
+  std::optional<ResourceInfo> ExtractResourceInfo(const server::http::HttpRequest& request) const {
+    // Extract resource information from URL path
+    // Example: /api/documents/{document_id} -> resource_type: "document", resource_id: {document_id}
+    
+    std::string path = request.GetPath();
+    
+    // Simple path parsing - in real implementation, this would be more sophisticated
+    if (path.find("/api/documents/") == 0) {
+      size_t pos = path.find_last_of('/');
+      if (pos != std::string::npos && pos < path.length() - 1) {
+        ResourceInfo info;
+        info.type = "document";
+        info.id = path.substr(pos + 1);
+        return info;
+      }
+    }
+    
+    // Add more resource types as needed
+    
+    return std::nullopt;
+  }
+  
+  std::string GetPermissionForMethod(server::http::HttpMethod method) const {
+    switch (method) {
+      case server::http::HttpMethod::kGet: return "read";
+      case server::http::HttpMethod::kPost: return "create";
+      case server::http::HttpMethod::kPut: return "update";
+      case server::http::HttpMethod::kPatch: return "update";
+      case server::http::HttpMethod::kDelete: return "delete";
+      default: return "read";
+    }
+  }
+  
+  std::unique_ptr<ResourceAccessManager> access_manager_;
+};
+```
+
+## Authorization Configuration
+
+### Static Configuration
+```yaml
+# Authorization component configuration
+auth-rbac:
+  cache-ttl: 300
+  required-roles: [user, admin]
+  role-hierarchy:
+    admin: [user, moderator]
+    moderator: [user]
+    user: []
+    guest: []
+
+auth-abac:
+  policy-cache-ttl: 300
+  default-policies:
+    - id: "public-read"
+      description: "Allow public read access"
+      conditions:
+        resource.type: "public"
+        action: "read"
+      permissions: ["read"]
+      active: true
+
+auth-resource-access:
+  default-permissions:
+    owner: [read, write, delete, share]
+    shared: [read]
+    public: [read]
+
+# Authorization factory registration
+auth-checker-factories:
+  - name: "rbac"
+    factory: "samples::auth::RbacAuthCheckerFactory"
+  - name: "abac"
+    factory: "samples::auth::AbacAuthCheckerFactory"
+  - name: "resource"
+    factory: "samples::auth::ResourceAuthCheckerFactory"
+```
+
+### Handler Authorization Configuration
+```yaml
+# Handler-specific authorization configuration
+handler-admin-panel:
+  path: /admin/*
+  task_processor: main-task-processor
+  method: GET,POST,PUT,DELETE
+  auth:
+    types: [bearer]
+    checker: rbac
+    required-roles: [admin]
+    scopes: [admin-access]
+
+handler-user-profile:
+  path: /api/users/{user_id}
+  task_processor: main-task-processor
+  method: GET,PUT
+  auth:
+    types: [bearer]
+    checker: resource
+    required-permission: read
+
+handler-document-management:
+  path: /api/documents/*
+  task_processor: main-task-processor
+  method: GET,POST,PUT,DELETE
+  auth:
+    types: [bearer]
+    checker: abac
+    policy-conditions:
+      resource.type: "document"
+      subject.roles: "user,admin"
+
+handler-public-api:
+  path: /api/public/*
+  task_processor: main-task-processor
+  method: GET
+  auth:
+    types: [bearer]
+    checker: rbac
+    required-roles: [guest, user, admin]
+    optional: true
+```
+
+## Cross-References
+
+### Related Framework Components
+- [Authentication Patterns](authentication.md) - Authentication integration with authorization
+- [Network Security Patterns](../../networking/network-security.md) - Security middleware integration
+- [Component System](../../../memory-bank/main/component-system.md) - Authorization component integration
+- [Framework Core](../../../memory-bank/main/framework-core.md) - Core security primitives
+
+### Security Best Practices
+- [Security Best Practices](security-best-practices.md) - Secure authorization implementation
+- [Vulnerability Prevention](vulnerability-prevention.md) - Authorization-related vulnerability prevention
+- [Encryption Patterns](encryption.md) - Data protection for authorization data
+
+### Implementation References
+- [`server::handlers::auth::AuthCheckerBase`](https://userver.tech/d6/db7/classserver_1_1handlers_1_1auth_1_1AuthCheckerBase.html)
+- [`server::auth::UserScope`](https://userver.tech/d4/d67/classutils_1_1StrongTypedef.html)
+- [`concurrent::Variable`](https://userver.tech/d8/dcc/namespaceconcurrent.html)
+- [`components::PostgreCache`](https://userver.tech/d2/d8d/classcomponents_1_1PostgreCache.html)
\ No newline at end of file
diff --git a/security/encryption.md b/security/encryption.md
new file mode 100644
index 000000000000..0eda4c98b6bc
--- /dev/null
+++ b/security/encryption.md
@@ -0,0 +1,1058 @@
+# Encryption Patterns
+
+## Overview
+
+Comprehensive encryption patterns for userver applications, covering TLS/SSL configuration, data encryption at rest and in transit, key management strategies, secure communication protocols, and certificate management.
+
+## Core Encryption Components
+
+### TLS/SSL Implementation
+- [`engine::io::TlsWrapper`](https://userver.tech/df/d00/classengine_1_1io_1_1TlsWrapper.html) - TLS encryption for sockets
+- [`crypto::Certificate`](https://userver.tech/d6/d32/classcrypto_1_1Certificate.html) - Certificate management
+- [`crypto::PrivateKey`](https://userver.tech/d7/d32/classcrypto_1_1PrivateKey.html) - Private key handling
+- [`server::http::HttpRequest`](https://userver.tech/d3/d44/classserver_1_1http_1_1HttpRequest.html) - HTTPS request handling
+
+### Data Encryption
+- [`crypto::aes::Aes256`](https://userver.tech/d8/d32/classcrypto_1_1aes_1_1Aes256.html) - AES-256 encryption
+- [`crypto::hmac::HmacSha256`](https://userver.tech/d9/d32/classcrypto_1_1hmac_1_1HmacSha256.html) - HMAC-SHA256 for data integrity
+- [`crypto::hash::Sha256`](https://userver.tech/da/d32/classcrypto_1_1hash_1_1Sha256.html) - SHA-256 hashing
+- [`crypto::random`](https://userver.tech/db/d32/namespacecrypto_1_1random.html) - Cryptographically secure random number generation
+
+### Key Management
+- [`crypto::Key`](https://userver.tech/dc/d32/classcrypto_1_1Key.html) - Key management and storage
+- [`crypto::kms`](https://userver.tech/dd/d32/namespacecrypto_1_1kms.html) - Key Management Service integration
+- [`concurrent::Variable`](https://userver.tech/d8/dcc/namespaceconcurrent.html) - Thread-safe key storage
+- [`components::ComponentBase`](https://userver.tech/d0/d9c/classcomponents_1_1ComponentBase.html) - Key management component base
+
+## TLS/SSL Implementation
+
+### HTTPS Server Configuration
+```cpp
+#include <userver/server/component.hpp>
+#include <userver/engine/io/tls_wrapper.hpp>
+#include <userver/crypto/certificate.hpp>
+#include <userver/crypto/private_key.hpp>
+
+class SecureHttpServer : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "secure-http-server";
+  
+  SecureHttpServer(const components::ComponentConfig& config,
+                   const components::ComponentContext& context)
+    : ComponentBase(config, context) {
+    
+    // Load TLS certificates
+    auto cert_path = config["tls"]["cert-file"].As<std::string>();
+    auto key_path = config["tls"]["key-file"].As<std::string>();
+    auto ca_path = config["tls"]["ca-file"].As<std::string>("");
+    
+    certificate_ = crypto::Certificate::LoadFromFile(cert_path);
+    private_key_ = crypto::PrivateKey::LoadFromFile(key_path);
+    
+    if (!ca_path.empty()) {
+      ca_certificate_ = crypto::Certificate::LoadFromFile(ca_path);
+    }
+    
+    // Configure TLS settings
+    tls_config_.cipher_suites = config["tls"]["cipher-suites"].As<std::string>(
+      "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256"
+    );
+    tls_config_.verify_client = config["tls"]["verify-client"].As<bool>(false);
+    tls_config_.min_version = config["tls"]["min-version"].As<std::string>("TLSv1.2");
+    tls_config_.max_version = config["tls"]["max-version"].As<std::string>("TLSv1.3");
+    
+    // Configure session resumption
+    tls_config_.session_cache_size = config["tls"]["session-cache-size"].As<int>(1000);
+    tls_config_.session_timeout = config["tls"]["session-timeout"].As<int>(300);
+  }
+
+private:
+  struct TlsConfig {
+    std::string cipher_suites;
+    bool verify_client = false;
+    std::string min_version = "TLSv1.2";
+    std::string max_version = "TLSv1.3";
+    int session_cache_size = 1000;
+    int session_timeout = 300;
+  };
+  
+  crypto::Certificate certificate_;
+  crypto::PrivateKey private_key_;
+  std::optional<crypto::Certificate> ca_certificate_;
+  TlsConfig tls_config_;
+};
+```
+
+### TLS Client Implementation
+```cpp
+#include <userver/clients/http/client.hpp>
+#include <userver/engine/io/tls_wrapper.hpp>
+#include <userver/crypto/certificate.hpp>
+
+class SecureTcpClient {
+public:
+  struct TlsConfig {
+    std::string ca_file;
+    std::string cert_file;
+    std::string key_file;
+    bool verify_server = true;
+    std::string server_name; // For SNI
+    std::string cipher_suites;
+    std::string min_version = "TLSv1.2";
+    std::string max_version = "TLSv1.3";
+    bool enable_session_resumption = true;
+  };
+  
+  SecureTcpClient(const engine::io::Sockaddr& server_addr, TlsConfig tls_config)
+    : server_addr_(server_addr), tls_config_(std::move(tls_config)) {}
+  
+  void Connect() {
+    // Create TCP socket
+    socket_ = engine::io::Socket::Create(
+      server_addr_.Domain(),
+      engine::io::SocketType::kStream
+    );
+    
+    auto deadline = engine::Deadline::FromDuration(std::chrono::seconds(10));
+    socket_.Connect(server_addr_, deadline);
+    
+    // Wrap with TLS
+    tls_wrapper_ = engine::io::TlsWrapper::StartTlsClient(
+      std::move(socket_),
+      tls_config_.ca_file,
+      tls_config_.cert_file,
+      tls_config_.key_file
+    );
+    
+    if (tls_config_.verify_server) {
+      tls_wrapper_->SetVerifyMode(engine::io::TlsWrapper::VerifyMode::kPeer);
+    }
+    
+    if (!tls_config_.server_name.empty()) {
+      tls_wrapper_->SetServerName(tls_config_.server_name);
+    }
+    
+    // Configure TLS parameters
+    if (!tls_config_.cipher_suites.empty()) {
+      tls_wrapper_->SetCipherSuites(tls_config_.cipher_suites);
+    }
+    
+    tls_wrapper_->SetMinVersion(tls_config_.min_version);
+    tls_wrapper_->SetMaxVersion(tls_config_.max_version);
+    
+    if (tls_config_.enable_session_resumption) {
+      tls_wrapper_->EnableSessionResumption(true);
+    }
+    
+    // Perform TLS handshake
+    tls_wrapper_->DoHandshake(deadline);
+  }
+  
+  std::string SendSecureRequest(const std::string& request) {
+    auto deadline = engine::Deadline::FromDuration(std::chrono::seconds(30));
+    
+    tls_wrapper_->SendAll(request.data(), request.size(), deadline);
+    
+    std::array<char, 4096> buffer;
+    auto bytes_received = tls_wrapper_->RecvSome(buffer.data(), buffer.size(), deadline);
+    
+    return std::string(buffer.data(), bytes_received);
+  }
+  
+  void Disconnect() {
+    if (tls_wrapper_ && tls_wrapper_->IsValid()) {
+      tls_wrapper_->Close();
+    }
+  }
+
+private:
+  engine::io::Sockaddr server_addr_;
+  TlsConfig tls_config_;
+  engine::io::Socket socket_;
+  std::optional<engine::io::TlsWrapper> tls_wrapper_;
+};
+```
+
+### Mutual TLS (mTLS) Configuration
+```cpp
+#include <userver/server/component.hpp>
+#include <userver/engine/io/tls_wrapper.hpp>
+#include <userver/crypto/certificate.hpp>
+
+class MutualTlsServer : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "mutual-tls-server";
+  
+  MutualTlsServer(const components::ComponentConfig& config,
+                  const components::ComponentContext& context)
+    : ComponentBase(config, context) {
+    
+    // Load server certificates
+    server_cert_ = crypto::Certificate::LoadFromFile(
+      config["server-cert"].As<std::string>()
+    );
+    server_key_ = crypto::PrivateKey::LoadFromFile(
+      config["server-key"].As<std::string>()
+    );
+    
+    // Load CA certificate for client verification
+    ca_cert_ = crypto::Certificate::LoadFromFile(
+      config["ca-cert"].As<std::string>()
+    );
+    
+    // Load Certificate Revocation List (optional)
+    auto crl_path = config["crl-file"].As<std::string>("");
+    if (!crl_path.empty()) {
+      crl_ = crypto::CertificateRevocationList::LoadFromFile(crl_path);
+    }
+    
+    // Configure mutual TLS settings
+    mtls_config_.require_client_cert = config["require-client-cert"].As<bool>(true);
+    mtls_config_.verify_depth = config["verify-depth"].As<int>(2);
+    mtls_config_.check_crl = config["check-crl"].As<bool>(false);
+  }
+  
+  bool VerifyClientCertificate(const crypto::Certificate& client_cert) const {
+    try {
+      // Verify certificate against CA
+      client_cert.Verify(ca_cert_);
+      
+      // Check certificate validity period
+      if (!client_cert.IsValidAt(std::chrono::system_clock::now())) {
+        LOG_WARNING() << "Client certificate is not valid";
+        return false;
+      }
+      
+      // Check against CRL if configured
+      if (crl_ && mtls_config_.check_crl) {
+        if (crl_->IsRevoked(client_cert)) {
+          LOG_WARNING() << "Client certificate is revoked";
+          return false;
+        }
+      }
+      
+      return true;
+      
+    } catch (const std::exception& e) {
+      LOG_WARNING() << "Client certificate verification failed: " << e.what();
+      return false;
+    }
+  }
+
+private:
+  struct MutualTlsConfig {
+    bool require_client_cert = true;
+    int verify_depth = 2;
+    bool check_crl = false;
+  };
+  
+  crypto::Certificate server_cert_;
+  crypto::PrivateKey server_key_;
+  crypto::Certificate ca_cert_;
+  std::optional<crypto::CertificateRevocationList> crl_;
+  MutualTlsConfig mtls_config_;
+};
+```
+
+## Data Encryption Implementation
+
+### AES-256 Encryption Service
+```cpp
+#include <userver/crypto/aes.hpp>
+#include <userver/crypto/random.hpp>
+#include <userver/concurrent/variable.hpp>
+
+class DataEncryptionService {
+public:
+  struct EncryptedData {
+    std::string ciphertext;
+    std::string iv; // Initialization Vector
+    std::string auth_tag; // For AEAD modes
+    std::chrono::system_clock::time_point created_at;
+  };
+  
+  DataEncryptionService(const components::ComponentConfig& config,
+                       const components::ComponentContext& context)
+    : key_rotation_interval_(config["key-rotation-interval"].As<int>(86400)) // 24 hours
+    , encryption_mode_(ParseEncryptionMode(config["mode"].As<std::string>("AES-256-GCM"))) {
+    
+    // Initialize master key
+    LoadMasterKey(config);
+    
+    // Start key rotation task
+    key_rotation_task_ = utils::Async("key-rotation", [this]() {
+      KeyRotationLoop();
+    });
+  }
+  
+  EncryptedData Encrypt(const std::string& plaintext) {
+    // Get current encryption key
+    auto key_info = GetCurrentKey();
+    
+    // Generate random IV
+    std::string iv = crypto::random::GenerateRandomString(16); // 128 bits for AES
+    
+    EncryptedData result;
+    result.iv = iv;
+    result.created_at = std::chrono::system_clock::now();
+    
+    switch (encryption_mode_) {
+      case EncryptionMode::kAes256Gcm: {
+        auto aes = crypto::aes::Aes256Gcm::Create(key_info.key);
+        auto encrypted = aes.Encrypt(plaintext, iv);
+        result.ciphertext = encrypted.ciphertext;
+        result.auth_tag = encrypted.auth_tag;
+        break;
+      }
+      
+      case EncryptionMode::kAes256Cbc: {
+        // Add PKCS#7 padding
+        std::string padded_plaintext = AddPkcs7Padding(plaintext, 16);
+        auto aes = crypto::aes::Aes256Cbc::Create(key_info.key);
+        result.ciphertext = aes.Encrypt(padded_plaintext, iv);
+        break;
+      }
+      
+      default:
+        throw std::runtime_error("Unsupported encryption mode");
+    }
+    
+    return result;
+  }
+  
+  std::string Decrypt(const EncryptedData& encrypted_data) {
+    // Get appropriate key for decryption
+    auto key_info = GetKeyForTimestamp(encrypted_data.created_at);
+    
+    std::string plaintext;
+    
+    switch (encryption_mode_) {
+      case EncryptionMode::kAes256Gcm: {
+        auto aes = crypto::aes::Aes256Gcm::Create(key_info.key);
+        crypto::aes::Aes256Gcm::EncryptedData data;
+        data.ciphertext = encrypted_data.ciphertext;
+        data.auth_tag = encrypted_data.auth_tag;
+        plaintext = aes.Decrypt(data, encrypted_data.iv);
+        break;
+      }
+      
+      case EncryptionMode::kAes256Cbc: {
+        auto aes = crypto::aes::Aes256Cbc::Create(key_info.key);
+        std::string padded_plaintext = aes.Decrypt(encrypted_data.ciphertext, encrypted_data.iv);
+        plaintext = RemovePkcs7Padding(padded_plaintext);
+        break;
+      }
+      
+      default:
+        throw std::runtime_error("Unsupported encryption mode");
+    }
+    
+    return plaintext;
+  }
+  
+  std::string Hash(const std::string& data) {
+    return crypto::hash::Sha256::Hash(data);
+  }
+  
+  std::string CreateHmac(const std::string& data, const std::string& key_id = "current") {
+    auto key_info = GetKey(key_id);
+    return crypto::hmac::HmacSha256(key_info.key, data);
+  }
+
+private:
+  enum class EncryptionMode {
+    kAes256Gcm,
+    kAes256Cbc
+  };
+  
+  struct KeyInfo {
+    std::string key; // 256-bit key (32 bytes)
+    std::chrono::system_clock::time_point created_at;
+    std::string id;
+  };
+  
+  EncryptionMode ParseEncryptionMode(const std::string& mode_str) {
+    if (mode_str == "AES-256-GCM") return EncryptionMode::kAes256Gcm;
+    if (mode_str == "AES-256-CBC") return EncryptionMode::kAes256Cbc;
+    throw std::invalid_argument("Unknown encryption mode: " + mode_str);
+  }
+  
+  void LoadMasterKey(const components::ComponentConfig& config) {
+    std::string master_key;
+    
+    // Try to load from configuration
+    if (config.HasMember("master-key")) {
+      master_key = config["master-key"].As<std::string>();
+    } else {
+      // Generate new master key
+      master_key = crypto::random::GenerateRandomString(32); // 256 bits
+      LOG_INFO() << "Generated new master key";
+    }
+    
+    // Initialize current key
+    KeyInfo key_info;
+    key_info.key = master_key;
+    key_info.created_at = std::chrono::system_clock::now();
+    key_info.id = "master";
+    
+    auto keys = encryption_keys_.Lock();
+    (*keys)["current"] = key_info;
+    (*keys)["master"] = key_info;
+  }
+  
+  KeyInfo GetCurrentKey() {
+    auto keys = encryption_keys_.Lock();
+    auto it = keys->find("current");
+    if (it != keys->end()) {
+      return it->second;
+    }
+    
+    throw std::runtime_error("No current encryption key available");
+  }
+  
+  KeyInfo GetKey(const std::string& key_id) {
+    auto keys = encryption_keys_.Lock();
+    auto it = keys->find(key_id);
+    if (it != keys->end()) {
+      return it->second;
+    }
+    
+    throw std::runtime_error("Encryption key not found: " + key_id);
+  }
+  
+  KeyInfo GetKeyForTimestamp(const std::chrono::system_clock::time_point& timestamp) {
+    // In a real implementation, this would find the appropriate key
+    // based on when the data was encrypted
+    return GetCurrentKey();
+  }
+  
+  void KeyRotationLoop() {
+    while (!should_stop_) {
+      engine::SleepFor(key_rotation_interval_);
+      
+      try {
+        RotateKey();
+      } catch (const std::exception& e) {
+        LOG_ERROR() << "Key rotation failed: " << e.what();
+      }
+    }
+  }
+  
+  void RotateKey() {
+    LOG_INFO() << "Rotating encryption key";
+    
+    // Generate new key
+    std::string new_key = crypto::random::GenerateRandomString(32); // 256 bits
+    
+    KeyInfo new_key_info;
+    new_key_info.key = new_key;
+    new_key_info.created_at = std::chrono::system_clock::now();
+    new_key_info.id = "key-" + std::to_string(
+      std::chrono::duration_cast<std::chrono::seconds>(
+        new_key_info.created_at.time_since_epoch()
+      ).count()
+    );
+    
+    // Update current key
+    auto keys = encryption_keys_.Lock();
+    (*keys)["previous"] = (*keys)["current"];
+    (*keys)["current"] = new_key_info;
+    
+    LOG_INFO() << "Key rotation completed, new key ID: " << new_key_info.id;
+  }
+  
+  std::string AddPkcs7Padding(const std::string& data, size_t block_size) {
+    size_t padding_length = block_size - (data.length() % block_size);
+    std::string padded_data = data;
+    padded_data.append(padding_length, static_cast<char>(padding_length));
+    return padded_data;
+  }
+  
+  std::string RemovePkcs7Padding(const std::string& padded_data) {
+    if (padded_data.empty()) return padded_data;
+    
+    unsigned char padding_length = padded_data.back();
+    if (padding_length > 0 && padding_length <= 16) {
+      return padded_data.substr(0, padded_data.length() - padding_length);
+    }
+    
+    return padded_data; // No padding or invalid padding
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, KeyInfo>> encryption_keys_;
+  std::chrono::seconds key_rotation_interval_;
+  EncryptionMode encryption_mode_;
+  engine::TaskWithResult<void> key_rotation_task_;
+  std::atomic<bool> should_stop_{false};
+};
+
+// Encryption service component
+class EncryptionServiceComponent : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "encryption-service";
+  
+  EncryptionServiceComponent(const components::ComponentConfig& config,
+                            const components::ComponentContext& context)
+    : ComponentBase(config, context)
+    , encryption_service_(std::make_unique<DataEncryptionService>(config, context)) {}
+  
+  DataEncryptionService& GetEncryptionService() {
+    return *encryption_service_;
+  }
+
+private:
+  std::unique_ptr<DataEncryptionService> encryption_service_;
+};
+```
+
+## Key Management Implementation
+
+### Key Management Service
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/crypto/kms.hpp>
+
+class KeyManagementService {
+public:
+  struct KeyMetadata {
+    std::string id;
+    std::string name;
+    std::string algorithm;
+    std::chrono::system_clock::time_point created_at;
+    std::chrono::system_clock::time_point last_used;
+    bool enabled = true;
+    std::string description;
+    std::vector<std::string> tags;
+  };
+  
+  KeyManagementService(const components::ComponentConfig& config,
+                      const components::ComponentContext& context)
+    : default_key_ttl_(config["default-key-ttl"].As<int>(2592000)) // 30 days
+    , enable_key_rotation_(config["enable-key-rotation"].As<bool>(true)) {
+    
+    // Initialize KMS client if configured
+    if (config.HasMember("kms-provider")) {
+      kms_provider_ = config["kms-provider"].As<std::string>();
+      InitializeKmsClient(config);
+    }
+    
+    // Load existing keys
+    LoadKeys(config);
+  }
+  
+  std::string GenerateKey(const std::string& name,
+                         const std::string& algorithm = "AES-256",
+                         int ttl_seconds = 0) {
+    if (ttl_seconds <= 0) {
+      ttl_seconds = default_key_ttl_.count();
+    }
+    
+    std::string key_id = GenerateKeyId();
+    std::string key_material;
+    
+    if (kms_provider_.has_value()) {
+      // Generate key in KMS
+      key_material = GenerateKeyInKms(key_id, algorithm);
+    } else {
+      // Generate local key
+      if (algorithm == "AES-256") {
+        key_material = crypto::random::GenerateRandomString(32);
+      } else {
+        throw std::runtime_error("Unsupported algorithm: " + algorithm);
+      }
+    }
+    
+    // Store key metadata
+    KeyMetadata metadata;
+    metadata.id = key_id;
+    metadata.name = name;
+    metadata.algorithm = algorithm;
+    metadata.created_at = std::chrono::system_clock::now();
+    metadata.last_used = metadata.created_at;
+    metadata.enabled = true;
+    
+    auto keys = key_store_.Lock();
+    (*keys)[key_id] = std::make_pair(key_material, metadata);
+    
+    LOG_INFO() << "Generated new key: " << key_id << " (" << name << ")";
+    
+    // Schedule key rotation if enabled
+    if (enable_key_rotation_) {
+      ScheduleKeyRotation(key_id, std::chrono::seconds(ttl_seconds));
+    }
+    
+    return key_id;
+  }
+  
+  std::string GetKey(const std::string& key_id) {
+    auto keys = key_store_.Lock();
+    auto it = keys->find(key_id);
+    
+    if (it == keys->end()) {
+      throw std::runtime_error("Key not found: " + key_id);
+    }
+    
+    auto& [key_material, metadata] = it->second;
+    
+    if (!metadata.enabled) {
+      throw std::runtime_error("Key is disabled: " + key_id);
+    }
+    
+    // Update last used timestamp
+    metadata.last_used = std::chrono::system_clock::now();
+    
+    if (kms_provider_.has_value()) {
+      // Decrypt key material from KMS if needed
+      return DecryptKeyFromKms(key_id, key_material);
+    }
+    
+    return key_material;
+  }
+  
+  void DisableKey(const std::string& key_id) {
+    auto keys = key_store_.Lock();
+    auto it = keys->find(key_id);
+    
+    if (it != keys->end()) {
+      it->second.second.enabled = false;
+      LOG_INFO() << "Disabled key: " << key_id;
+    }
+  }
+  
+  void EnableKey(const std::string& key_id) {
+    auto keys = key_store_.Lock();
+    auto it = keys->find(key_id);
+    
+    if (it != keys->end()) {
+      it->second.second.enabled = true;
+      LOG_INFO() << "Enabled key: " << key_id;
+    }
+  }
+  
+  std::vector<KeyMetadata> ListKeys() {
+    std::vector<KeyMetadata> result;
+    
+    auto keys = key_store_.Lock();
+    for (const auto& [key_id, key_pair] : *keys) {
+      result.push_back(key_pair.second);
+    }
+    
+    return result;
+  }
+  
+  void RotateKey(const std::string& key_id) {
+    auto keys = key_store_.Lock();
+    auto it = keys->find(key_id);
+    
+    if (it == keys->end()) {
+      throw std::runtime_error("Key not found: " + key_id);
+    }
+    
+    auto& [old_key_material, metadata] = it->second;
+    
+    // Generate new key material
+    std::string new_key_material;
+    if (kms_provider_.has_value()) {
+      new_key_material = GenerateKeyInKms(key_id + "-rotated", metadata.algorithm);
+    } else {
+      if (metadata.algorithm == "AES-256") {
+        new_key_material = crypto::random::GenerateRandomString(32);
+      } else {
+        throw std::runtime_error("Unsupported algorithm: " + metadata.algorithm);
+      }
+    }
+    
+    // Update key material
+    old_key_material = new_key_material;
+    metadata.created_at = std::chrono::system_clock::now();
+    
+    LOG_INFO() << "Rotated key: " << key_id;
+  }
+
+private:
+  void InitializeKmsClient(const components::ComponentConfig& config) {
+    // Initialize KMS client based on provider
+    // This is a simplified example
+    LOG_INFO() << "Initialized KMS client for provider: " << kms_provider_.value();
+  }
+  
+  std::string GenerateKeyInKms(const std::string& key_id, const std::string& algorithm) {
+    // Generate key in KMS and return key identifier or encrypted key material
+    // This is a simplified example
+    return "kms://" + kms_provider_.value() + "/" + key_id;
+  }
+  
+  std::string DecryptKeyFromKms(const std::string& key_id, const std::string& encrypted_key) {
+    // Decrypt key material from KMS
+    // This is a simplified example
+    return crypto::random::GenerateRandomString(32);
+  }
+  
+  void LoadKeys(const components::ComponentConfig& config) {
+    // Load existing keys from storage
+    // This is a simplified example
+    LOG_INFO() << "Loaded key store";
+  }
+  
+  std::string GenerateKeyId() {
+    auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
+      std::chrono::system_clock::now().time_since_epoch()
+    ).count();
+    
+    return "key-" + std::to_string(now) + "-" + 
+           crypto::random::GenerateRandomString(8);
+  }
+  
+  void ScheduleKeyRotation(const std::string& key_id, std::chrono::seconds ttl) {
+    // Schedule automatic key rotation
+    // This is a simplified example
+    LOG_INFO() << "Scheduled key rotation for " << key_id << " in " << ttl.count() << " seconds";
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, std::pair<std::string, KeyMetadata>>> key_store_;
+  std::optional<std::string> kms_provider_;
+  std::chrono::seconds default_key_ttl_;
+  bool enable_key_rotation_;
+};
+
+// Key management component
+class KeyManagementComponent : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "key-management";
+  
+  KeyManagementComponent(const components::ComponentConfig& config,
+                        const components::ComponentContext& context)
+    : ComponentBase(config, context)
+    , key_manager_(std::make_unique<KeyManagementService>(config, context)) {}
+  
+  KeyManagementService& GetKeyManager() {
+    return *key_manager_;
+  }
+
+private:
+  std::unique_ptr<KeyManagementService> key_manager_;
+};
+```
+
+## Certificate Management Implementation
+
+### Certificate Manager
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/crypto/certificate.hpp>
+
+class CertificateManager {
+public:
+  struct CertificateInfo {
+    std::string id;
+    std::string name;
+    std::string type; // server, client, ca
+    std::chrono::system_clock::time_point not_before;
+    std::chrono::system_clock::time_point not_after;
+    std::chrono::system_clock::time_point last_updated;
+    bool is_valid = true;
+    std::vector<std::string> domains; // For server certificates
+    std::string issuer;
+    std::string subject;
+  };
+  
+  CertificateManager(const components::ComponentConfig& config,
+                    const components::ComponentContext& context)
+    : cert_check_interval_(config["cert-check-interval"].As<int>(3600)) // 1 hour
+    , auto_renew_threshold_(config["auto-renew-threshold"].As<int>(604800)) // 7 days
+    , storage_path_(config["storage-path"].As<std::string>("")) {
+    
+    // Load existing certificates
+    LoadCertificates(config);
+    
+    // Start certificate monitoring task
+    if (cert_check_interval_.count() > 0) {
+      cert_monitoring_task_ = utils::Async("cert-monitoring", [this]() {
+        CertificateMonitoringLoop();
+      });
+    }
+  }
+  
+  void AddCertificate(const std::string& name,
+                     const std::string& cert_path,
+                     const std::string& key_path,
+                     const std::string& type = "server") {
+    auto cert = crypto::Certificate::LoadFromFile(cert_path);
+    auto key = crypto::PrivateKey::LoadFromFile(key_path);
+    
+    // Validate certificate
+    ValidateCertificate(cert, key);
+    
+    CertificateInfo cert_info;
+    cert_info.id = GenerateCertId();
+    cert_info.name = name;
+    cert_info.type = type;
+    cert_info.not_before = cert.GetNotBefore();
+    cert_info.not_after = cert.GetNotAfter();
+    cert_info.last_updated = std::chrono::system_clock::now();
+    cert_info.is_valid = true;
+    cert_info.issuer = cert.GetIssuer();
+    cert_info.subject = cert.GetSubject();
+    
+    // Extract domains for server certificates
+    if (type == "server") {
+      cert_info.domains = cert.GetSubjectAltNames();
+      if (cert_info.domains.empty()) {
+        auto common_name = cert.GetSubjectCommonName();
+        if (!common_name.empty()) {
+          cert_info.domains.push_back(common_name);
+        }
+      }
+    }
+    
+    // Store certificate
+    auto certs = certificates_.Lock();
+    (*certs)[cert_info.id] = std::make_pair(cert, cert_info);
+    
+    LOG_INFO() << "Added certificate: " << cert_info.id << " (" << name << ")";
+  }
+  
+  crypto::Certificate GetCertificate(const std::string& cert_id) {
+    auto certs = certificates_.Lock();
+    auto it = certs->find(cert_id);
+    
+    if (it == certs->end()) {
+      throw std::runtime_error("Certificate not found: " + cert_id);
+    }
+    
+    return it->second.first;
+  }
+  
+  CertificateInfo GetCertificateInfo(const std::string& cert_id) {
+    auto certs = certificates_.Lock();
+    auto it = certs->find(cert_id);
+    
+    if (it == certs->end()) {
+      throw std::runtime_error("Certificate not found: " + cert_id);
+    }
+    
+    return it->second.second;
+  }
+  
+  std::vector<CertificateInfo> ListCertificates() {
+    std::vector<CertificateInfo> result;
+    
+    auto certs = certificates_.Lock();
+    for (const auto& [cert_id, cert_pair] : *certs) {
+      result.push_back(cert_pair.second);
+    }
+    
+    return result;
+  }
+  
+  bool IsCertificateValid(const std::string& cert_id) {
+    try {
+      auto cert_info = GetCertificateInfo(cert_id);
+      auto now = std::chrono::system_clock::now();
+      
+      return cert_info.is_valid && 
+             now >= cert_info.not_before && 
+             now <= cert_info.not_after;
+    } catch (...) {
+      return false;
+    }
+  }
+  
+  std::chrono::system_clock::time_point GetCertificateExpiry(const std::string& cert_id) {
+    auto cert_info = GetCertificateInfo(cert_id);
+    return cert_info.not_after;
+  }
+  
+  void RenewCertificate(const std::string& cert_id) {
+    // Implementation for certificate renewal
+    // This would typically involve calling a CA or certificate management service
+    LOG_INFO() << "Renewing certificate: " << cert_id;
+  }
+
+private:
+  void LoadCertificates(const components::ComponentConfig& config) {
+    // Load existing certificates from storage
+    // This is a simplified example
+    LOG_INFO() << "Loaded certificate store";
+  }
+  
+  void ValidateCertificate(const crypto::Certificate& cert,
+                          const crypto::PrivateKey& key) {
+    // Validate certificate structure
+    if (!cert.IsValid()) {
+      throw std::runtime_error("Invalid certificate");
+    }
+    
+    // Validate certificate validity period
+    auto now = std::chrono::system_clock::now();
+    if (now < cert.GetNotBefore() || now > cert.GetNotAfter()) {
+      throw std::runtime_error("Certificate is not valid at current time");
+    }
+    
+    // Validate key pair match
+    if (!cert.MatchesPrivateKey(key)) {
+      throw std::runtime_error("Certificate does not match private key");
+    }
+  }
+  
+  void CertificateMonitoringLoop() {
+    while (!should_stop_) {
+      engine::SleepFor(cert_check_interval_);
+      
+      try {
+        CheckCertificates();
+      } catch (const std::exception& e) {
+        LOG_ERROR() << "Certificate monitoring failed: " << e.what();
+      }
+    }
+  }
+  
+  void CheckCertificates() {
+    LOG_DEBUG() << "Checking certificates for expiration";
+    
+    auto now = std::chrono::system_clock::now();
+    auto renewal_threshold = now + std::chrono::seconds(auto_renew_threshold_);
+    
+    auto certs = certificates_.Lock();
+    for (auto& [cert_id, cert_pair] : *certs) {
+      auto& [cert, cert_info] = cert_pair;
+      
+      // Check if certificate is expired
+      if (now > cert_info.not_after) {
+        LOG_WARNING() << "Certificate expired: " << cert_info.name << " (" << cert_id << ")";
+        cert_info.is_valid = false;
+        continue;
+      }
+      
+      // Check if certificate needs renewal
+      if (now > cert_info.not_after - std::chrono::seconds(auto_renew_threshold_)) {
+        LOG_WARNING() << "Certificate needs renewal: " << cert_info.name << " (" << cert_id << ")";
+        // Trigger renewal process
+        if (auto_renew_enabled_) {
+          // In a real implementation, this would trigger the renewal process
+          LOG_INFO() << "Auto-renewal triggered for certificate: " << cert_id;
+        }
+      }
+    }
+  }
+  
+  std::string GenerateCertId() {
+    auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
+      std::chrono::system_clock::now().time_since_epoch()
+    ).count();
+    
+    return "cert-" + std::to_string(now);
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, std::pair<crypto::Certificate, CertificateInfo>>> certificates_;
+  std::chrono::seconds cert_check_interval_;
+  std::chrono::seconds auto_renew_threshold_;
+  std::string storage_path_;
+  bool auto_renew_enabled_ = true;
+  engine::TaskWithResult<void> cert_monitoring_task_;
+  std::atomic<bool> should_stop_{false};
+};
+
+// Certificate management component
+class CertificateManagementComponent : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "certificate-management";
+  
+  CertificateManagementComponent(const components::ComponentConfig& config,
+                                const components::ComponentContext& context)
+    : ComponentBase(config, context)
+    , cert_manager_(std::make_unique<CertificateManager>(config, context)) {}
+  
+  CertificateManager& GetCertificateManager() {
+    return *cert_manager_;
+  }
+
+private:
+  std::unique_ptr<CertificateManager> cert_manager_;
+};
+```
+
+## Encryption Configuration
+
+### Static Configuration
+```yaml
+# Encryption service configuration
+encryption-service:
+  mode: "AES-256-GCM"
+  key-rotation-interval: 86400  # 24 hours
+  master-key: ""  # If empty, generates new key
+  enable-key-rotation: true
+
+# Key management configuration
+key-management:
+  default-key-ttl: 2592000  # 30 days
+  enable-key-rotation: true
+  kms-provider: ""  # If empty, uses local key storage
+  key-storage-path: "/var/lib/userver/keys"
+
+# Certificate management configuration
+certificate-management:
+  cert-check-interval: 3600  # 1 hour
+  auto-renew-threshold: 604800  # 7 days
+  storage-path: "/etc/userver/certs"
+  auto-renew-enabled: true
+
+# TLS server configuration
+tls-server:
+  cert-file: "/etc/ssl/certs/server.crt"
+  key-file: "/etc/ssl/private/server.key"
+  ca-file: "/etc/ssl/certs/ca.crt"
+  cipher-suites: "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256"
+  min-version: "TLSv1.2"
+  max-version: "TLSv1.3"
+  verify-client: false
+  session-cache-size: 1000
+  session-timeout: 300
+
+# Mutual TLS configuration
+mutual-tls:
+  server-cert: "/etc/ssl/certs/server.crt"
+  server-key: "/etc/ssl/private/server.key"
+  ca-cert: "/etc/ssl/certs/ca.crt"
+  crl-file: "/etc/ssl/certs/crl.pem"
+  require-client-cert: true
+  verify-depth: 2
+  check-crl: false
+```
+
+### Client TLS Configuration
+```yaml
+# TLS client configuration
+tls-client:
+  ca-file: "/etc/ssl/certs/ca.crt"
+  cert-file: "/etc/ssl/certs/client.crt"
+  key-file: "/etc/ssl/private/client.key"
+  verify-server: true
+  server-name: "api.example.com"
+  cipher-suites: "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256"
+  min-version: "TLSv1.2"
+  max-version: "TLSv1.3"
+  enable-session-resumption: true
+```
+
+## Cross-References
+
+### Related Framework Components
+- [Network Security Patterns](../../networking/network-security.md) - TLS/SSL integration, security middleware
+- [Authentication Patterns](authentication.md) - JWT signing, secure token handling
+- [Component System](../../../memory-bank/main/component-system.md) - Encryption component integration
+- [Framework Core](../../../memory-bank/main/framework-core.md) - Core cryptographic primitives
+
+### Security Best Practices
+- [Security Best Practices](security-best-practices.md) - Secure key management, certificate handling
+- [Vulnerability Prevention](vulnerability-prevention.md) - Encryption-related vulnerability prevention
+- [Authorization Patterns](authorization.md) - Secure data access with encryption
+
+### Implementation References
+- [`engine::io::TlsWrapper`](https://userver.tech/df/d00/classengine_1_1io_1_1TlsWrapper.html)
+- [`crypto::Certificate`](https://userver.tech/d6/d32/classcrypto_1_1Certificate.html)
+- [`crypto::aes::Aes256`](https://userver.tech/d8/d32/classcrypto_1_1aes_1_1Aes256.html)
+- [`crypto::Key`](https://userver.tech/dc/d32/classcrypto_1_1Key.html)
+- [`concurrent::Variable`](https://userver.tech/d8/dcc/namespaceconcurrent.html)
\ No newline at end of file
diff --git a/security/security-best-practices.md b/security/security-best-practices.md
new file mode 100644
index 000000000000..238a19a4042e
--- /dev/null
+++ b/security/security-best-practices.md
@@ -0,0 +1,1044 @@
+# Security Best Practices
+
+## Overview
+
+Essential security best practices for userver applications, covering input validation, output encoding, secure configuration, security headers, secure coding patterns, and defense-in-depth strategies.
+
+## Core Security Components
+
+### Input Validation
+- [`formats::json::Value`](https://userver.tech/d7/d00/classformats_1_1json_1_1Value.html) - JSON parsing and validation
+- [`server::http::HttpRequest`](https://userver.tech/d3/d44/classserver_1_1http_1_1HttpRequest.html) - HTTP request validation
+- [`utils::text`](https://userver.tech/d9/d00/namespaceutils_1_1text.html) - Text processing and validation utilities
+- [`crypto::hash`](https://userver.tech/da/d32/namespacecrypto_1_1hash.html) - Hashing for data integrity
+
+### Output Encoding
+- [`utils::text::EscapeHtml`](https://userver.tech/d9/d00/namespaceutils_1_1text.html) - HTML entity encoding
+- [`utils::text::EscapeUrl`](https://userver.tech/d9/d00/namespaceutils_1_1text.html) - URL encoding
+- [`utils::text::EscapeJson`](https://userver.tech/d9/d00/namespaceutils_1_1text.html) - JSON string encoding
+- [`server::http::HttpResponse`](https://userver.tech/d4/d44/classserver_1_1http_1_1HttpResponse.html) - HTTP response handling
+
+### Security Middleware
+- [`server::middlewares::HttpMiddlewareBase`](https://userver.tech/d5/d44/classserver_1_1middlewares_1_1HttpMiddlewareBase.html) - Base class for security middleware
+- [`server::handlers::auth::AuthCheckerBase`](https://userver.tech/d6/d44/classserver_1_1handlers_1_1auth_1_1AuthCheckerBase.html) - Authentication checker base
+- [`logging::LogExtra`](https://userver.tech/d7/d44/classlogging_1_1LogExtra.html) - Structured logging for security events
+
+## Input Validation Patterns
+
+### Request Validation Middleware
+```cpp
+#include <userver/server/middlewares/http_middleware_base.hpp>
+#include <userver/formats/json/value.hpp>
+#include <userver/server/http/http_request.hpp>
+#include <userver/utils/text.hpp>
+
+class RequestValidationMiddleware : public server::middlewares::HttpMiddlewareBase {
+public:
+  static constexpr std::string_view kName = "request-validation";
+  
+  RequestValidationMiddleware(const components::ComponentConfig& config,
+                             const components::ComponentContext& context)
+    : HttpMiddlewareBase(config, context) {
+    
+    // Load validation rules
+    max_request_size_ = config["max-request-size"].As<size_t>(10 * 1024 * 1024); // 10MB
+    max_json_depth_ = config["max-json-depth"].As<int>(32);
+    enable_sql_injection_check_ = config["enable-sql-injection-check"].As<bool>(true);
+    enable_command_injection_check_ = config["enable-command-injection-check"].As<bool>(true);
+    enable_xss_check_ = config["enable-xss-check"].As<bool>(true);
+  }
+  
+  void HandleRequest(server::http::HttpRequest& request,
+                     server::request::RequestContext& context,
+                     server::middlewares::Next next) const override {
+    
+    try {
+      // Validate request size
+      ValidateRequestSize(request);
+      
+      // Validate HTTP headers
+      ValidateHeaders(request);
+      
+      // Validate query parameters
+      ValidateQueryParameters(request);
+      
+      // Validate request body based on content type
+      if (request.GetMethod() == server::http::HttpMethod::kPost ||
+          request.GetMethod() == server::http::HttpMethod::kPut ||
+          request.GetMethod() == server::http::HttpMethod::kPatch) {
+        
+        auto content_type = request.GetHeader("Content-Type");
+        if (content_type.find("application/json") != std::string::npos) {
+          ValidateJsonBody(request);
+        } else if (content_type.find("application/x-www-form-urlencoded") != std::string::npos) {
+          ValidateFormBody(request);
+        } else if (content_type.find("multipart/form-data") != std::string::npos) {
+          ValidateMultipartBody(request);
+        }
+      }
+      
+      // Call next middleware
+      next(request, context);
+      
+    } catch (const ValidationException& e) {
+      LOG_WARNING() << "Request validation failed: " << e.what();
+      request.SetResponseStatus(server::http::HttpStatus::kBadRequest);
+      request.SetResponseBody(e.what());
+      return;
+    } catch (const SecurityException& e) {
+      LOG_WARNING() << "Security violation detected: " << e.what();
+      request.SetResponseStatus(server::http::HttpStatus::kForbidden);
+      request.SetResponseBody("Security violation detected");
+      return;
+    }
+  }
+
+private:
+  class ValidationException : public std::exception {
+  public:
+    explicit ValidationException(const std::string& message) : message_(message) {}
+    const char* what() const noexcept override { return message_.c_str(); }
+  private:
+    std::string message_;
+  };
+  
+  class SecurityException : public std::exception {
+  public:
+    explicit SecurityException(const std::string& message) : message_(message) {}
+    const char* what() const noexcept override { return message_.c_str(); }
+  private:
+    std::string message_;
+  };
+  
+  void ValidateRequestSize(const server::http::HttpRequest& request) const {
+    if (request.RequestBody().size() > max_request_size_) {
+      throw ValidationException("Request body too large");
+    }
+  }
+  
+  void ValidateHeaders(const server::http::HttpRequest& request) const {
+    // Validate required headers
+    static const std::vector<std::string> required_headers = {
+      "Host", "User-Agent", "Accept"
+    };
+    
+    for (const auto& header : required_headers) {
+      if (request.GetHeader(header).empty()) {
+        throw ValidationException("Missing required header: " + header);
+      }
+    }
+    
+    // Validate header values for security issues
+    for (const auto& [name, value] : request.GetHeaders()) {
+      if (enable_sql_injection_check_ && ContainsSqlInjection(value)) {
+        throw SecurityException("SQL injection detected in header: " + name);
+      }
+      
+      if (enable_command_injection_check_ && ContainsCommandInjection(value)) {
+        throw SecurityException("Command injection detected in header: " + name);
+      }
+      
+      if (enable_xss_check_ && ContainsXssPatterns(value)) {
+        throw SecurityException("XSS patterns detected in header: " + name);
+      }
+    }
+  }
+  
+  void ValidateQueryParameters(const server::http::HttpRequest& request) const {
+    for (const auto& [name, value] : request.GetQueryParameters()) {
+      // Validate parameter names
+      if (!IsValidParameterName(name)) {
+        throw ValidationException("Invalid parameter name: " + name);
+      }
+      
+      // Validate parameter values
+      if (!IsValidParameterValue(value)) {
+        throw ValidationException("Invalid parameter value for: " + name);
+      }
+      
+      // Security checks
+      if (enable_sql_injection_check_ && ContainsSqlInjection(value)) {
+        throw SecurityException("SQL injection detected in parameter: " + name);
+      }
+      
+      if (enable_command_injection_check_ && ContainsCommandInjection(value)) {
+        throw SecurityException("Command injection detected in parameter: " + name);
+      }
+      
+      if (enable_xss_check_ && ContainsXssPatterns(value)) {
+        throw SecurityException("XSS patterns detected in parameter: " + name);
+      }
+    }
+  }
+  
+  void ValidateJsonBody(const server::http::HttpRequest& request) const {
+    try {
+      auto json_value = formats::json::FromString(request.RequestBody());
+      
+      // Validate JSON structure depth
+      ValidateJsonDepth(json_value, 0);
+      
+      // Validate JSON values
+      ValidateJsonValue(json_value);
+      
+    } catch (const formats::json::ParseException& e) {
+      throw ValidationException("Invalid JSON format: " + std::string(e.what()));
+    }
+  }
+  
+  void ValidateJsonDepth(const formats::json::Value& value, int current_depth) const {
+    if (current_depth > max_json_depth_) {
+      throw ValidationException("JSON structure too deep");
+    }
+    
+    if (value.IsObject()) {
+      for (const auto& [key, sub_value] : Items(value)) {
+        ValidateJsonDepth(sub_value, current_depth + 1);
+      }
+    } else if (value.IsArray()) {
+      for (const auto& sub_value : value) {
+        ValidateJsonDepth(sub_value, current_depth + 1);
+      }
+    }
+  }
+  
+  void ValidateJsonValue(const formats::json::Value& value) const {
+    if (value.IsString()) {
+      auto str_value = value.As<std::string>();
+      
+      if (enable_sql_injection_check_ && ContainsSqlInjection(str_value)) {
+        throw SecurityException("SQL injection detected in JSON value");
+      }
+      
+      if (enable_command_injection_check_ && ContainsCommandInjection(str_value)) {
+        throw SecurityException("Command injection detected in JSON value");
+      }
+      
+      if (enable_xss_check_ && ContainsXssPatterns(str_value)) {
+        throw SecurityException("XSS patterns detected in JSON value");
+      }
+      
+    } else if (value.IsObject()) {
+      for (const auto& [key, sub_value] : Items(value)) {
+        // Validate key
+        if (!IsValidParameterName(key)) {
+          throw ValidationException("Invalid JSON key: " + key);
+        }
+        ValidateJsonValue(sub_value);
+      }
+    } else if (value.IsArray()) {
+      for (const auto& sub_value : value) {
+        ValidateJsonValue(sub_value);
+      }
+    }
+  }
+  
+  void ValidateFormBody(const server::http::HttpRequest& request) const {
+    // Parse form data
+    auto form_data = ParseFormData(request.RequestBody());
+    
+    for (const auto& [name, value] : form_data) {
+      // Validate parameter names
+      if (!IsValidParameterName(name)) {
+        throw ValidationException("Invalid form parameter name: " + name);
+      }
+      
+      // Validate parameter values
+      if (!IsValidParameterValue(value)) {
+        throw ValidationException("Invalid form parameter value for: " + name);
+      }
+      
+      // Security checks
+      if (enable_sql_injection_check_ && ContainsSqlInjection(value)) {
+        throw SecurityException("SQL injection detected in form parameter: " + name);
+      }
+      
+      if (enable_command_injection_check_ && ContainsCommandInjection(value)) {
+        throw SecurityException("Command injection detected in form parameter: " + name);
+      }
+      
+      if (enable_xss_check_ && ContainsXssPatterns(value)) {
+        throw SecurityException("XSS patterns detected in form parameter: " + name);
+      }
+    }
+  }
+  
+  void ValidateMultipartBody(const server::http::HttpRequest& request) const {
+    // Validate multipart form data
+    // This is a simplified example - in practice, you'd use a proper multipart parser
+    auto content_type = request.GetHeader("Content-Type");
+    if (content_type.find("boundary=") == std::string::npos) {
+      throw ValidationException("Invalid multipart content type");
+    }
+    
+    // Additional multipart validation would go here
+    // Check file sizes, content types, etc.
+  }
+  
+  bool IsValidParameterName(const std::string& name) const {
+    // Allow alphanumeric characters, hyphens, and underscores
+    return std::all_of(name.begin(), name.end(), [](char c) {
+      return std::isalnum(c) || c == '-' || c == '_';
+    }) && !name.empty() && name.size() <= 255;
+  }
+  
+  bool IsValidParameterValue(const std::string& value) const {
+    // Basic validation - check for null bytes and excessive length
+    return value.find('\0') == std::string::npos && value.size() <= 65535;
+  }
+  
+  bool ContainsSqlInjection(const std::string& input) const {
+    static const std::vector<std::string> sql_keywords = {
+      "SELECT", "INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER", "EXEC",
+      "UNION", "SELECT", "FROM", "WHERE", "HAVING", "ORDER BY", "GROUP BY"
+    };
+    
+    std::string upper_input = utils::text::ToUpperCase(input);
+    
+    for (const auto& keyword : sql_keywords) {
+      if (upper_input.find(keyword) != std::string::npos) {
+        // Additional checks to reduce false positives
+        if (upper_input.find("'") != std::string::npos || 
+            upper_input.find("--") != std::string::npos ||
+            upper_input.find("/*") != std::string::npos) {
+          return true;
+        }
+      }
+    }
+    
+    return false;
+  }
+  
+  bool ContainsCommandInjection(const std::string& input) const {
+    static const std::vector<std::string> dangerous_chars = {
+      ";", "|", "&", "`", "$(", "${"
+    };
+    
+    static const std::vector<std::string> dangerous_commands = {
+      "cat", "ls", "rm", "cp", "mv", "chmod", "chown", "wget", "curl", "ping"
+    };
+    
+    for (const auto& chars : dangerous_chars) {
+      if (input.find(chars) != std::string::npos) {
+        return true;
+      }
+    }
+    
+    std::string lower_input = utils::text::ToLowerCase(input);
+    for (const auto& command : dangerous_commands) {
+      if (lower_input.find(command) != std::string::npos) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  bool ContainsXssPatterns(const std::string& input) const {
+    static const std::vector<std::string> xss_patterns = {
+      "<script", "javascript:", "onload=", "onerror=", "onclick=", "onmouseover=",
+      "eval(", "document.cookie", "document.location", "window.location"
+    };
+    
+    std::string lower_input = utils::text::ToLowerCase(input);
+    for (const auto& pattern : xss_patterns) {
+      if (lower_input.find(pattern) != std::string::npos) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  std::unordered_map<std::string, std::string> ParseFormData(const std::string& body) const {
+    std::unordered_map<std::string, std::string> result;
+    
+    size_t start = 0;
+    while (start < body.length()) {
+      size_t end = body.find('&', start);
+      if (end == std::string::npos) {
+        end = body.length();
+      }
+      
+      std::string pair = body.substr(start, end - start);
+      size_t eq_pos = pair.find('=');
+      
+      if (eq_pos != std::string::npos) {
+        std::string key = pair.substr(0, eq_pos);
+        std::string value = pair.substr(eq_pos + 1);
+        
+        // URL decode
+        key = utils::text::UrlDecode(key);
+        value = utils::text::UrlDecode(value);
+        
+        result[key] = value;
+      }
+      
+      start = end + 1;
+    }
+    
+    return result;
+  }
+  
+  size_t max_request_size_;
+  int max_json_depth_;
+  bool enable_sql_injection_check_;
+  bool enable_command_injection_check_;
+  bool enable_xss_check_;
+};
+```
+
+## Output Encoding Patterns
+
+### Secure Response Handler
+```cpp
+#include <userver/server/handlers/http_handler_base.hpp>
+#include <userver/utils/text.hpp>
+#include <userver/formats/json/value.hpp>
+
+class SecureResponseHandler : public server::handlers::HttpHandlerBase {
+public:
+  static constexpr std::string_view kName = "secure-response-handler";
+  
+  SecureResponseHandler(const components::ComponentConfig& config,
+                       const components::ComponentContext& context)
+    : HttpHandlerBase(config, context) {
+    
+    // Load encoding settings
+    enable_html_encoding_ = config["enable-html-encoding"].As<bool>(true);
+    enable_json_encoding_ = config["enable-json-encoding"].As<bool>(true);
+    enable_url_encoding_ = config["enable-url-encoding"].As<bool>(true);
+    content_security_policy_ = config["content-security-policy"].As<std::string>("");
+  }
+  
+  std::string HandleRequestThrow(const server::http::HttpRequest& request,
+                                server::request::RequestContext&) const override {
+    
+    // Generate response content
+    std::string response_content = GenerateResponseContent(request);
+    
+    // Apply appropriate encoding based on content type
+    auto content_type = request.GetHeader("Accept");
+    
+    if (content_type.find("text/html") != std::string::npos) {
+      if (enable_html_encoding_) {
+        response_content = utils::text::EscapeHtml(response_content);
+      }
+    } else if (content_type.find("application/json") != std::string::npos) {
+      if (enable_json_encoding_) {
+        // For JSON responses, ensure proper JSON encoding
+        response_content = formats::json::ValueBuilder(response_content).ExtractValue().ToString();
+      }
+    }
+    
+    return response_content;
+  }
+
+private:
+  std::string GenerateResponseContent(const server::http::HttpRequest& request) const {
+    // Generate response content based on request
+    // This is a simplified example
+    
+    std::string content;
+    
+    // Include request parameters in response (safely)
+    for (const auto& [name, value] : request.GetQueryParameters()) {
+      content += "<p>" + name + ": " + value + "</p>";
+    }
+    
+    return content;
+  }
+  
+  void SetSecurityHeaders(server::http::HttpResponse& response) const {
+    // Set security headers
+    if (!content_security_policy_.empty()) {
+      response.SetHeader("Content-Security-Policy", content_security_policy_);
+    }
+    
+    response.SetHeader("X-Content-Type-Options", "nosniff");
+    response.SetHeader("X-Frame-Options", "DENY");
+    response.SetHeader("X-XSS-Protection", "1; mode=block");
+    response.SetHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
+    response.SetHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+  }
+  
+  bool enable_html_encoding_;
+  bool enable_json_encoding_;
+  bool enable_url_encoding_;
+  std::string content_security_policy_;
+};
+```
+
+## CSRF Protection Implementation
+
+### CSRF Token Manager
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/crypto/random.hpp>
+#include <userver/crypto/hash.hpp>
+
+class CsrfTokenManager {
+public:
+  struct CsrfToken {
+    std::string token;
+    std::chrono::system_clock::time_point created_at;
+    std::chrono::system_clock::time_point expires_at;
+    std::string session_id;
+  };
+  
+  CsrfTokenManager(const components::ComponentConfig& config,
+                  const components::ComponentContext& context)
+    : token_ttl_(config["token-ttl"].As<int>(3600)) // 1 hour
+    , token_length_(config["token-length"].As<int>(32)) {
+    
+    // Start token cleanup task
+    cleanup_task_ = utils::Async("csrf-token-cleanup", [this]() {
+      TokenCleanupLoop();
+    });
+  }
+  
+  std::string GenerateToken(const std::string& session_id) {
+    std::string token = crypto::random::GenerateRandomString(token_length_);
+    std::string hashed_token = crypto::hash::Sha256::Hash(token);
+    
+    CsrfToken csrf_token;
+    csrf_token.token = hashed_token;
+    csrf_token.created_at = std::chrono::system_clock::now();
+    csrf_token.expires_at = csrf_token.created_at + token_ttl_;
+    csrf_token.session_id = session_id;
+    
+    auto tokens = token_store_.Lock();
+    (*tokens)[hashed_token] = csrf_token;
+    
+    return token;
+  }
+  
+  bool ValidateToken(const std::string& token, const std::string& session_id) {
+    std::string hashed_token = crypto::hash::Sha256::Hash(token);
+    
+    auto tokens = token_store_.Lock();
+    auto it = tokens->find(hashed_token);
+    
+    if (it == tokens->end()) {
+      return false;
+    }
+    
+    const auto& csrf_token = it->second;
+    
+    // Check expiration
+    if (std::chrono::system_clock::now() > csrf_token.expires_at) {
+      tokens->erase(it);
+      return false;
+    }
+    
+    // Check session match
+    if (csrf_token.session_id != session_id) {
+      return false;
+    }
+    
+    return true;
+  }
+  
+  void InvalidateToken(const std::string& token) {
+    std::string hashed_token = crypto::hash::Sha256::Hash(token);
+    
+    auto tokens = token_store_.Lock();
+    tokens->erase(hashed_token);
+  }
+
+private:
+  void TokenCleanupLoop() {
+    while (!should_stop_) {
+      engine::SleepFor(std::chrono::minutes(10));
+      
+      try {
+        CleanupExpiredTokens();
+      } catch (const std::exception& e) {
+        LOG_ERROR() << "CSRF token cleanup failed: " << e.what();
+      }
+    }
+  }
+  
+  void CleanupExpiredTokens() {
+    auto now = std::chrono::system_clock::now();
+    
+    auto tokens = token_store_.Lock();
+    for (auto it = tokens->begin(); it != tokens->end();) {
+      if (now > it->second.expires_at) {
+        it = tokens->erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, CsrfToken>> token_store_;
+  std::chrono::seconds token_ttl_;
+  int token_length_;
+  engine::TaskWithResult<void> cleanup_task_;
+  std::atomic<bool> should_stop_{false};
+};
+
+// CSRF protection middleware
+class CsrfProtectionMiddleware : public server::middlewares::HttpMiddlewareBase {
+public:
+  static constexpr std::string_view kName = "csrf-protection";
+  
+  CsrfProtectionMiddleware(const components::ComponentConfig& config,
+                          const components::ComponentContext& context)
+    : HttpMiddlewareBase(config, context)
+    , csrf_manager_(context.FindComponent<CsrfTokenManager>()) {
+    
+    exempt_methods_ = config["exempt-methods"].As<std::vector<std::string>>({"GET", "HEAD", "OPTIONS"});
+    exempt_paths_ = config["exempt-paths"].As<std::vector<std::string>>({"/api/health", "/metrics"});
+    token_header_ = config["token-header"].As<std::string>("X-CSRF-Token");
+    token_form_field_ = config["token-form-field"].As<std::string>("_csrf_token");
+  }
+  
+  void HandleRequest(server::http::HttpRequest& request,
+                     server::request::RequestContext& context,
+                     server::middlewares::Next next) const override {
+    
+    std::string path = request.GetUrl();
+    std::string method = ToString(request.GetMethod());
+    
+    // Check if path/method is exempt
+    if (IsExemptPath(path) || IsExemptMethod(method)) {
+      next(request, context);
+      return;
+    }
+    
+    // For state-changing methods, validate CSRF token
+    if (IsStateChangingMethod(method)) {
+      if (!ValidateCsrfToken(request)) {
+        LOG_WARNING() << "CSRF token validation failed for " << method << " " << path;
+        request.SetResponseStatus(server::http::HttpStatus::kForbidden);
+        request.SetResponseBody("CSRF token validation failed");
+        return;
+      }
+    }
+    
+    // Generate CSRF token for all requests (for use in forms)
+    std::string session_id = GetSessionId(request);
+    std::string csrf_token = csrf_manager_.GenerateToken(session_id);
+    request.GetResponse().SetHeader("X-CSRF-Token", csrf_token);
+    
+    next(request, context);
+  }
+
+private:
+  bool IsExemptPath(const std::string& path) const {
+    for (const auto& exempt_path : exempt_paths_) {
+      if (path == exempt_path || (exempt_path.back() == '*' && 
+          path.substr(0, exempt_path.length() - 1) == exempt_path.substr(0, exempt_path.length() - 1))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  bool IsExemptMethod(const std::string& method) const {
+    return std::find(exempt_methods_.begin(), exempt_methods_.end(), method) != exempt_methods_.end();
+  }
+  
+  bool IsStateChangingMethod(const std::string& method) const {
+    static const std::vector<std::string> state_changing_methods = {"POST", "PUT", "PATCH", "DELETE"};
+    return std::find(state_changing_methods.begin(), state_changing_methods.end(), method) != state_changing_methods.end();
+  }
+  
+  bool ValidateCsrfToken(const server::http::HttpRequest& request) const {
+    std::string token;
+    
+    // Check header first
+    token = request.GetHeader(token_header_);
+    
+    // Check form data if header not found
+    if (token.empty() && request.GetMethod() == server::http::HttpMethod::kPost) {
+      auto content_type = request.GetHeader("Content-Type");
+      if (content_type.find("application/x-www-form-urlencoded") != std::string::npos) {
+        // Parse form data to find token
+        auto form_data = ParseFormData(request.RequestBody());
+        auto it = form_data.find(token_form_field_);
+        if (it != form_data.end()) {
+          token = it->second;
+        }
+      }
+    }
+    
+    if (token.empty()) {
+      return false;
+    }
+    
+    std::string session_id = GetSessionId(request);
+    return csrf_manager_.ValidateToken(token, session_id);
+  }
+  
+  std::string GetSessionId(const server::http::HttpRequest& request) const {
+    // Extract session ID from request (this is a simplified example)
+    // In practice, you'd get this from your session management system
+    return request.GetHeader("X-Session-ID");
+  }
+  
+  std::unordered_map<std::string, std::string> ParseFormData(const std::string& body) const {
+    std::unordered_map<std::string, std::string> result;
+    
+    size_t start = 0;
+    while (start < body.length()) {
+      size_t end = body.find('&', start);
+      if (end == std::string::npos) {
+        end = body.length();
+      }
+      
+      std::string pair = body.substr(start, end - start);
+      size_t eq_pos = pair.find('=');
+      
+      if (eq_pos != std::string::npos) {
+        std::string key = pair.substr(0, eq_pos);
+        std::string value = pair.substr(eq_pos + 1);
+        
+        // URL decode
+        key = utils::text::UrlDecode(key);
+        value = utils::text::UrlDecode(value);
+        
+        result[key] = value;
+      }
+      
+      start = end + 1;
+    }
+    
+    return result;
+  }
+  
+  CsrfTokenManager& csrf_manager_;
+  std::vector<std::string> exempt_methods_;
+  std::vector<std::string> exempt_paths_;
+  std::string token_header_;
+  std::string token_form_field_;
+};
+```
+
+## Security Headers Implementation
+
+### Security Headers Middleware
+```cpp
+#include <userver/server/middlewares/http_middleware_base.hpp>
+#include <userver/server/http/http_response.hpp>
+
+class SecurityHeadersMiddleware : public server::middlewares::HttpMiddlewareBase {
+public:
+  static constexpr std::string_view kName = "security-headers";
+  
+  SecurityHeadersMiddleware(const components::ComponentConfig& config,
+                           const components::ComponentContext& context)
+    : HttpMiddlewareBase(config, context) {
+    
+    // Load security header configurations
+    csp_enabled_ = config["content-security-policy"]["enabled"].As<bool>(true);
+    csp_policy_ = config["content-security-policy"]["policy"].As<std::string>(
+      "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'"
+    );
+    
+    hsts_enabled_ = config["strict-transport-security"]["enabled"].As<bool>(true);
+    hsts_max_age_ = config["strict-transport-security"]["max-age"].As<int>(31536000); // 1 year
+    hsts_include_subdomains_ = config["strict-transport-security"]["include-subdomains"].As<bool>(true);
+    hsts_preload_ = config["strict-transport-security"]["preload"].As<bool>(false);
+    
+    x_content_type_options_ = config["x-content-type-options"].As<std::string>("nosniff");
+    x_frame_options_ = config["x-frame-options"].As<std::string>("DENY");
+    x_xss_protection_ = config["x-xss-protection"].As<std::string>("1; mode=block");
+    referrer_policy_ = config["referrer-policy"].As<std::string>("strict-origin-when-cross-origin");
+    permissions_policy_ = config["permissions-policy"].As<std::string>("");
+  }
+  
+  void HandleRequest(server::http::HttpRequest& request,
+                     server::request::RequestContext& context,
+                     server::middlewares::Next next) const override {
+    
+    // Call next middleware first to let the handler process the request
+    next(request, context);
+    
+    // Set security headers on the response
+    auto& response = request.GetResponse();
+    SetSecurityHeaders(response, request);
+  }
+
+private:
+  void SetSecurityHeaders(server::http::HttpResponse& response,
+                         const server::http::HttpRequest& request) const {
+    
+    // Content Security Policy
+    if (csp_enabled_) {
+      response.SetHeader("Content-Security-Policy", csp_policy_);
+    }
+    
+    // Strict Transport Security
+    if (hsts_enabled_ && request.IsSecure()) {
+      std::string hsts_value = "max-age=" + std::to_string(hsts_max_age_);
+      if (hsts_include_subdomains_) {
+        hsts_value += "; includeSubDomains";
+      }
+      if (hsts_preload_) {
+        hsts_value += "; preload";
+      }
+      response.SetHeader("Strict-Transport-Security", hsts_value);
+    }
+    
+    // X-Content-Type-Options
+    if (!x_content_type_options_.empty()) {
+      response.SetHeader("X-Content-Type-Options", x_content_type_options_);
+    }
+    
+    // X-Frame-Options
+    if (!x_frame_options_.empty()) {
+      response.SetHeader("X-Frame-Options", x_frame_options_);
+    }
+    
+    // X-XSS-Protection
+    if (!x_xss_protection_.empty()) {
+      response.SetHeader("X-XSS-Protection", x_xss_protection_);
+    }
+    
+    // Referrer-Policy
+    if (!referrer_policy_.empty()) {
+      response.SetHeader("Referrer-Policy", referrer_policy_);
+    }
+    
+    // Permissions-Policy
+    if (!permissions_policy_.empty()) {
+      response.SetHeader("Permissions-Policy", permissions_policy_);
+    }
+  }
+  
+  bool csp_enabled_;
+  std::string csp_policy_;
+  bool hsts_enabled_;
+  int hsts_max_age_;
+  bool hsts_include_subdomains_;
+  bool hsts_preload_;
+  std::string x_content_type_options_;
+  std::string x_frame_options_;
+  std::string x_xss_protection_;
+  std::string referrer_policy_;
+  std::string permissions_policy_;
+};
+```
+
+## Secure Configuration Patterns
+
+### Configuration Validator
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/formats/json/value.hpp>
+
+class SecureConfigValidator {
+public:
+  struct ValidationResult {
+    bool is_valid = true;
+    std::vector<std::string> errors;
+    std::vector<std::string> warnings;
+  };
+  
+  static ValidationResult ValidateConfiguration(const components::ComponentConfig& config) {
+    ValidationResult result;
+    
+    // Validate security-related configuration
+    ValidateTlsConfiguration(config, result);
+    ValidateAuthenticationConfiguration(config, result);
+    ValidateRateLimitingConfiguration(config, result);
+    ValidateSecurityHeadersConfiguration(config, result);
+    
+    return result;
+  }
+
+private:
+  static void ValidateTlsConfiguration(const components::ComponentConfig& config,
+                                      ValidationResult& result) {
+    if (config.HasMember("tls")) {
+      const auto& tls_config = config["tls"];
+      
+      // Check for required TLS settings
+      if (!tls_config.HasMember("cert-file") || !tls_config.HasMember("key-file")) {
+        result.errors.push_back("TLS configuration missing cert-file or key-file");
+        result.is_valid = false;
+      }
+      
+      // Check TLS version
+      if (tls_config.HasMember("min-version")) {
+        auto min_version = tls_config["min-version"].As<std::string>();
+        if (min_version < "TLSv1.2") {
+          result.warnings.push_back("TLS minimum version should be TLSv1.2 or higher");
+        }
+      }
+      
+      // Check cipher suites
+      if (tls_config.HasMember("cipher-suites")) {
+        auto cipher_suites = tls_config["cipher-suites"].As<std::string>();
+        if (cipher_suites.find("NULL") != std::string::npos ||
+            cipher_suites.find("EXPORT") != std::string::npos) {
+          result.errors.push_back("Weak cipher suites detected in TLS configuration");
+          result.is_valid = false;
+        }
+      }
+    }
+  }
+  
+  static void ValidateAuthenticationConfiguration(const components::ComponentConfig& config,
+                                                ValidationResult& result) {
+    if (config.HasMember("auth")) {
+      const auto& auth_config = config["auth"];
+      
+      // Check JWT configuration
+      if (auth_config.HasMember("jwt")) {
+        const auto& jwt_config = auth_config["jwt"];
+        if (!jwt_config.HasMember("secret") && !jwt_config.HasMember("public-key-file")) {
+          result.warnings.push_back("JWT configuration should specify either secret or public-key-file");
+        }
+      }
+      
+      // Check session configuration
+      if (auth_config.HasMember("session")) {
+        const auto& session_config = auth_config["session"];
+        if (session_config.HasMember("secure") && !session_config["secure"].As<bool>()) {
+          result.warnings.push_back("Session cookies should be secure in production");
+        }
+      }
+    }
+  }
+  
+  static void ValidateRateLimitingConfiguration(const components::ComponentConfig& config,
+                                               ValidationResult& result) {
+    if (config.HasMember("rate-limiting")) {
+      const auto& rate_config = config["rate-limiting"];
+      
+      // Check if rate limiting is configured
+      if (!rate_config.HasMember("enabled") || !rate_config["enabled"].As<bool>()) {
+        result.warnings.push_back("Rate limiting is disabled - consider enabling for security");
+      }
+    } else {
+      result.warnings.push_back("Rate limiting configuration not found - consider adding");
+    }
+  }
+  
+  static void ValidateSecurityHeadersConfiguration(const components::ComponentConfig& config,
+                                                  ValidationResult& result) {
+    if (config.HasMember("security-headers")) {
+      const auto& headers_config = config["security-headers"];
+      
+      // Check for essential security headers
+      if (!headers_config.HasMember("content-security-policy")) {
+        result.warnings.push_back("Content-Security-Policy not configured");
+      }
+      
+      if (!headers_config.HasMember("strict-transport-security")) {
+        result.warnings.push_back("Strict-Transport-Security not configured");
+      }
+    }
+  }
+};
+
+// Configuration validation component
+class ConfigValidationComponent : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "config-validation";
+  
+  ConfigValidationComponent(const components::ComponentConfig& config,
+                           const components::ComponentContext& context)
+    : ComponentBase(config, context) {
+    
+    // Validate configuration on startup
+    auto validation_result = SecureConfigValidator::ValidateConfiguration(config);
+    
+    if (!validation_result.is_valid) {
+      std::string error_msg = "Configuration validation failed:\n";
+      for (const auto& error : validation_result.errors) {
+        error_msg += "  - " + error + "\n";
+      }
+      throw std::runtime_error(error_msg);
+    }
+    
+    if (!validation_result.warnings.empty()) {
+      LOG_WARNING() << "Configuration validation warnings:";
+      for (const auto& warning : validation_result.warnings) {
+        LOG_WARNING() << "  - " << warning;
+      }
+    }
+    
+    LOG_INFO() << "Configuration validation completed successfully";
+  }
+};
+```
+
+## Security Best Practices Configuration
+
+### Static Configuration
+```yaml
+# Request validation middleware configuration
+request-validation:
+  max-request-size: 10485760  # 10MB
+  max-json-depth: 32
+  enable-sql-injection-check: true
+  enable-command-injection-check: true
+  enable-xss-check: true
+
+# CSRF protection configuration
+csrf-protection:
+  token-ttl: 3600  # 1 hour
+  token-length: 32
+  exempt-methods: ["GET", "HEAD", "OPTIONS"]
+  exempt-paths: ["/api/health", "/metrics", "/static/*"]
+  token-header: "X-CSRF-Token"
+  token-form-field: "_csrf_token"
+
+# Security headers configuration
+security-headers:
+  content-security-policy:
+    enabled: true
+    policy: "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self'; frame-ancestors 'none';"
+  
+  strict-transport-security:
+    enabled: true
+    max-age: 31536000  # 1 year
+    include-subdomains: true
+    preload: false
+  
+  x-content-type-options: "nosniff"
+  x-frame-options: "DENY"
+  x-xss-protection: "1; mode=block"
+  referrer-policy: "strict-origin-when-cross-origin"
+  permissions-policy: "geolocation=(), microphone=(), camera=()"
+
+# Secure configuration validation
+config-validation:
+  validate-on-startup: true
+  fail-on-validation-error: true
+
+# Rate limiting configuration
+rate-limiting:
+  enabled: true
+  default-limit: 1000
+  default-window: 3600  # 1 hour
+  ip-based-limiting: true
+  user-based-limiting: true
+```
+
+## Cross-References
+
+### Related Framework Components
+- [Authentication Patterns](authentication.md) - Secure token handling, session management
+- [Authorization Patterns](authorization.md) - Access control validation
+- [Encryption Patterns](encryption.md) - Data protection, secure communication
+- [Component System](../../memory-bank/main/component-system.md) - Security middleware integration
+- [Framework Core](../../memory-bank/main/framework-core.md) - Core security utilities
+
+### Security Implementation References
+- [Vulnerability Prevention](vulnerability-prevention.md) - Specific vulnerability mitigation strategies
+- [Network Security](../networking/network-security.md) - Network-level security measures
+- [Database Security](../database/database-security.md) - Database security best practices
+
+### Implementation References
+- [`server::middlewares::HttpMiddlewareBase`](https://userver.tech/d5/d44/classserver_1_1middlewares_1_1HttpMiddlewareBase.html)
+- [`formats::json::Value`](https://userver.tech/d7/d00/classformats_1_1json_1_1Value.html)
+- [`utils::text`](https://userver.tech/d9/d00/namespaceutils_1_1text.html)
+- [`crypto::hash`](https://userver.tech/da/d32/namespacecrypto_1_1hash.html)
+- [`logging::LogExtra`](https://userver.tech/d7/d44/classlogging_1_1LogExtra.html)
\ No newline at end of file
diff --git a/security/vulnerability-prevention.md b/security/vulnerability-prevention.md
new file mode 100644
index 000000000000..c32fa3168c90
--- /dev/null
+++ b/security/vulnerability-prevention.md
@@ -0,0 +1,1407 @@
+# Vulnerability Prevention
+
+## Overview
+
+Comprehensive vulnerability prevention patterns for userver applications, covering common security vulnerabilities, automated security testing frameworks, penetration testing utilities, security monitoring, Intrusion Detection Systems (IDS), and incident response patterns.
+
+## Core Vulnerability Prevention Components
+
+### Security Testing Framework
+- [`clients::http::Client`](https://userver.tech/d1/d00/classclients_1_1http_1_1Client.html) - HTTP client for security testing
+- [`formats::json::Value`](https://userver.tech/d7/d00/classformats_1_1json_1_1Value.html) - JSON parsing for test data
+- [`engine::Task`](https://userver.tech/d2/d00/classengine_1_1Task.html) - Asynchronous security testing tasks
+- [`logging::LogExtra`](https://userver.tech/d7/d44/classlogging_1_1LogExtra.html) - Structured logging for security events
+
+### Security Monitoring
+- [`metrics::MetricTag`](https://userver.tech/d3/d00/classmetrics_1_1MetricTag.html) - Security metrics collection
+- [`tracing::Span`](https://userver.tech/d4/d00/classtracing_1_1Span.html) - Distributed tracing for security events
+- [`concurrent::Variable`](https://userver.tech/d8/dcc/namespaceconcurrent.html) - Thread-safe security state tracking
+- [`components::ComponentBase`](https://userver.tech/d0/d9c/classcomponents_1_1ComponentBase.html) - Security monitoring components
+
+### Intrusion Detection
+- [`server::http::HttpRequest`](https://userver.tech/d3/d44/classserver_1_1http_1_1HttpRequest.html) - Request analysis for IDS
+- [`utils::text`](https://userver.tech/d9/d00/namespaceutils_1_1text.html) - Text analysis for suspicious patterns
+- [`crypto::hash`](https://userver.tech/da/d32/namespacecrypto_1_1hash.html) - Hashing for integrity checking
+- [`engine::io::Socket`](https://userver.tech/d5/d00/classengine_1_1io_1_1Socket.html) - Network traffic monitoring
+
+## Common Vulnerability Prevention
+
+### Security Test Framework
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/clients/http/client.hpp>
+#include <userver/formats/json/value.hpp>
+#include <userver/engine/task/task.hpp>
+#include <userver/concurrent/variable.hpp>
+
+class SecurityTestFramework {
+public:
+  struct SecurityTest {
+    std::string name;
+    std::string description;
+    std::string category; // injection, xss, csrf, etc.
+    std::function<bool()> test_function;
+    std::chrono::seconds timeout;
+    bool enabled = true;
+  };
+  
+  struct TestResult {
+    std::string test_name;
+    bool passed = false;
+    std::string message;
+    std::chrono::system_clock::time_point executed_at;
+    std::chrono::milliseconds duration;
+  };
+  
+  SecurityTestFramework(const components::ComponentConfig& config,
+                       const components::ComponentContext& context)
+    : http_client_(context.FindComponent<clients::http::Client>())
+    , test_interval_(config["test-interval"].As<int>(3600)) // 1 hour
+    , enable_automated_testing_(config["enable-automated-testing"].As<bool>(true)) {
+    
+    // Register built-in security tests
+    RegisterBuiltInTests();
+    
+    // Load custom tests from configuration
+    LoadCustomTests(config);
+    
+    // Start automated testing if enabled
+    if (enable_automated_testing_) {
+      testing_task_ = utils::Async("security-testing", [this]() {
+        AutomatedTestingLoop();
+      });
+    }
+  }
+  
+  void RegisterSecurityTest(const std::string& name,
+                           const std::string& description,
+                           const std::string& category,
+                           std::function<bool()> test_function,
+                           std::chrono::seconds timeout = std::chrono::seconds(30)) {
+    SecurityTest test;
+    test.name = name;
+    test.description = description;
+    test.category = category;
+    test.test_function = std::move(test_function);
+    test.timeout = timeout;
+    test.enabled = true;
+    
+    auto tests = security_tests_.Lock();
+    (*tests)[name] = test;
+    
+    LOG_INFO() << "Registered security test: " << name;
+  }
+  
+  std::vector<TestResult> RunAllTests() {
+    std::vector<TestResult> results;
+    
+    auto tests = security_tests_.Lock();
+    for (const auto& [name, test] : *tests) {
+      if (!test.enabled) continue;
+      
+      TestResult result;
+      result.test_name = name;
+      result.executed_at = std::chrono::system_clock::now();
+      
+      try {
+        auto start_time = std::chrono::steady_clock::now();
+        
+        // Run test with timeout
+        auto future_result = engine::AsyncNoSpan([test_func = test.test_function]() {
+          return test_func();
+        });
+        
+        if (future_result.wait_for(test.timeout) == engine::FutureStatus::kReady) {
+          result.passed = future_result.get();
+          result.message = result.passed ? "Test passed" : "Test failed";
+        } else {
+          result.passed = false;
+          result.message = "Test timed out";
+        }
+        
+        auto end_time = std::chrono::steady_clock::now();
+        result.duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
+        
+      } catch (const std::exception& e) {
+        result.passed = false;
+        result.message = "Test exception: " + std::string(e.what());
+        result.duration = std::chrono::milliseconds(0);
+      }
+      
+      results.push_back(result);
+      
+      if (!result.passed) {
+        LOG_WARNING() << "Security test failed: " << name << " - " << result.message;
+      }
+    }
+    
+    return results;
+  }
+  
+  std::vector<TestResult> RunTestsByCategory(const std::string& category) {
+    std::vector<TestResult> results;
+    
+    auto tests = security_tests_.Lock();
+    for (const auto& [name, test] : *tests) {
+      if (!test.enabled || test.category != category) continue;
+      
+      // Similar test execution logic as RunAllTests()
+      TestResult result;
+      result.test_name = name;
+      result.executed_at = std::chrono::system_clock::now();
+      
+      try {
+        auto start_time = std::chrono::steady_clock::now();
+        
+        auto future_result = engine::AsyncNoSpan([test_func = test.test_function]() {
+          return test_func();
+        });
+        
+        if (future_result.wait_for(test.timeout) == engine::FutureStatus::kReady) {
+          result.passed = future_result.get();
+          result.message = result.passed ? "Test passed" : "Test failed";
+        } else {
+          result.passed = false;
+          result.message = "Test timed out";
+        }
+        
+        auto end_time = std::chrono::steady_clock::now();
+        result.duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
+        
+      } catch (const std::exception& e) {
+        result.passed = false;
+        result.message = "Test exception: " + std::string(e.what());
+        result.duration = std::chrono::milliseconds(0);
+      }
+      
+      results.push_back(result);
+    }
+    
+    return results;
+  }
+  
+  void EnableTest(const std::string& name, bool enabled = true) {
+    auto tests = security_tests_.Lock();
+    auto it = tests->find(name);
+    if (it != tests->end()) {
+      it->second.enabled = enabled;
+      LOG_INFO() << "Security test " << (enabled ? "enabled" : "disabled") << ": " << name;
+    }
+  }
+
+private:
+  void RegisterBuiltInTests() {
+    // SQL Injection Test
+    RegisterSecurityTest("sql-injection-test", 
+                        "Test for SQL injection vulnerabilities",
+                        "injection",
+                        [this]() { return TestSqlInjection(); });
+    
+    // XSS Test
+    RegisterSecurityTest("xss-test",
+                        "Test for Cross-Site Scripting vulnerabilities",
+                        "xss",
+                        [this]() { return TestXss(); });
+    
+    // CSRF Test
+    RegisterSecurityTest("csrf-test",
+                        "Test for Cross-Site Request Forgery vulnerabilities",
+                        "csrf",
+                        [this]() { return TestCsrf(); });
+    
+    // Authentication Test
+    RegisterSecurityTest("auth-test",
+                        "Test authentication mechanisms",
+                        "authentication",
+                        [this]() { return TestAuthentication(); });
+    
+    // Authorization Test
+    RegisterSecurityTest("authz-test",
+                        "Test authorization mechanisms",
+                        "authorization",
+                        [this]() { return TestAuthorization(); });
+    
+    // Rate Limiting Test
+    RegisterSecurityTest("rate-limit-test",
+                        "Test rate limiting mechanisms",
+                        "dos",
+                        [this]() { return TestRateLimiting(); });
+  }
+  
+  void LoadCustomTests(const components::ComponentConfig& config) {
+    if (!config.HasMember("custom-tests")) return;
+    
+    const auto& custom_tests = config["custom-tests"];
+    for (const auto& test_config : custom_tests) {
+      std::string name = test_config["name"].As<std::string>();
+      std::string description = test_config["description"].As<std::string>();
+      std::string category = test_config["category"].As<std::string>();
+      std::string endpoint = test_config["endpoint"].As<std::string>();
+      std::string method = test_config["method"].As<std::string>("GET");
+      auto timeout = std::chrono::seconds(test_config["timeout"].As<int>(30));
+      
+      RegisterSecurityTest(name, description, category,
+                          [this, endpoint, method]() {
+                            return RunCustomTest(endpoint, method);
+                          }, timeout);
+    }
+  }
+  
+  void AutomatedTestingLoop() {
+    while (!should_stop_) {
+      engine::SleepFor(test_interval_);
+      
+      try {
+        LOG_INFO() << "Running automated security tests";
+        auto results = RunAllTests();
+        
+        // Log summary
+        int passed = 0, failed = 0;
+        for (const auto& result : results) {
+          if (result.passed) passed++;
+          else failed++;
+        }
+        
+        LOG_INFO() << "Security test summary: " << passed << " passed, " << failed << " failed";
+        
+        // Alert on failures
+        if (failed > 0) {
+          AlertOnTestFailures(results);
+        }
+        
+      } catch (const std::exception& e) {
+        LOG_ERROR() << "Automated security testing failed: " << e.what();
+      }
+    }
+  }
+  
+  bool TestSqlInjection() {
+    // Test common SQL injection patterns
+    std::vector<std::string> test_payloads = {
+      "' OR '1'='1",
+      "'; DROP TABLE users; --",
+      "' UNION SELECT username, password FROM users --",
+      "1'; EXEC xp_cmdshell('dir'); --"
+    };
+    
+    for (const auto& payload : test_payloads) {
+      // This is a simplified example - in practice, you'd make actual HTTP requests
+      // to test endpoints with these payloads and check for vulnerable responses
+      if (TestEndpointWithPayload("/api/test", "POST", payload)) {
+        LOG_WARNING() << "Potential SQL injection vulnerability detected with payload: " << payload;
+        return false;
+      }
+    }
+    
+    return true;
+  }
+  
+  bool TestXss() {
+    // Test common XSS patterns
+    std::vector<std::string> test_payloads = {
+      "<script>alert('xss')</script>",
+      "javascript:alert('xss')",
+      "<img src=x onerror=alert('xss')>",
+      "<svg onload=alert('xss')>"
+    };
+    
+    for (const auto& payload : test_payloads) {
+      if (TestEndpointWithPayload("/api/test", "GET", payload)) {
+        LOG_WARNING() << "Potential XSS vulnerability detected with payload: " << payload;
+        return false;
+      }
+    }
+    
+    return true;
+  }
+  
+  bool TestCsrf() {
+    // Test CSRF protection by making requests without proper tokens
+    // This is a simplified example
+    auto response = http_client_.CreateRequest()
+      .method(engine::http::Method::kPost)
+      .url("http://localhost:8080/api/sensitive-action")
+      .body("{}")
+      .timeout(std::chrono::seconds(10))
+      .perform();
+    
+    // Check if request was rejected due to missing CSRF token
+    return response->GetStatusCode() == 403;
+  }
+  
+  bool TestAuthentication() {
+    // Test authentication mechanisms
+    // Try to access protected endpoints without authentication
+    auto response = http_client_.CreateRequest()
+      .method(engine::http::Method::kGet)
+      .url("http://localhost:8080/api/protected")
+      .timeout(std::chrono::seconds(10))
+      .perform();
+    
+    // Should be rejected
+    if (response->GetStatusCode() != 401) {
+      LOG_WARNING() << "Authentication bypass detected";
+      return false;
+    }
+    
+    return true;
+  }
+  
+  bool TestAuthorization() {
+    // Test authorization mechanisms
+    // Try to access resources with insufficient privileges
+    auto response = http_client_.CreateRequest()
+      .method(engine::http::Method::kGet)
+      .url("http://localhost:8080/api/admin-only")
+      .header("Authorization", "Bearer user-token") // Regular user token
+      .timeout(std::chrono::seconds(10))
+      .perform();
+    
+    // Should be rejected
+    if (response->GetStatusCode() != 403) {
+      LOG_WARNING() << "Authorization bypass detected";
+      return false;
+    }
+    
+    return true;
+  }
+  
+  bool TestRateLimiting() {
+    // Test rate limiting by making many rapid requests
+    int request_count = 100;
+    int success_count = 0;
+    
+    for (int i = 0; i < request_count; i++) {
+      auto response = http_client_.CreateRequest()
+        .method(engine::http::Method::kGet)
+        .url("http://localhost:8080/api/rate-limited")
+        .timeout(std::chrono::seconds(5))
+        .perform();
+      
+      if (response->GetStatusCode() == 200) {
+        success_count++;
+      }
+      
+      // Small delay to avoid overwhelming the server
+      engine::SleepFor(std::chrono::milliseconds(10));
+    }
+    
+    // Check if rate limiting is working (should reject some requests)
+    double success_rate = static_cast<double>(success_count) / request_count;
+    if (success_rate > 0.8) { // Allow some margin
+      LOG_WARNING() << "Rate limiting may not be effective - success rate: " 
+                    << (success_rate * 100) << "%";
+      return false;
+    }
+    
+    return true;
+  }
+  
+  bool TestEndpointWithPayload(const std::string& endpoint,
+                              const std::string& method,
+                              const std::string& payload) {
+    // This is a simplified example - in practice, you'd implement
+    // actual HTTP requests with the payload and analyze responses
+    // for signs of vulnerability
+    
+    auto request = http_client_.CreateRequest()
+      .url("http://localhost:8080" + endpoint)
+      .timeout(std::chrono::seconds(10));
+    
+    if (method == "POST") {
+      request = request.method(engine::http::Method::kPost)
+        .body(payload);
+    } else {
+      request = request.method(engine::http::Method::kGet)
+        .retry(0);
+      // Add payload as query parameter for GET requests
+      // This is a simplified example
+    }
+    
+    auto response = request.perform();
+    
+    // Analyze response for signs of vulnerability
+    // This is a very basic example - real implementation would be more sophisticated
+    std::string response_body = response->GetBody();
+    
+    // Look for database error messages
+    if (response_body.find("SQL syntax") != std::string::npos ||
+        response_body.find("mysql_fetch") != std::string::npos ||
+        response_body.find("ORA-") != std::string::npos) {
+      return true; // Potential SQL injection
+    }
+    
+    // Look for reflected input (potential XSS)
+    if (response_body.find(payload) != std::string::npos) {
+      return true; // Potential XSS
+    }
+    
+    return false;
+  }
+  
+  bool RunCustomTest(const std::string& endpoint, const std::string& method) {
+    // Execute custom security test
+    auto response = http_client_.CreateRequest()
+      .method(method == "POST" ? engine::http::Method::kPost : engine::http::Method::kGet)
+      .url("http://localhost:8080" + endpoint)
+      .timeout(std::chrono::seconds(30))
+      .perform();
+    
+    // Custom test logic would go here
+    return response->GetStatusCode() == 200;
+  }
+  
+  void AlertOnTestFailures(const std::vector<TestResult>& results) {
+    // Send alerts for failed security tests
+    // This could integrate with monitoring systems, email, Slack, etc.
+    
+    for (const auto& result : results) {
+      if (!result.passed) {
+        LOG_ERROR() << "Security test failed: " << result.test_name 
+                    << " - " << result.message;
+        
+        // In a real implementation, you'd send alerts to monitoring systems
+        SendSecurityAlert(result);
+      }
+    }
+  }
+  
+  void SendSecurityAlert(const TestResult& result) {
+    // Send security alert to monitoring system
+    // This is a simplified example
+    LOG_CRITICAL() << "SECURITY ALERT: " << result.test_name 
+                   << " failed at " << ToString(result.executed_at)
+                   << " - " << result.message;
+  }
+  
+  concurrent::Variable<std::unordered_map<std::string, SecurityTest>> security_tests_;
+  clients::http::Client& http_client_;
+  std::chrono::seconds test_interval_;
+  bool enable_automated_testing_;
+  engine::TaskWithResult<void> testing_task_;
+  std::atomic<bool> should_stop_{false};
+};
+
+// Security test framework component
+class SecurityTestFrameworkComponent : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "security-test-framework";
+  
+  SecurityTestFrameworkComponent(const components::ComponentConfig& config,
+                                const components::ComponentContext& context)
+    : ComponentBase(config, context)
+    , test_framework_(std::make_unique<SecurityTestFramework>(config, context)) {}
+  
+  SecurityTestFramework& GetTestFramework() {
+    return *test_framework_;
+  }
+
+private:
+  std::unique_ptr<SecurityTestFramework> test_framework_;
+};
+```
+
+## Intrusion Detection System
+
+### IDS Implementation
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/server/http/http_request.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/metrics/metric_tag.hpp>
+#include <userver/utils/text.hpp>
+
+class IntrusionDetectionSystem {
+public:
+  struct Alert {
+    std::string rule_name;
+    std::string description;
+    std::string source_ip;
+    std::string user_agent;
+    std::chrono::system_clock::time_point timestamp;
+    int severity; // 1-10
+    std::string request_details;
+  };
+  
+  struct Rule {
+    std::string name;
+    std::string description;
+    std::function<bool(const server::http::HttpRequest&)> condition;
+    int severity = 5;
+    bool enabled = true;
+    std::chrono::seconds cooldown_period;
+    std::chrono::system_clock::time_point last_triggered;
+  };
+  
+  struct Statistics {
+    std::atomic<uint64_t> total_requests{0};
+    std::atomic<uint64_t> suspicious_requests{0};
+    std::atomic<uint64_t> alerts_generated{0};
+    std::atomic<uint64_t> blocked_requests{0};
+  };
+  
+  IntrusionDetectionSystem(const components::ComponentConfig& config,
+                          const components::ComponentContext& context)
+    : alert_threshold_(config["alert-threshold"].As<int>(10))
+    , block_threshold_(config["block-threshold"].As<int>(50))
+    , enable_blocking_(config["enable-blocking"].As<bool>(false))
+    , log_alerts_(config["log-alerts"].As<bool>(true)) {
+    
+    // Register built-in detection rules
+    RegisterBuiltInRules();
+    
+    // Load custom rules from configuration
+    LoadCustomRules(config);
+    
+    // Initialize metrics
+    InitializeMetrics(context);
+  }
+  
+  bool AnalyzeRequest(const server::http::HttpRequest& request) {
+    statistics_.total_requests++;
+    
+    bool is_suspicious = false;
+    std::vector<Alert> triggered_alerts;
+    
+    // Check all enabled rules
+    auto rules = detection_rules_.Lock();
+    for (const auto& [name, rule] : *rules) {
+      if (!rule.enabled) continue;
+      
+      // Check cooldown period
+      auto now = std::chrono::system_clock::now();
+      if (now < rule.last_triggered + rule.cooldown_period) {
+        continue;
+      }
+      
+      if (rule.condition(request)) {
+        is_suspicious = true;
+        statistics_.suspicious_requests++;
+        
+        Alert alert;
+        alert.rule_name = rule.name;
+        alert.description = rule.description;
+        alert.source_ip = request.GetRemoteAddress();
+        alert.user_agent = request.GetHeader("User-Agent");
+        alert.timestamp = now;
+        alert.severity = rule.severity;
+        alert.request_details = GetRequestDetails(request);
+        
+        triggered_alerts.push_back(alert);
+        statistics_.alerts_generated++;
+        
+        // Update last triggered time
+        const_cast<Rule&>(rule).last_triggered = now;
+      }
+    }
+    
+    // Handle alerts
+    if (!triggered_alerts.empty()) {
+      HandleAlerts(triggered_alerts, request);
+      
+      // Check if request should be blocked
+      if (enable_blocking_ && ShouldBlockRequest(triggered_alerts)) {
+        statistics_.blocked_requests++;
+        return true; // Block the request
+      }
+    }
+    
+    return false; // Don't block the request
+  }
+  
+  std::vector<Alert> GetRecentAlerts(size_t limit = 100) {
+    std::lock_guard<std::mutex> lock(alert_history_mutex_);
+    
+    std::vector<Alert> recent_alerts;
+    auto now = std::chrono::system_clock::now();
+    auto cutoff = now - std::chrono::hours(24); // Last 24 hours
+    
+    for (auto it = alert_history_.rbegin(); 
+         it != alert_history_.rend() && recent_alerts.size() < limit; 
+         ++it) {
+      if (it->timestamp >= cutoff) {
+        recent_alerts.push_back(*it);
+      } else {
+        break;
+      }
+    }
+    
+    return recent_alerts;
+  }
+  
+  Statistics GetStatistics() const {
+    return statistics_;
+  }
+  
+  void AddCustomRule(const std::string& name,
+                    const std::string& description,
+                    std::function<bool(const server::http::HttpRequest&)> condition,
+                    int severity = 5,
+                    std::chrono::seconds cooldown = std::chrono::seconds(60)) {
+    Rule rule;
+    rule.name = name;
+    rule.description = description;
+    rule.condition = std::move(condition);
+    rule.severity = severity;
+    rule.enabled = true;
+    rule.cooldown_period = cooldown;
+    rule.last_triggered = std::chrono::system_clock::time_point::min();
+    
+    auto rules = detection_rules_.Lock();
+    (*rules)[name] = rule;
+    
+    LOG_INFO() << "Added custom IDS rule: " << name;
+  }
+
+private:
+  void RegisterBuiltInRules() {
+    // High request rate detection
+    AddBuiltInRule("high-request-rate", 
+                  "Unusually high request rate from single IP",
+                  7,
+                  std::chrono::seconds(60),
+                  [this](const server::http::HttpRequest& request) {
+                    return DetectHighRequestRate(request);
+                  });
+    
+    // SQL injection patterns
+    AddBuiltInRule("sql-injection", 
+                  "SQL injection attempt detected",
+                  9,
+                  std::chrono::seconds(30),
+                  [this](const server::http::HttpRequest& request) {
+                    return DetectSqlInjection(request);
+                  });
+    
+    // XSS patterns
+    AddBuiltInRule("xss-attempt", 
+                  "Cross-site scripting attempt detected",
+                  8,
+                  std::chrono::seconds(30),
+                  [this](const server::http::HttpRequest& request) {
+                    return DetectXss(request);
+                  });
+    
+    // Command injection
+    AddBuiltInRule("command-injection", 
+                  "Command injection attempt detected",
+                  10,
+                  std::chrono::seconds(30),
+                  [this](const server::http::HttpRequest& request) {
+                    return DetectCommandInjection(request);
+                  });
+    
+    // Directory traversal
+    AddBuiltInRule("directory-traversal", 
+                  "Directory traversal attempt detected",
+                  8,
+                  std::chrono::seconds(60),
+                  [this](const server::http::HttpRequest& request) {
+                    return DetectDirectoryTraversal(request);
+                  });
+    
+    // Large request body
+    AddBuiltInRule("large-request", 
+                  "Unusually large request body",
+                  6,
+                  std::chrono::seconds(120),
+                  [this](const server::http::HttpRequest& request) {
+                    return DetectLargeRequest(request);
+                  });
+  }
+  
+  void AddBuiltInRule(const std::string& name,
+                     const std::string& description,
+                     int severity,
+                     std::chrono::seconds cooldown,
+                     std::function<bool(const server::http::HttpRequest&)> condition) {
+    Rule rule;
+    rule.name = name;
+    rule.description = description;
+    rule.condition = std::move(condition);
+    rule.severity = severity;
+    rule.enabled = true;
+    rule.cooldown_period = cooldown;
+    rule.last_triggered = std::chrono::system_clock::time_point::min();
+    
+    auto rules = detection_rules_.Lock();
+    (*rules)[name] = rule;
+  }
+  
+  void LoadCustomRules(const components::ComponentConfig& config) {
+    if (!config.HasMember("custom-rules")) return;
+    
+    const auto& custom_rules = config["custom-rules"];
+    for (const auto& rule_config : custom_rules) {
+      std::string name = rule_config["name"].As<std::string>();
+      std::string description = rule_config["description"].As<std::string>();
+      int severity = rule_config["severity"].As<int>(5);
+      auto cooldown = std::chrono::seconds(rule_config["cooldown"].As<int>(60));
+      
+      // In a real implementation, you'd parse the rule condition from config
+      // This is a simplified example
+      AddCustomRule(name, description, 
+                   [name](const server::http::HttpRequest&) { 
+                     // Custom rule logic would go here
+                     return false; 
+                   }, 
+                   severity, cooldown);
+    }
+  }
+  
+  bool DetectHighRequestRate(const server::http::HttpRequest& request) {
+    std::string ip = request.GetRemoteAddress();
+    
+    auto now = std::chrono::steady_clock::now();
+    auto window_start = now - std::chrono::minutes(1);
+    
+    // Count requests from this IP in the last minute
+    std::lock_guard<std::mutex> lock(request_history_mutex_);
+    
+    // Clean old entries
+    while (!request_history_.empty() && 
+           request_history_.front().timestamp < window_start) {
+      request_history_.pop_front();
+    }
+    
+    // Count requests from this IP
+    int ip_request_count = 0;
+    for (const auto& entry : request_history_) {
+      if (entry.ip == ip) {
+        ip_request_count++;
+      }
+    }
+    
+    // Store this request
+    request_history_.push_back({ip, now});
+    
+    // Alert if more than threshold requests per minute
+    return ip_request_count > 100; // Configurable threshold
+  }
+  
+  bool DetectSqlInjection(const server::http::HttpRequest& request) {
+    // Check query parameters
+    for (const auto& [name, value] : request.GetQueryParameters()) {
+      if (ContainsSqlInjectionPatterns(value)) {
+        return true;
+      }
+    }
+    
+    // Check request body
+    if (!request.RequestBody().empty()) {
+      if (ContainsSqlInjectionPatterns(request.RequestBody())) {
+        return true;
+      }
+    }
+    
+    // Check headers
+    for (const auto& [name, value] : request.GetHeaders()) {
+      if (ContainsSqlInjectionPatterns(value)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  bool DetectXss(const server::http::HttpRequest& request) {
+    // Check query parameters
+    for (const auto& [name, value] : request.GetQueryParameters()) {
+      if (ContainsXssPatterns(value)) {
+        return true;
+      }
+    }
+    
+    // Check request body
+    if (!request.RequestBody().empty()) {
+      if (ContainsXssPatterns(request.RequestBody())) {
+        return true;
+      }
+    }
+    
+    // Check headers
+    for (const auto& [name, value] : request.GetHeaders()) {
+      if (ContainsXssPatterns(value)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  bool DetectCommandInjection(const server::http::HttpRequest& request) {
+    // Check for command injection patterns
+    static const std::vector<std::string> dangerous_patterns = {
+      ";", "|", "&", "`", "$(", "${", "||", "&&"
+    };
+    
+    auto check_for_patterns = [&dangerous_patterns](const std::string& input) {
+      std::string lower_input = utils::text::ToLowerCase(input);
+      for (const auto& pattern : dangerous_patterns) {
+        if (lower_input.find(pattern) != std::string::npos) {
+          // Additional checks to reduce false positives
+          if (lower_input.find("cat ") != std::string::npos ||
+              lower_input.find("ls ") != std::string::npos ||
+              lower_input.find("rm ") != std::string::npos) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    
+    // Check query parameters
+    for (const auto& [name, value] : request.GetQueryParameters()) {
+      if (check_for_patterns(value)) {
+        return true;
+      }
+    }
+    
+    // Check request body
+    if (!request.RequestBody().empty()) {
+      if (check_for_patterns(request.RequestBody())) {
+        return true;
+      }
+    }
+    
+    // Check headers
+    for (const auto& [name, value] : request.GetHeaders()) {
+      if (check_for_patterns(value)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  bool DetectDirectoryTraversal(const server::http::HttpRequest& request) {
+    std::string path = request.GetPath();
+    
+    // Check for directory traversal patterns
+    if (path.find("../") != std::string::npos ||
+        path.find("..\\") != std::string::npos ||
+        path.find("%2e%2e%2f") != std::string::npos || // URL encoded ../
+        path.find("%2e%2e\\") != std::string::npos) {  // URL encoded ..\
+      return true;
+    }
+    
+    return false;
+  }
+  
+  bool DetectLargeRequest(const server::http::HttpRequest& request) {
+    // Check if request body is unusually large
+    size_t body_size = request.RequestBody().size();
+    return body_size > 10 * 1024 * 1024; // 10MB threshold
+  }
+  
+  bool ContainsSqlInjectionPatterns(const std::string& input) {
+    static const std::vector<std::string> sql_keywords = {
+      "SELECT", "INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER", "EXEC",
+      "UNION", "FROM", "WHERE", "HAVING", "ORDER BY", "GROUP BY"
+    };
+    
+    std::string upper_input = utils::text::ToUpperCase(input);
+    
+    for (const auto& keyword : sql_keywords) {
+      if (upper_input.find(keyword) != std::string::npos) {
+        // Additional checks to reduce false positives
+        if (upper_input.find("'") != std::string::npos || 
+            upper_input.find("--") != std::string::npos ||
+            upper_input.find("/*") != std::string::npos) {
+          return true;
+        }
+      }
+    }
+    
+    return false;
+  }
+  
+  bool ContainsXssPatterns(const std::string& input) {
+    static const std::vector<std::string> xss_patterns = {
+      "<script", "javascript:", "onload=", "onerror=", "onclick=", "onmouseover=",
+      "eval(", "document.cookie", "document.location", "window.location",
+      "<img", "<iframe", "<object", "<embed"
+    };
+    
+    std::string lower_input = utils::text::ToLowerCase(input);
+    for (const auto& pattern : xss_patterns) {
+      if (lower_input.find(pattern) != std::string::npos) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  std::string GetRequestDetails(const server::http::HttpRequest& request) {
+    std::string details = "Method: " + ToString(request.GetMethod()) + 
+                         ", Path: " + request.GetPath() +
+                         ", IP: " + request.GetRemoteAddress();
+    
+    // Add first few query parameters
+    int param_count = 0;
+    for (const auto& [name, value] : request.GetQueryParameters()) {
+      if (param_count++ >= 3) break;
+      details += ", " + name + "=" + value;
+    }
+    
+    return details;
+  }
+  
+  void HandleAlerts(const std::vector<Alert>& alerts, 
+                   const server::http::HttpRequest& request) {
+    for (const auto& alert : alerts) {
+      if (log_alerts_) {
+        LOG_WARNING() << "IDS Alert - Rule: " << alert.rule_name
+                      << ", IP: " << alert.source_ip
+                      << ", Severity: " << alert.severity
+                      << ", Description: " << alert.description;
+      }
+      
+      // Store alert in history
+      {
+        std::lock_guard<std::mutex> lock(alert_history_mutex_);
+        alert_history_.push_back(alert);
+        
+        // Keep only recent alerts
+        auto now = std::chrono::system_clock::now();
+        auto cutoff = now - std::chrono::hours(24);
+        while (!alert_history_.empty() && 
+               alert_history_.front().timestamp < cutoff) {
+          alert_history_.pop_front();
+        }
+      }
+      
+      // Send alert to external monitoring system
+      SendAlertToMonitoring(alert);
+    }
+  }
+  
+  void SendAlertToMonitoring(const Alert& alert) {
+    // Send alert to external monitoring system
+    // This could integrate with SIEM, logging systems, etc.
+    
+    // Update metrics
+    if (alert.severity >= 8) {
+      critical_alerts_counter_.Account(1);
+    } else if (alert.severity >= 5) {
+      warning_alerts_counter_.Account(1);
+    } else {
+      info_alerts_counter_.Account(1);
+    }
+  }
+  
+  bool ShouldBlockRequest(const std::vector<Alert>& alerts) {
+    int total_severity = 0;
+    for (const auto& alert : alerts) {
+      total_severity += alert.severity;
+    }
+    
+    return total_severity >= block_threshold_;
+  }
+  
+  void InitializeMetrics(const components::ComponentContext& context) {
+    // Initialize metrics for monitoring
+    auto& metrics = context.FindComponent<components::StatisticsStorage>().GetMetricsStorage();
+    
+    critical_alerts_counter_ = metrics.CreateCounterMetric(
+      {"security", "ids", "alerts", "critical"}, "Number of critical IDS alerts");
+    
+    warning_alerts_counter_ = metrics.CreateCounterMetric(
+      {"security", "ids", "alerts", "warning"}, "Number of warning IDS alerts");
+    
+    info_alerts_counter_ = metrics.CreateCounterMetric(
+      {"security", "ids", "alerts", "info"}, "Number of info IDS alerts");
+    
+    blocked_requests_counter_ = metrics.CreateCounterMetric(
+      {"security", "ids", "requests", "blocked"}, "Number of blocked requests");
+  }
+  
+  struct RequestHistoryEntry {
+    std::string ip;
+    std::chrono::steady_clock::time_point timestamp;
+  };
+  
+  concurrent::Variable<std::unordered_map<std::string, Rule>> detection_rules_;
+  int alert_threshold_;
+  int block_threshold_;
+  bool enable_blocking_;
+  bool log_alerts_;
+  
+  Statistics statistics_;
+  
+  std::deque<RequestHistoryEntry> request_history_;
+  std::mutex request_history_mutex_;
+  
+  std::deque<Alert> alert_history_;
+  std::mutex alert_history_mutex_;
+  
+  metrics::CounterMetric critical_alerts_counter_;
+  metrics::CounterMetric warning_alerts_counter_;
+  metrics::CounterMetric info_alerts_counter_;
+  metrics::CounterMetric blocked_requests_counter_;
+};
+
+// IDS middleware
+class IntrusionDetectionMiddleware : public server::middlewares::HttpMiddlewareBase {
+public:
+  static constexpr std::string_view kName = "intrusion-detection";
+  
+  IntrusionDetectionMiddleware(const components::ComponentConfig& config,
+                              const components::ComponentContext& context)
+    : HttpMiddlewareBase(config, context)
+    , ids_(context.FindComponent<IntrusionDetectionSystem>()) {
+    
+    log_suspicious_requests_ = config["log-suspicious-requests"].As<bool>(true);
+  }
+  
+  void HandleRequest(server::http::HttpRequest& request,
+                     server::request::RequestContext& context,
+                     server::middlewares::Next next) const override {
+    
+    // Analyze request for suspicious activity
+    if (ids_.AnalyzeRequest(request)) {
+      // Request should be blocked
+      LOG_WARNING() << "IDS blocked suspicious request from " 
+                    << request.GetRemoteAddress() << " to " << request.GetPath();
+      
+      request.SetResponseStatus(server::http::HttpStatus::kForbidden);
+      request.SetResponseBody("Request blocked by security system");
+      return;
+    }
+    
+    // Continue with normal request processing
+    next(request, context);
+  }
+
+private:
+  IntrusionDetectionSystem& ids_;
+  bool log_suspicious_requests_;
+};
+```
+
+## Security Monitoring and Incident Response
+
+### Security Monitoring Component
+```cpp
+#include <userver/components/component.hpp>
+#include <userver/metrics/metric_tag.hpp>
+#include <userver/concurrent/variable.hpp>
+#include <userver/tracing/span.hpp>
+
+class SecurityMonitoring {
+public:
+  struct SecurityEvent {
+    std::string event_type;
+    std::string description;
+    std::string source;
+    std::string user_id;
+    std::chrono::system_clock::time_point timestamp;
+    std::string severity; // info, warning, error, critical
+    std::unordered_map<std::string, std::string> metadata;
+  };
+  
+  struct SecurityMetrics {
+    std::atomic<uint64_t> authentication_failures{0};
+    std::atomic<uint64_t> authorization_failures{0};
+    std::atomic<uint64_t> security_violations{0};
+    std::atomic<uint64_t> suspicious_activities{0};
+    std::atomic<uint64_t> data_access_attempts{0};
+    std::atomic<uint64_t> data_modification_attempts{0};
+  };
+  
+  SecurityMonitoring(const components::ComponentConfig& config,
+                    const components::ComponentContext& context)
+    : event_retention_period_(config["event-retention-period"].As<int>(86400)) // 24 hours
+    , enable_real_time_alerts_(config["enable-real-time-alerts"].As<bool>(true))
+    , log_security_events_(config["log-security-events"].As<bool>(true)) {
+    
+    // Initialize metrics
+    InitializeMetrics(context);
+    
+    // Start event cleanup task
+    cleanup_task_ = utils::Async("security-event-cleanup", [this]() {
+      EventCleanupLoop();
+    });
+  }
+  
+  void LogSecurityEvent(const std::string& event_type,
+                       const std::string& description,
+                       const std::string& source,
+                       const std::string& user_id = "",
+                       const std::string& severity = "info",
+                       std::unordered_map<std::string, std::string> metadata = {}) {
+    
+    SecurityEvent event;
+    event.event_type = event_type;
+    event.description = description;
+    event.source = source;
+    event.user_id = user_id;
+    event.timestamp = std::chrono::system_clock::now();
+    event.severity = severity;
+    event.metadata = std::move(metadata);
+    
+    // Store event
+    {
+      auto events = security_events_.Lock();
+      events->push_back(event);
+    }
+    
+    // Log event
+    if (log_security_events_) {
+      LOG_INFO() << "Security Event - Type: " << event_type
+                 << ", Source: " << source
+                 << ", User: " << user_id
+                 << ", Severity: " << severity
+                 << ", Description: " << description;
+    }
+    
+    // Update metrics
+    UpdateMetrics(event);
+    
+    // Send real-time alert if enabled
+    if (enable_real_time_alerts_) {
+      SendRealTimeAlert(event);
+    }
+  }
+  
+  std::vector<SecurityEvent> GetRecentEvents(size_t limit = 100,
+                                           const std::string& event_type = "",
+                                           const std::string& severity = "") {
+    std::vector<SecurityEvent> recent_events;
+    
+    auto events = security_events_.Lock();
+    auto now = std::chrono::system_clock::now();
+    auto cutoff = now - std::chrono::seconds(event_retention_period_);
+    
+    for (auto it = events->rbegin(); 
+         it != events->rend() && recent_events.size() < limit; 
+         ++it) {
+      
+      // Check retention period
+      if (it->timestamp < cutoff) {
+        break;
+      }
+      
+      // Filter by event type if specified
+      if (!event_type.empty() && it->event_type != event_type) {
+        continue;
+      }
+      
+      // Filter by severity if specified
+      if (!severity.empty() && it->severity != severity) {
+        continue;
+      }
+      
+      recent_events.push_back(*it);
+    }
+    
+    return recent_events;
+  }
+  
+  SecurityMetrics GetSecurityMetrics() const {
+    return metrics_;
+  }
+  
+  std::vector<SecurityEvent> SearchEvents(const std::string& query,
+                                        std::chrono::system_clock::time_point start_time,
+                                        std::chrono::system_clock::time_point end_time) {
+    std::vector<SecurityEvent> matching_events;
+    
+    auto events = security_events_.Lock();
+    for (const auto& event : *events) {
+      // Check time range
+      if (event.timestamp < start_time || event.timestamp > end_time) {
+        continue;
+      }
+      
+      // Check if query matches any field
+      if (event.event_type.find(query) != std::string::npos ||
+          event.description.find(query) != std::string::npos ||
+          event.source.find(query) != std::string::npos ||
+          event.user_id.find(query) != std::string::npos) {
+        matching_events.push_back(event);
+      }
+    }
+    
+    return matching_events;
+  }
+
+private:
+  void InitializeMetrics(const components::ComponentContext& context) {
+    // Initialize security metrics
+    auto& metrics = context.FindComponent<components::StatisticsStorage>().GetMetricsStorage();
+    
+    auth_failures_counter_ = metrics.CreateCounterMetric(
+      {"security", "authentication", "failures"}, "Number of authentication failures");
+    
+    authz_failures_counter_ = metrics.CreateCounterMetric(
+      {"security", "authorization", "failures"}, "Number of authorization failures");
+    
+    violations_counter_ = metrics.CreateCounterMetric(
+      {"security", "violations"}, "Number of security violations");
+    
+    suspicious_counter_ = metrics.CreateCounterMetric(
+      {"security", "suspicious"}, "Number of suspicious activities");
+  }
+  
+  void UpdateMetrics(const SecurityEvent& event) {
+    if (event.event_type == "authentication_failure") {
+      metrics_.authentication_failures++;
+      auth_failures_counter_.Account(1);
+    } else if (event.event_type == "authorization_failure") {
+      metrics_.authorization_failures++;
+      authz_failures_counter_.Account(1);
+    } else if (event.severity == "error" || event.severity == "critical") {
+      metrics_.security_violations++;
+      violations_counter_.Account(1);
+    } else if (event.severity == "warning") {
+      metrics_.suspicious_activities++;
+      suspicious_counter_.Account(1);
+    }
+  }
+  
+  void SendRealTimeAlert(const SecurityEvent& event) {
+    // Send real-time alert for critical events
+    if (event.severity == "critical" || event.severity == "error") {
+      // This could integrate with external alerting systems
+      // such as PagerDuty, Slack, email, etc.
+      
+      LOG_CRITICAL() << "SECURITY ALERT: " << event.event_type
+                     << " from " << event.source
+                     << " - " << event.description;
+    }
+  }
+  
+  void EventCleanupLoop() {
+    while (!should_stop_) {
+      engine::SleepFor(std::chrono::minutes(30));
+      
+      try {
+        CleanupOldEvents();
+      } catch (const std::exception& e) {
+        LOG_ERROR() << "Security event cleanup failed: " << e.what();
+      }
+    }
+  }
+  
+  void CleanupOldEvents() {
+    auto now = std::chrono::system_clock::now();
+    auto cutoff = now - std::chrono::seconds(event_retention_period_);
+    
+    auto events = security_events_.Lock();
+    events->erase(
+      std::remove_if(events->begin(), events->end(),
+                    [cutoff](const SecurityEvent& event) {
+                      return event.timestamp < cutoff;
+                    }),
+      events->end()
+    );
+  }
+  
+  concurrent::Variable<std::vector<SecurityEvent>> security_events_;
+  SecurityMetrics metrics_;
+  int event_retention_period_;
+  bool enable_real_time_alerts_;
+  bool log_security_events_;
+  
+  engine::TaskWithResult<void> cleanup_task_;
+  std::atomic<bool> should_stop_{false};
+  
+  metrics::CounterMetric auth_failures_counter_;
+  metrics::CounterMetric authz_failures_counter_;
+  metrics::CounterMetric violations_counter_;
+  metrics::CounterMetric suspicious_counter_;
+};
+
+// Security monitoring component
+class SecurityMonitoringComponent : public components::ComponentBase {
+public:
+  static constexpr std::string_view kName = "security-monitoring";
+  
+  SecurityMonitoringComponent(const components::ComponentConfig& config,
+                             const components::ComponentContext& context)
+    : ComponentBase(config, context)
+    , monitoring_(std::make_unique<SecurityMonitoring>(config, context)) {}
+  
+  SecurityMonitoring& GetMonitoring() {
+    return *monitoring_;
+  }
+
+private:
+  std::unique_ptr<SecurityMonitoring> monitoring_;
+};
+```
+
+## Vulnerability Prevention Configuration
+
+### Static Configuration
+```yaml
+# Security test framework configuration
+security-test-framework:
+  test-interval: 3600  # 1 hour
+  enable-automated-testing: true
+  
+  custom-tests:
+    - name: "api-rate-limit-test"
+      description: "Test API rate limiting"
+      category: "dos"
+      endpoint: "/api/test-endpoint"
+      method: "GET"
+      timeout: 30
+      
+    - name: "input-validation-test"
+      description: "Test input validation"
+      category: "injection"
+      endpoint: "/api/input-test"
+      method: "POST"
+      timeout: 30
+
+# Intrusion detection system configuration
+intrusion-detection:
+  alert-threshold: 10
+  block-threshold: 50
+  enable-blocking: false
+  log-alerts: true
+  
+  custom-rules:
+    - name: "custom-suspicious-pattern"
+      description: "Custom suspicious pattern detection"
+      severity: 7
+      cooldown: 60
+
+# Security monitoring configuration
+security-monitoring:
+  event-retention-period: 86400  # 24 hours
+  enable-real-time-alerts: true
+  log-security-events: true
+
+# Penetration testing configuration
+penetration-testing:
+  enabled: true
+  target-endpoints: ["/api/*", "/admin/*"]
+  exclude-paths: ["/api/health", "/metrics"]
+  test-depth: "comprehensive"  # basic, standard, comprehensive
+  report-format: "json"  # json, xml, html
+```
+
+## Cross-References
+
+### Related Framework Components
+- [Security Best Practices](security-best-practices.md) - Input validation, security headers
+- [Authentication Patterns](authentication.md) - Secure authentication mechanisms
+- [Authorization Patterns](authorization.md) - Access control validation
+- [Encryption Patterns](encryption.md) - Data protection and secure communication
+- [Framework Core](../../memory-bank/main/framework-core.md) - Core security utilities
+
+### Security Implementation References
+- [Network Security](../networking/network-security.md) - Network-level security measures
+- [Database Security](../database/database-security.md) - Database security best practices
+- [Component System](../../memory-bank/main/component-system.md) - Security component integration
+
+### Implementation References
+- [`clients::http::Client`](https://userver.tech/d1/d00/classclients_1_1http_1_1Client.html)
+- [`formats::json::Value`](https://userver.tech/d7/d00/classformats_1_1json_1_1Value.html)
+- [`metrics::MetricTag`](https://userver.tech/d3/d00/classmetrics_1_1MetricTag.html)
+- [`tracing::Span`](https://userver.tech/d4/d00/classtracing_1_1Span.html)
+- [`concurrent::Variable`](https://userver.tech/d8/dcc/namespaceconcurrent.html)
\ No newline at end of file
diff --git a/sqlite/CMakeLists.txt b/sqlite/CMakeLists.txt
index d443c0addd38..66ef8bb9f69c 100755
--- a/sqlite/CMakeLists.txt
+++ b/sqlite/CMakeLists.txt
@@ -30,6 +30,7 @@ userver_module(
     SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}"
     LINK_LIBRARIES_PRIVATE SQLite::SQLite3
     UTEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*_test.cpp"
+    DEPENDS core
 )
 
 if(USERVER_BUILD_TESTS)
diff --git a/sqlite/include/userver/storages/sqlite/component.hpp b/sqlite/include/userver/storages/sqlite/component.hpp
index 8b2e56695600..f4d3af8d05b3 100644
--- a/sqlite/include/userver/storages/sqlite/component.hpp
+++ b/sqlite/include/userver/storages/sqlite/component.hpp
@@ -49,7 +49,7 @@ namespace components {
 /// ---------------------------------- | --------------------------------------------------------------------------------- | ---------------
 /// fs-task-processor                  | name of the task processor to handle the blocking file operations                 | engine::current_task::GetBlockingTaskProcessor()
 /// db-path                            | path to the database file or `::memory::` for in-memory mode                      | -
-/// create_file                        | сreate the database file if it does not exist at the specified path               | true
+/// create_file                        | create the database file if it does not exist at the specified path               | true
 /// is_read_only                       | open the database in read-only mode                                               | false
 /// shared_cache                       | enable shared in-memory cache for the database                                    | false
 /// read_uncommitted                   | allow reading uncommitted data (requires shared_cache)                            | false
diff --git a/sqlite/include/userver/storages/sqlite/impl/statement.hpp b/sqlite/include/userver/storages/sqlite/impl/statement.hpp
index 5858bfb097b0..d9b436199b27 100644
--- a/sqlite/include/userver/storages/sqlite/impl/statement.hpp
+++ b/sqlite/include/userver/storages/sqlite/impl/statement.hpp
@@ -74,7 +74,7 @@ class Statement final : public StatementBase {
 
     using NativeStatementPtr = std::unique_ptr<sqlite3_stmt, SQLiteStatementDeleter>;
 
-    NativeStatementPtr prepareStatement(std::string_view statement_str);
+    NativeStatementPtr PrepareStatement(std::string_view statement_str);
 
     const NativeHandler& db_handler_;
     NativeStatementPtr prepare_statement_;
diff --git a/sqlite/include/userver/storages/sqlite/infra/statistics/statistics_counter.hpp b/sqlite/include/userver/storages/sqlite/infra/statistics/statistics_counter.hpp
index 79a93be7817a..0d570df26139 100644
--- a/sqlite/include/userver/storages/sqlite/infra/statistics/statistics_counter.hpp
+++ b/sqlite/include/userver/storages/sqlite/infra/statistics/statistics_counter.hpp
@@ -24,7 +24,7 @@ class QueryStatCounter {
 
 private:
     PoolQueriesStatistics& queries_stats_;
-    utils::datetime::SteadyClock::time_point exec_begin_time;
+    utils::datetime::SteadyClock::time_point exec_begin_time_;
 };
 
 class TransactionStatCounter {
@@ -42,7 +42,7 @@ class TransactionStatCounter {
 
 private:
     PoolTransactionsStatistics& transactions_stats_;
-    utils::datetime::SteadyClock::time_point exec_begin_time;
+    utils::datetime::SteadyClock::time_point exec_begin_time_;
 };
 
 }  // namespace storages::sqlite::infra::statistics
diff --git a/sqlite/include/userver/storages/sqlite/transaction.hpp b/sqlite/include/userver/storages/sqlite/transaction.hpp
index 61a54092da2a..ab7ab517a41f 100644
--- a/sqlite/include/userver/storages/sqlite/transaction.hpp
+++ b/sqlite/include/userver/storages/sqlite/transaction.hpp
@@ -3,6 +3,7 @@
 /// @file userver/storages/sqlite/transaction.hpp
 
 #include <userver/utils/fast_pimpl.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 #include <userver/storages/sqlite/cursor_result_set.hpp>
 #include <userver/storages/sqlite/impl/binder_help.hpp>
@@ -105,6 +106,7 @@ class Transaction final {
     void AccountQueryFailed() const noexcept;
 
     std::shared_ptr<infra::ConnectionPtr> connection_;
+    utils::trx_tracker::TransactionLock trx_lock_;
 };
 
 template <typename... Args>
diff --git a/sqlite/src/storages/sqlite/component.cpp b/sqlite/src/storages/sqlite/component.cpp
index 9057d2e4aa5d..49db55301aad 100644
--- a/sqlite/src/storages/sqlite/component.cpp
+++ b/sqlite/src/storages/sqlite/component.cpp
@@ -123,7 +123,7 @@ additionalProperties: false
         description: path to the database file or `::memory::` for in-memory mode
     create_file:
         type: boolean
-        description: сreate the database file if it does not exist at the specified path
+        description: create the database file if it does not exist at the specified path
         defaultDescription: true
     is_read_only:
         type: boolean
diff --git a/sqlite/src/storages/sqlite/impl/statement.cpp b/sqlite/src/storages/sqlite/impl/statement.cpp
index 54e40a64fe53..390dba2442f8 100644
--- a/sqlite/src/storages/sqlite/impl/statement.cpp
+++ b/sqlite/src/storages/sqlite/impl/statement.cpp
@@ -16,7 +16,7 @@ namespace storages::sqlite::impl {
 
 Statement::Statement(const NativeHandler& db_handler, std::string_view statement)
     : db_handler_{db_handler},
-      prepare_statement_(prepareStatement(statement)),
+      prepare_statement_(PrepareStatement(statement)),
       column_count_(sqlite3_column_count(prepare_statement_.get())) {}
 
 Statement::~Statement() = default;
@@ -54,7 +54,7 @@ OperationType Statement::GetOperationType() const noexcept {
     return sqlite3_stmt_readonly(prepare_statement_.get()) ? OperationType::kReadOnly : OperationType::kReadWrite;
 }
 
-Statement::NativeStatementPtr Statement::prepareStatement(std::string_view statement_str) {
+Statement::NativeStatementPtr Statement::PrepareStatement(std::string_view statement_str) {
     sqlite3_stmt* statement = nullptr;
     // TODO: It can indirectly triggers I/O?
     const int ret_code = sqlite3_prepare_v2(
diff --git a/sqlite/src/storages/sqlite/infra/statistics/statistics_counter.cpp b/sqlite/src/storages/sqlite/infra/statistics/statistics_counter.cpp
index 7e3c06b24d2b..673acc44985f 100644
--- a/sqlite/src/storages/sqlite/infra/statistics/statistics_counter.cpp
+++ b/sqlite/src/storages/sqlite/infra/statistics/statistics_counter.cpp
@@ -10,13 +10,13 @@ QueryStatCounter::~QueryStatCounter() = default;
 
 void QueryStatCounter::AccountQueryExecute() noexcept {
     ++queries_stats_.total;
-    exec_begin_time = utils::datetime::SteadyClock::now();
+    exec_begin_time_ = utils::datetime::SteadyClock::now();
 }
 
 void QueryStatCounter::AccountQueryCompleted() noexcept {
     auto now = utils::datetime::SteadyClock::now();
     ++queries_stats_.executed;
-    queries_stats_.timings.Account(std::chrono::duration_cast<std::chrono::milliseconds>(now - exec_begin_time).count()
+    queries_stats_.timings.Account(std::chrono::duration_cast<std::chrono::milliseconds>(now - exec_begin_time_).count()
     );
 }
 
@@ -28,14 +28,14 @@ TransactionStatCounter::~TransactionStatCounter() = default;
 
 void TransactionStatCounter::AccountTransactionStart() noexcept {
     ++transactions_stats_.total;
-    exec_begin_time = utils::datetime::SteadyClock::now();
+    exec_begin_time_ = utils::datetime::SteadyClock::now();
 }
 
 void TransactionStatCounter::AccountTransactionCommit() noexcept {
     auto now = utils::datetime::SteadyClock::now();
     ++transactions_stats_.commit;
     transactions_stats_.timings.Account(
-        std::chrono::duration_cast<std::chrono::milliseconds>(now - exec_begin_time).count()
+        std::chrono::duration_cast<std::chrono::milliseconds>(now - exec_begin_time_).count()
     );
 }
 
diff --git a/sqlite/src/storages/sqlite/transaction.cpp b/sqlite/src/storages/sqlite/transaction.cpp
index 7109a71573f6..79be32dfe4d0 100644
--- a/sqlite/src/storages/sqlite/transaction.cpp
+++ b/sqlite/src/storages/sqlite/transaction.cpp
@@ -13,6 +13,7 @@ Transaction::Transaction(std::shared_ptr<infra::ConnectionPtr> connection, const
     : connection_{std::move(connection)} {
     if (connection_ && connection_->IsValid()) {
         (*connection_)->Begin(options);
+        trx_lock_.Lock();
     }
 }
 
@@ -46,6 +47,7 @@ void Transaction::Commit() {
     {
         auto connection = std::move(connection_);
         (*connection)->Commit();
+        trx_lock_.Unlock();
     }
 }
 
@@ -54,6 +56,7 @@ void Transaction::Rollback() {
     {
         auto connection = std::move(connection_);
         (*connection)->Rollback();
+        trx_lock_.Unlock();
     }
 }
 
diff --git a/testsuite/requirements-grpc-6.txt b/testsuite/requirements-grpc-6.txt
new file mode 100644
index 000000000000..535514129035
--- /dev/null
+++ b/testsuite/requirements-grpc-6.txt
@@ -0,0 +1,4 @@
+grpcio >= 1.72.0
+grpcio-tools >= 1.72.0
+grpcio-reflection >= 1.72.0
+protobuf >= 6.30.0, < 7.0dev
diff --git a/third_party/date/README.md b/third_party/date/README.md
index 41cade454ff8..03c8213fdcae 100644
--- a/third_party/date/README.md
+++ b/third_party/date/README.md
@@ -1,6 +1,6 @@
 date.h is imported from https://github.com/HowardHinnant/date
 
-Tag: v3.0.1
+Commit: a5db3aecec580bc78b6c01c118f2628676769b69
 
 # Date
 
diff --git a/third_party/date/include/date/date.h b/third_party/date/include/date/date.h
index 7b6b4e4cb9d7..ded0ba23f5aa 100644
--- a/third_party/date/include/date/date.h
+++ b/third_party/date/include/date/date.h
@@ -84,6 +84,12 @@
 #   pragma warning(disable : 4127)
 #endif
 
+#if (defined(__GNUC__) && __GNUC__ < 5) && !defined(__clang__) && !defined(_MSC_VER)
+#  define OPERATOR_LITERAL(suffix) operator"" _##suffix
+#else
+#  define OPERATOR_LITERAL(suffix) operator""_##suffix
+#endif
+
 namespace date
 {
 
@@ -963,8 +969,8 @@ operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last&
 inline namespace literals
 {
 
-CONSTCD11 date::day  operator "" _d(unsigned long long d) NOEXCEPT;
-CONSTCD11 date::year operator "" _y(unsigned long long y) NOEXCEPT;
+CONSTCD11 date::day  OPERATOR_LITERAL(d)(unsigned long long d) NOEXCEPT;
+CONSTCD11 date::year OPERATOR_LITERAL(y)(unsigned long long y) NOEXCEPT;
 
 }  // inline namespace literals
 #endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)
@@ -1316,7 +1322,7 @@ CONSTCD11
 std::chrono::duration<Rep, Period>
 abs(std::chrono::duration<Rep, Period> d)
 {
-    return d >= d.zero() ? d : -d;
+    return d >= d.zero() ? d : static_cast<decltype(d)>(-d);
 }
 
 // round down
@@ -1972,7 +1978,7 @@ inline namespace literals
 CONSTCD11
 inline
 date::day
-operator "" _d(unsigned long long d) NOEXCEPT
+OPERATOR_LITERAL(d)(unsigned long long d) NOEXCEPT
 {
     return date::day{static_cast<unsigned>(d)};
 }
@@ -1980,7 +1986,7 @@ operator "" _d(unsigned long long d) NOEXCEPT
 CONSTCD11
 inline
 date::year
-operator "" _y(unsigned long long y) NOEXCEPT
+OPERATOR_LITERAL(y)(unsigned long long y) NOEXCEPT
 {
     return date::year(static_cast<int>(y));
 }
@@ -4206,8 +4212,8 @@ template <class CharT, class Traits, class Duration>
 inline
 typename std::enable_if
 <
-    std::ratio_less<typename Duration::period, days::period>::value
-    , std::basic_ostream<CharT, Traits>&
+    !std::is_convertible<Duration, days>::value,
+    std::basic_ostream<CharT, Traits>&
 >::type
 operator<<(std::basic_ostream<CharT, Traits>& os, const sys_time<Duration>& tp)
 {
@@ -4228,7 +4234,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const local_time<Duration>& ut)
 {
-    return (os << sys_time<Duration>{ut.time_since_epoch()});
+    return (date::operator<<(os, sys_time<Duration>{ut.time_since_epoch()}));
 }
 
 namespace detail
@@ -4787,7 +4793,11 @@ struct fields
     hh_mm_ss<Duration>    tod{};
     bool                  has_tod = false;
 
+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ <= 409)
+    fields() : ymd{nanyear/0/0}, wd{8u}, tod{}, has_tod{false} {}
+#else
     fields() = default;
+#endif
 
     fields(year_month_day ymd_) : ymd(ymd_) {}
     fields(weekday wd_) : wd(wd_) {}
@@ -6209,8 +6219,13 @@ to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
           const std::chrono::seconds* offset_sec = nullptr)
 {
     using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
-    auto ld = floor<days>(tp);
-    fields<CT> fds{year_month_day{ld}, hh_mm_ss<CT>{tp-local_seconds{ld}}};
+    auto ld = std::chrono::time_point_cast<days>(tp);
+    fields<CT> fds;
+    if (ld <= tp)
+        fds = fields<CT>{year_month_day{ld}, hh_mm_ss<CT>{tp-local_seconds{ld}}};
+    else
+        fds = fields<CT>{year_month_day{ld - days{1}},
+                         hh_mm_ss<CT>{days{1} - (local_seconds{ld} - tp)}};
     return to_stream(os, fmt, fds, abbrev, offset_sec);
 }
 
@@ -6223,8 +6238,13 @@ to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
     using CT = typename std::common_type<Duration, seconds>::type;
     const std::string abbrev("UTC");
     CONSTDATA seconds offset{0};
-    auto sd = floor<days>(tp);
-    fields<CT> fds{year_month_day{sd}, hh_mm_ss<CT>{tp-sys_seconds{sd}}};
+    auto sd = std::chrono::time_point_cast<days>(tp);
+    fields<CT> fds;
+    if (sd <= tp)
+        fds = fields<CT>{year_month_day{sd}, hh_mm_ss<CT>{tp-sys_seconds{sd}}};
+    else
+        fds = fields<CT>{year_month_day{sd - days{1}},
+                         hh_mm_ss<CT>{days{1} - (sys_seconds{sd} - tp)}};
     return to_stream(os, fmt, fds, &abbrev, &offset);
 }
 
@@ -6337,7 +6357,10 @@ read_signed(std::basic_istream<CharT, Traits>& is, unsigned m = 1, unsigned M =
         if (('0' <= c && c <= '9') || c == '-' || c == '+')
         {
             if (c == '-' || c == '+')
+            {
                 (void)is.get();
+                --M;
+            }
             auto x = static_cast<int>(read_unsigned(is, std::max(m, 1u), M));
             if (!is.fail())
             {
@@ -6401,7 +6424,7 @@ read_long_double(std::basic_istream<CharT, Traits>& is, unsigned m = 1, unsigned
         is.setstate(std::ios::failbit);
         return 0;
     }
-    return i + f/std::pow(10.L, fcount);
+    return static_cast<long double>(i) + static_cast<long double>(f)/std::pow(10.L, fcount);
 }
 
 struct rs
@@ -6510,7 +6533,14 @@ read(std::basic_istream<CharT, Traits>& is, int a0, Args&& ...args)
             *e++ = static_cast<CharT>(CharT(u % 10) + CharT{'0'});
             u /= 10;
         } while (u > 0);
+#if defined(__GNUC__) && __GNUC__ >= 11
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
         std::reverse(buf, e);
+#if defined(__GNUC__) && __GNUC__ >= 11
+#pragma GCC diagnostic pop
+#endif
         for (auto p = buf; p != e && is.rdstate() == std::ios::goodbit; ++p)
             read(is, *p);
     }
@@ -6576,7 +6606,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
 
         CONSTDATA int not_a_year = numeric_limits<short>::min();
         CONSTDATA int not_a_2digit_year = 100;
-        CONSTDATA int not_a_century = not_a_year / 100;
+        CONSTDATA int not_a_century = numeric_limits<int>::min();
         CONSTDATA int not_a_month = 0;
         CONSTDATA int not_a_day = 0;
         CONSTDATA int not_a_hour = numeric_limits<int>::min();
@@ -6760,14 +6790,14 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                         checked_set(m, static_cast<int>(i % 12 + 1), not_a_month, is);
                         ws(is);
                         int td = not_a_day;
-                        read(is, rs{td, 1, 2});
+                        read(is, ru{td, 1, 2});
                         checked_set(d, td, not_a_day, is);
                         ws(is);
                         using dfs = detail::decimal_format_seconds<Duration>;
                         CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
                         int tH;
                         int tM;
-                        long double S;
+                        long double S{};
                         read(is, ru{tH, 1, 2}, CharT{':'}, ru{tM, 1, 2},
                                                CharT{':'}, rld{S, 1, w});
                         checked_set(H, tH, not_a_hour, is);
@@ -6776,7 +6806,9 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                                     not_a_second, is);
                         ws(is);
                         int tY = not_a_year;
-                        read(is, rs{tY, 1, 4u});
+                        // No need for `rs` here, negative years can't parse
+                        // with "%c" since `width` is hardcoded to 4
+                        read(is, ru{tY, 1, 4u});
                         checked_set(Y, tY, not_a_year, is);
 #endif
                     }
@@ -6810,7 +6842,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                         int tm = not_a_month;
                         int td = not_a_day;
                         read(is, ru{tm, 1, 2}, CharT{'/'}, ru{td, 1, 2}, CharT{'/'},
-                                 rs{ty, 1, 2});
+                                 ru{ty, 1, 2});
                         checked_set(y, ty, not_a_2digit_year, is);
                         checked_set(m, tm, not_a_month, is);
                         checked_set(d, td, not_a_day, is);
@@ -6847,7 +6879,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                         CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
                         int tH = not_a_hour;
                         int tM = not_a_minute;
-                        long double S;
+                        long double S{};
                         read(is, ru{tH, 1, 2}, CharT{':'}, ru{tM, 1, 2},
                                                CharT{':'}, rld{S, 1, w});
                         checked_set(H, tH, not_a_hour, is);
@@ -6906,7 +6938,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                         int ty = not_a_2digit_year;
                         read(is, ru{tn, 1, 2}, CharT{'\0'}, CharT{'/'}, CharT{'\0'},
                                  ru{td, 1, 2}, CharT{'\0'}, CharT{'/'}, CharT{'\0'},
-                                 rs{ty, 1, 2});
+                                 ru{ty, 1, 2});
                         checked_set(y, ty, not_a_2digit_year, is);
                         checked_set(m, tn, not_a_month, is);
                         checked_set(d, td, not_a_day, is);
@@ -6954,7 +6986,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
 #endif
                     {
                         int td = not_a_day;
-                        read(is, rs{td, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
+                        read(is, ru{td, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
                         checked_set(d, td, not_a_day, is);
                     }
 #if !ONLY_C_LOCALE
@@ -7018,7 +7050,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                     {
                         int tI = not_a_hour_12_value;
                         // reads in an hour into I, but most be in [1, 12]
-                        read(is, rs{tI, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
+                        read(is, ru{tI, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
                         if (!(1 <= tI && tI <= 12))
                             is.setstate(ios::failbit);
                         checked_set(I, tI, not_a_hour_12_value, is);
@@ -7092,7 +7124,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
 #endif
                     {
                         int tn = not_a_month;
-                        read(is, rs{tn, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
+                        read(is, ru{tn, 1, width == -1 ? 2u : static_cast<unsigned>(width)});
                         checked_set(m, tn, not_a_month, is);
                     }
 #if !ONLY_C_LOCALE
@@ -7202,7 +7234,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                         // "%I:%M:%S %p"
                         using dfs = detail::decimal_format_seconds<Duration>;
                         CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
-                        long double S;
+                        long double S{};
                         int tI = not_a_hour_12_value;
                         int tM = not_a_minute;
                         read(is, ru{tI, 1, 2}, CharT{':'}, ru{tM, 1, 2},
@@ -7258,7 +7290,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                     {
                         using dfs = detail::decimal_format_seconds<Duration>;
                         CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
-                        long double S;
+                        long double S{};
                         read(is, rld{S, 1, width == -1 ? w : static_cast<unsigned>(width)});
                         checked_set(s, round_i<Duration>(duration<long double>{S}),
                                     not_a_second, is);
@@ -7292,7 +7324,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                         CONSTDATA auto w = Duration::period::den == 1 ? 2 : 3 + dfs::width;
                         int tH = not_a_hour;
                         int tM = not_a_minute;
-                        long double S;
+                        long double S{};
                         read(is, ru{tH, 1, 2}, CharT{':'}, ru{tM, 1, 2},
                                                CharT{':'}, rld{S, 1, w});
                         checked_set(H, tH, not_a_hour, is);
@@ -7503,11 +7535,16 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                     {
                         auto c = static_cast<char>(Traits::to_char_type(ic));
                         if (c == '-')
+                        {
                             neg = true;
+                            (void)is.get();
+                        }
+                        else if (c == '+')
+                            (void)is.get();
                     }
                     if (modified == CharT{})
                     {
-                        read(is, rs{tH, 2, 2});
+                        read(is, ru{tH, 2, 2});
                         if (!is.fail())
                             toff = hours{std::abs(tH)};
                         if (is.good())
@@ -7527,7 +7564,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                     }
                     else
                     {
-                        read(is, rs{tH, 1, 2});
+                        read(is, ru{tH, 1, 2});
                         if (!is.fail())
                             toff = hours{std::abs(tH)};
                         if (is.good())
@@ -7546,7 +7583,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                             }
                         }
                     }
-                    if (neg)
+                    if (neg && !is.fail())
                         toff = -toff;
                     checked_set(temp_offset, toff, not_a_offset, is);
                     command = nullptr;
@@ -7719,9 +7756,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                 year_month_day ymd_trial = sys_days(year{Y}/January/Sunday[1]) +
                                            weeks{U-1} +
                                            (weekday{static_cast<unsigned>(wd)} - Sunday);
-                if (Y == not_a_year)
-                    Y = static_cast<int>(ymd_trial.year());
-                else if (year{Y} != ymd_trial.year())
+                if (year{Y} != ymd_trial.year())
                     goto broken;
                 if (m == not_a_month)
                     m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
@@ -7738,9 +7773,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
                 year_month_day ymd_trial = sys_days(year{Y}/January/Monday[1]) +
                                            weeks{W-1} +
                                            (weekday{static_cast<unsigned>(wd)} - Monday);
-                if (Y == not_a_year)
-                    Y = static_cast<int>(ymd_trial.year());
-                else if (year{Y} != ymd_trial.year())
+                if (year{Y} != ymd_trial.year())
                     goto broken;
                 if (m == not_a_month)
                     m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
@@ -7755,11 +7788,11 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
             if (j != not_a_doy && Y != not_a_year)
             {
                 auto ymd_trial = year_month_day{local_days(year{Y}/1/1) + days{j-1}};
-                if (m == 0)
+                if (m == not_a_month)
                     m = static_cast<int>(static_cast<unsigned>(ymd_trial.month()));
                 else if (month(static_cast<unsigned>(m)) != ymd_trial.month())
                     goto broken;
-                if (d == 0)
+                if (d == not_a_day)
                     d = static_cast<int>(static_cast<unsigned>(ymd_trial.day()));
                 else if (day(static_cast<unsigned>(d)) != ymd_trial.day())
                     goto broken;
@@ -7891,7 +7924,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, year& y,
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.year().ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -7907,7 +7940,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, month& m,
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.month().ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -7923,7 +7956,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, day& d,
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.day().ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -7939,7 +7972,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, weekday& wd
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.wd.ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -7955,7 +7988,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, year_month&
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.month().ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -7971,7 +8004,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt, month_day&
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.month().ok() || !fds.ymd.day().ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -7987,7 +8020,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
 {
     using CT = std::chrono::seconds;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.ok())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -8003,15 +8036,25 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
 {
     using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
     using detail::round_i;
-    std::chrono::minutes offset_local{};
-    auto offptr = offset ? offset : &offset_local;
+    std::chrono::minutes offset_local = std::chrono::minutes::min();
     fields<CT> fds{};
     fds.has_tod = true;
-    from_stream(is, fmt, fds, abbrev, offptr);
+    date::from_stream(is, fmt, fds, abbrev, &offset_local);
     if (!fds.ymd.ok() || !fds.tod.in_conventional_range())
         is.setstate(std::ios::failbit);
     if (!is.fail())
-        tp = round_i<Duration>(sys_days(fds.ymd) - *offptr + fds.tod.to_duration());
+    {
+        if (offset_local != std::chrono::minutes::min())
+        {
+            tp = round_i<Duration>(sys_days(fds.ymd) - offset_local + fds.tod.to_duration());
+            if (offset != nullptr)
+                *offset = offset_local;
+        }
+        else
+        {
+            tp = round_i<Duration>(sys_days(fds.ymd) + fds.tod.to_duration());
+        }
+    }
     return is;
 }
 
@@ -8025,7 +8068,7 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
     using detail::round_i;
     fields<CT> fds{};
     fds.has_tod = true;
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.ymd.ok() || !fds.tod.in_conventional_range())
         is.setstate(std::ios::failbit);
     if (!is.fail())
@@ -8042,12 +8085,13 @@ from_stream(std::basic_istream<CharT, Traits>& is, const CharT* fmt,
 {
     using Duration = std::chrono::duration<Rep, Period>;
     using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
+    using detail::round_i;
     fields<CT> fds{};
-    from_stream(is, fmt, fds, abbrev, offset);
+    date::from_stream(is, fmt, fds, abbrev, offset);
     if (!fds.has_tod)
         is.setstate(std::ios::failbit);
     if (!is.fail())
-        d = std::chrono::duration_cast<Duration>(fds.tod.to_duration());
+        d = round_i<Duration>(fds.tod.to_duration());
     return is;
 }
 
@@ -8070,8 +8114,134 @@ struct parse_manip
         , offset_(offset)
         {}
 
+#if HAS_STRING_VIEW
+    parse_manip(const CharT* format, Parsable& tp,
+                std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
+                std::chrono::minutes* offset = nullptr)
+        : format_(format)
+        , tp_(tp)
+        , abbrev_(abbrev)
+        , offset_(offset)
+        {}
+
+    parse_manip(std::basic_string_view<CharT, Traits> format, Parsable& tp,
+                std::basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
+                std::chrono::minutes* offset = nullptr)
+        : format_(format)
+        , tp_(tp)
+        , abbrev_(abbrev)
+        , offset_(offset)
+        {}
+#endif  // HAS_STRING_VIEW
 };
 
+#ifdef _MSC_VER
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+std::basic_istream<CharT, Traits>&
+operator>>(std::basic_istream<CharT, Traits>& is,
+           const parse_manip<Parsable, CharT, Traits, Alloc>& x)
+{
+    return date::from_stream(is, x.format_.c_str(), x.tp_, x.abbrev_, x.offset_);
+}
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+inline
+auto
+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
+                            format.c_str(), tp),
+                parse_manip<Parsable, CharT, Traits, Alloc>{format, tp})
+{
+    return {format, tp};
+}
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+inline
+auto
+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
+      std::basic_string<CharT, Traits, Alloc>& abbrev)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
+                            format.c_str(), tp, &abbrev),
+                parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev})
+{
+    return {format, tp, &abbrev};
+}
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+inline
+auto
+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
+      std::chrono::minutes& offset)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
+                            format.c_str(), tp,
+                            std::declval<std::basic_string<CharT, Traits, Alloc>*>(),
+                            &offset),
+                parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, nullptr, &offset})
+{
+    return {format, tp, nullptr, &offset};
+}
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+inline
+auto
+parse(const std::basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
+      std::basic_string<CharT, Traits, Alloc>& abbrev, std::chrono::minutes& offset)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(),
+                            format.c_str(), tp, &abbrev, &offset),
+                parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev, &offset})
+{
+    return {format, tp, &abbrev, &offset};
+}
+
+// const CharT* formats
+
+template <class Parsable, class CharT>
+inline
+auto
+parse(const CharT* format, Parsable& tp)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT>&>(), format, tp),
+                parse_manip<Parsable, CharT>{format, tp})
+{
+    return {format, tp};
+}
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+inline
+auto
+parse(const CharT* format, Parsable& tp, std::basic_string<CharT, Traits, Alloc>& abbrev)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format,
+                            tp, &abbrev),
+                parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev})
+{
+    return {format, tp, &abbrev};
+}
+
+template <class Parsable, class CharT>
+inline
+auto
+parse(const CharT* format, Parsable& tp, std::chrono::minutes& offset)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT>&>(), format,
+                            tp, std::declval<std::basic_string<CharT>*>(), &offset),
+                parse_manip<Parsable, CharT>{format, tp, nullptr, &offset})
+{
+    return {format, tp, nullptr, &offset};
+}
+
+template <class Parsable, class CharT, class Traits, class Alloc>
+inline
+auto
+parse(const CharT* format, Parsable& tp,
+      std::basic_string<CharT, Traits, Alloc>& abbrev, std::chrono::minutes& offset)
+    -> decltype(date::from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format,
+                            tp, &abbrev, &offset),
+                parse_manip<Parsable, CharT, Traits, Alloc>{format, tp, &abbrev, &offset})
+{
+    return {format, tp, &abbrev, &offset};
+}
+
+#else  // !defined _MSC_VER
+
 template <class Parsable, class CharT, class Traits, class Alloc>
 std::basic_istream<CharT, Traits>&
 operator>>(std::basic_istream<CharT, Traits>& is,
@@ -8175,6 +8345,8 @@ parse(const CharT* format, Parsable& tp,
     return {format, tp, &abbrev, &offset};
 }
 
+#endif  // !defined _MSC_VER
+
 // duration streaming
 
 template <class CharT, class Traits, class Rep, class Period>
diff --git a/third_party/uboost_coro/CMakeLists.txt b/third_party/uboost_coro/CMakeLists.txt
index ba7bc4c58b76..72ad8405c8d4 100644
--- a/third_party/uboost_coro/CMakeLists.txt
+++ b/third_party/uboost_coro/CMakeLists.txt
@@ -93,6 +93,9 @@ if(UBOOST_CORO_USE_UCONTEXT)
     endif()
 endif()
 
-find_package(Boost REQUIRED CONFIG)
-target_link_libraries(${PROJECT_NAME} PUBLIC Boost::boost userver-internal-compile-options)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC userver-internal-compile-options)
+if(USERVER_CONAN)
+    target_link_libraries(${PROJECT_NAME} PUBLIC Boost::headers)
+endif()
 _userver_install_targets(COMPONENT core TARGETS ${PROJECT_NAME})
diff --git a/universal/CMakeLists.txt b/universal/CMakeLists.txt
index 7a6ce58d0a0c..41fb95af1e07 100644
--- a/universal/CMakeLists.txt
+++ b/universal/CMakeLists.txt
@@ -25,11 +25,6 @@ list(REMOVE_ITEM SOURCES ${UNIT_TEST_SOURCES} ${BENCH_SOURCES} ${INTERNAL_SOURCE
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
-find_package(
-    Boost REQUIRED CONFIG
-    COMPONENTS program_options filesystem regex stacktrace_basic
-    OPTIONAL_COMPONENTS stacktrace_backtrace stacktrace_windbg
-)
 include(UserverRequireDWCAS) # Should be called after `find_package(Boost)`
 
 message(STATUS "boost: ${Boost_VERSION_STRING}")
@@ -45,8 +40,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     endif()
 endif()
 
-find_package_required(OpenSSL "libssl-dev")
-
 find_package(yaml-cpp REQUIRED)
 find_package(zstd REQUIRED)
 
@@ -240,8 +233,19 @@ endif()
 target_link_libraries(
     ${PROJECT_NAME}
     PUBLIC Threads::Threads userver-internal-sanitize-options userver-internal-compile-options
-    PRIVATE Boost::filesystem Boost::program_options OpenSSL::Crypto OpenSSL::SSL
+    PRIVATE
+        Boost::filesystem
+        Boost::program_options
+        OpenSSL::SSL
+        OpenSSL::Crypto
 )
+if(TARGET Boost::algorithm)
+    # Boost from CPM
+    target_link_libraries(
+        ${PROJECT_NAME}
+        PUBLIC Boost::algorithm Boost::uuid Boost::random Boost::container
+    )
+endif()
 
 if(USERVER_CONAN)
     target_link_libraries(
@@ -432,4 +436,6 @@ _userver_directory_install(
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/userver/modules
 )
 
+_userver_install_component(MODULE universal)
+
 include(UserverEmbedFile)
diff --git a/universal/include/userver/compression/error.hpp b/universal/include/userver/compression/error.hpp
index d0812d240cf2..4cd6abae1c14 100644
--- a/universal/include/userver/compression/error.hpp
+++ b/universal/include/userver/compression/error.hpp
@@ -21,7 +21,8 @@ class TooBigError : public DecompressionError {
 
 class ErrWithCode : public DecompressionError {
 public:
-    explicit ErrWithCode(const char* errName) : DecompressionError(fmt::format("Decompression failed: {}", errName)) {}
+    explicit ErrWithCode(const char* err_name)
+        : DecompressionError(fmt::format("Decompression failed: {}", err_name)) {}
 };
 
 }  // namespace compression
diff --git a/universal/include/userver/crypto/certificate.hpp b/universal/include/userver/crypto/certificate.hpp
index d50e6c64818c..42f59393007f 100644
--- a/universal/include/userver/crypto/certificate.hpp
+++ b/universal/include/userver/crypto/certificate.hpp
@@ -42,6 +42,9 @@ class Certificate {
     /// @throw crypto::KeyParseError if failed to load the certificate.
     static Certificate LoadFromStringSkippingAttributes(std::string_view certificate);
 
+    /// Returns Subject
+    std::string GetSubject() const;
+
 private:
     explicit Certificate(std::shared_ptr<NativeType> cert) : cert_(std::move(cert)) {}
 
diff --git a/universal/include/userver/crypto/hash.hpp b/universal/include/userver/crypto/hash.hpp
index 53c6a026ee18..49b42addc74b 100644
--- a/universal/include/userver/crypto/hash.hpp
+++ b/universal/include/userver/crypto/hash.hpp
@@ -21,6 +21,9 @@ enum class Pad { kWith, kWithout };
 /// @param encoding result could be returned as binary string or encoded
 /// @throws CryptoException internal library exception
 std::string Blake2b128(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
+
+/// @overload
+std::string Blake2b128(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
 #endif
 
 /// @brief Calculates SHA-1, output format depends on encoding param
@@ -29,30 +32,45 @@ std::string Blake2b128(std::string_view data, OutputEncoding encoding = OutputEn
 /// @throws CryptoException internal library exception
 std::string Sha1(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string Sha1(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
+
 /// @brief Calculates SHA-224, output format depends on encoding param
 /// @param data binary data to calculate hash from
 /// @param encoding result could be returned as binary string or encoded
 /// @throws CryptoException internal library exception
 std::string Sha224(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string Sha224(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
+
 /// @brief Calculates SHA-256, output format depends on encoding param
 /// @param data binary data to calculate hash from
 /// @param encoding result could be returned as binary string or encoded
 /// @throws CryptoException internal library exception
 std::string Sha256(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string Sha256(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
+
 /// @brief Calculates SHA-384, output format depends on encoding param
 /// @param data binary data to calculate hash from
 /// @param encoding result could be returned as binary string or encoded
 /// @throws CryptoException internal library exception
 std::string Sha384(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string Sha384(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
+
 /// @brief Calculates SHA-512, output format depends on encoding param
 /// @param data binary data to calculate hash from
 /// @param encoding result could be returned as binary string or encoded
 /// @throws CryptoException internal library exception
 std::string Sha512(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string Sha512(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
+
 /// @brief Calculates HMAC (using SHA-1 hash), encodes result with `encoding`
 /// algorithm
 /// @param key HMAC key
@@ -61,6 +79,13 @@ std::string Sha512(std::string_view data, OutputEncoding encoding = OutputEncodi
 /// @throws CryptoException internal library exception
 std::string HmacSha1(std::string_view key, std::string_view message, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string HmacSha1(
+    std::string_view key,
+    std::initializer_list<std::string_view> message,
+    OutputEncoding encoding = OutputEncoding::kHex
+);
+
 /// @brief Calculates HMAC (using SHA-256 hash), encodes result with `encoding`
 /// algorithm
 /// @param key HMAC key
@@ -69,6 +94,13 @@ std::string HmacSha1(std::string_view key, std::string_view message, OutputEncod
 /// @throws CryptoException internal library exception
 std::string HmacSha256(std::string_view key, std::string_view message, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string HmacSha256(
+    std::string_view key,
+    std::initializer_list<std::string_view> message,
+    OutputEncoding encoding = OutputEncoding::kHex
+);
+
 /// @brief Calculates HMAC (using SHA-384 hash), encodes result with `encoding`
 /// algorithm
 /// @param key HMAC key
@@ -77,6 +109,13 @@ std::string HmacSha256(std::string_view key, std::string_view message, OutputEnc
 /// @throws CryptoException internal library exception
 std::string HmacSha384(std::string_view key, std::string_view message, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string HmacSha384(
+    std::string_view key,
+    std::initializer_list<std::string_view> message,
+    OutputEncoding encoding = OutputEncoding::kHex
+);
+
 /// @brief Calculates HMAC (using SHA-512 hash), encodes result with `encoding`
 /// algorithm
 /// @param key HMAC key
@@ -85,6 +124,13 @@ std::string HmacSha384(std::string_view key, std::string_view message, OutputEnc
 /// @throws CryptoException internal library exception
 std::string HmacSha512(std::string_view key, std::string_view message, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string HmacSha512(
+    std::string_view key,
+    std::initializer_list<std::string_view> message,
+    OutputEncoding encoding = OutputEncoding::kHex
+);
+
 /// Broken cryptographic hashes, must not be used except for compatibility
 namespace weak {
 
@@ -94,6 +140,9 @@ namespace weak {
 /// @throws CryptoException internal library exception
 std::string Md5(std::string_view data, OutputEncoding encoding = OutputEncoding::kHex);
 
+/// @overload
+std::string Md5(std::initializer_list<std::string_view> data, OutputEncoding encoding = OutputEncoding::kHex);
+
 }  // namespace weak
 }  // namespace crypto::hash
 
diff --git a/universal/include/userver/crypto/signers.hpp b/universal/include/userver/crypto/signers.hpp
index 9961b82769e5..4b1c4d4186af 100644
--- a/universal/include/userver/crypto/signers.hpp
+++ b/universal/include/userver/crypto/signers.hpp
@@ -40,7 +40,7 @@ class SignerNone final : public Signer {
 };
 
 /// HMAC-SHA signer
-template <DigestSize bits>
+template <DigestSize Bits>
 class HmacShaSigner final : public Signer {
 public:
     /// Constructor from a shared secret
@@ -63,7 +63,7 @@ using SignerHs512 = HmacShaSigner<DigestSize::k512>;
 /// @}
 
 /// Generic signer for asymmetric cryptography
-template <DsaType type, DigestSize bits>
+template <DsaType Type, DigestSize Bits>
 class DsaSigner final : public Signer {
 public:
     /// Constructor from a PEM-encoded private key and an optional passphrase
diff --git a/universal/include/userver/crypto/ssl_ctx.hpp b/universal/include/userver/crypto/ssl_ctx.hpp
new file mode 100644
index 000000000000..e99a8895f699
--- /dev/null
+++ b/universal/include/userver/crypto/ssl_ctx.hpp
@@ -0,0 +1,62 @@
+#pragma once
+
+/// @file userver/crypto/ssl_ctx.hpp
+/// @brief @copybrief crypto::SslCtx
+
+#include <memory>
+#include <string_view>
+#include <vector>
+
+#include <userver/crypto/certificate.hpp>
+#include <userver/crypto/private_key.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace crypto {
+
+/// @ingroup userver_universal userver_containers
+///
+/// SSL context
+class SslCtx {
+public:
+    static SslCtx CreateServerTlsContext(
+        const crypto::CertificatesChain& cert_chain,
+        const crypto::PrivateKey& key,
+        const std::vector<crypto::Certificate>& extra_cert_authorities = {}
+    );
+
+    static SslCtx CreateClientTlsContext(std::string_view server_name);
+
+    static SslCtx CreateClientTlsContext(
+        std::string_view server_name,
+        const crypto::Certificate& cert,
+        const crypto::PrivateKey& key,
+        const std::vector<crypto::Certificate>& extra_cert_authorities = {}
+    );
+
+    SslCtx(SslCtx&&) noexcept;
+    SslCtx& operator=(SslCtx&&) noexcept;
+    ~SslCtx();
+
+    SslCtx(const SslCtx&) = delete;
+    SslCtx& operator=(const SslCtx&) = delete;
+
+    void* GetRawSslCtx() const noexcept;
+
+private:
+    void AddCertAuthorities(const std::vector<Certificate>& cert_authorities);
+    void EnableVerifyClientCertificate();
+    void SetServerName(std::string_view server_name);
+    void SetCertificate(const crypto::Certificate& cert);
+    void SetCertificates(const crypto::CertificatesChain& cert_chain);
+    void SetPrivateKey(const crypto::PrivateKey& key);
+
+    class Impl;
+    std::unique_ptr<Impl> impl_{};
+
+    explicit SslCtx(std::unique_ptr<Impl>&& impl);
+};
+
+}  // namespace crypto
+
+USERVER_NAMESPACE_END
diff --git a/universal/include/userver/crypto/verifiers.hpp b/universal/include/userver/crypto/verifiers.hpp
index 60606aee7eb9..8115a5250fe4 100644
--- a/universal/include/userver/crypto/verifiers.hpp
+++ b/universal/include/userver/crypto/verifiers.hpp
@@ -39,7 +39,7 @@ class VerifierNone final : public Verifier {
 };
 
 /// HMAC-SHA verifier
-template <DigestSize bits>
+template <DigestSize Bits>
 class HmacShaVerifier final : public Verifier {
 public:
     /// Constructor from a shared secret
@@ -62,7 +62,7 @@ using VerifierHs512 = HmacShaVerifier<DigestSize::k512>;
 /// @}
 
 /// Generic verifier for asymmetric cryptography
-template <DsaType type, DigestSize bits>
+template <DsaType Type, DigestSize Bits>
 class DsaVerifier final : public Verifier {
 public:
     /// Constructor from public key
diff --git a/universal/include/userver/decimal64/decimal64.hpp b/universal/include/userver/decimal64/decimal64.hpp
index ede553f47c78..1c7ba266108b 100644
--- a/universal/include/userver/decimal64/decimal64.hpp
+++ b/universal/include/userver/decimal64/decimal64.hpp
@@ -411,7 +411,7 @@ class RoundUpRoundPolicy final {
 ///
 /// Decimal should be serialized and stored as a string, NOT as `double`. Use
 /// `Decimal{str}` constructor (or `Decimal::FromStringPermissive` if rounding
-/// is allowed) to read a `Decimal`, and `ToString(dec)`
+/// and exponential format are allowed) to read a `Decimal`, and `ToString(dec)`
 /// (or `ToStringTrailingZeros(dec)`/`ToStringFixed<N>(dec)`) to write a
 /// `Decimal`.
 ///
@@ -433,14 +433,14 @@ class RoundUpRoundPolicy final {
 /// }
 /// return ToString(sum);
 /// @endcode
-template <int Prec, typename RoundPolicy_ = DefRoundPolicy>
+template <int Prec, typename TRoundPolicy = DefRoundPolicy>
 class Decimal {
 public:
     /// The number of fractional digits
     static constexpr int kDecimalPoints = Prec;
 
     /// Specifies how to round in lossy operations
-    using RoundPolicy = RoundPolicy_;
+    using RoundPolicy = TRoundPolicy;
 
     /// The denominator of the decimal fraction
     static constexpr int64_t kDecimalFactor = kPow10<Prec>;
@@ -461,6 +461,8 @@ class Decimal {
     /// No extra characters, including spaces, are allowed. Extra leading
     /// and trailing zeros (within `Prec`) are discarded. Input containing more
     /// fractional digits that `Prec` is not allowed (no implicit rounding).
+    /// Exponential format (e.g., "1.23e4", "5E-2") is not supported by this
+    /// constructor.
     ///
     /// @throw decimal64::ParseError on invalid input
     /// @see FromStringPermissive
@@ -494,6 +496,7 @@ class Decimal {
     /// - rounding (as per `RoundPolicy`), e.g. "12.3456789" with `Prec == 2`
     /// - space characters, e.g. " \t42  \n"
     /// - leading and trailing dot, e.g. "5." and ".5"
+    /// - exponential format, e.g. "1.23e4" -> 12300, "5E-2" -> 0.05
     ///
     /// @throw decimal64::ParseError on invalid input
     /// @see Decimal(std::string_view)
@@ -778,7 +781,7 @@ class Decimal {
     friend class Decimal;
 
     template <typename T, int OldPrec, typename OldRound>
-    friend constexpr T decimal_cast(Decimal<OldPrec, OldRound> arg);
+    friend constexpr T decimal_cast(Decimal<OldPrec, OldRound> arg);  // NOLINT(readability-identifier-naming)
 
     int64_t value_{0};
 };
@@ -811,7 +814,7 @@ inline constexpr bool kIsDecimal = impl::IsDecimal<T>::value;
 /// auto discount = decimal64::decimal_cast<Discount>(cost) * Discount{"0.05"};
 /// @endcode
 template <typename T, int OldPrec, typename OldRound>
-constexpr T decimal_cast(Decimal<OldPrec, OldRound> arg) {
+constexpr T decimal_cast(Decimal<OldPrec, OldRound> arg) {  // NOLINT(readability-identifier-naming)
     static_assert(kIsDecimal<T>);
     return T::FromDecimal(arg);
 }
@@ -857,6 +860,64 @@ constexpr Decimal<Prec, RoundPolicy> FromUnpacked(int64_t before, int64_t after,
     }
 }
 
+template <int Prec, typename RoundPolicy>
+constexpr Decimal<Prec, RoundPolicy> FromUnpackedWithExponent(
+    int64_t before,
+    int64_t after,
+    int original_precision,
+    int exponent,
+    bool is_negative_exponent,
+    int leading_zeros
+) {
+    UASSERT(((before >= 0) && (after >= 0)) || ((before <= 0) && (after <= 0)));
+    UASSERT(after > -Pow10(original_precision) && after < Pow10(original_precision));
+
+    if (before == 0 && after == 0) {
+        return Decimal<Prec, RoundPolicy>::FromUnbiased(0);
+    }
+
+    const int effective_exponent = is_negative_exponent ? -exponent : exponent;
+
+    if (effective_exponent + Prec < -kMaxDecimalDigits) {
+        return Decimal<Prec, RoundPolicy>::FromUnbiased(0);
+    }
+
+    int total_scale = effective_exponent + Prec - original_precision;
+
+    if (before == 0 && after != 0) {
+        if (!is_negative_exponent) {
+            if (exponent >= leading_zeros) {
+                exponent -= leading_zeros;
+                original_precision -= leading_zeros;
+            } else {
+                original_precision -= exponent;
+                exponent = 0;
+            }
+        }
+    }
+
+    int64_t value = before;
+
+    if (__builtin_mul_overflow(value, Pow10(original_precision), &value) ||
+        __builtin_add_overflow(value, after, &value)) {
+        throw OutOfBoundsError();
+    }
+
+    if (total_scale > 0) {
+        if (total_scale > kMaxDecimalDigits) {
+            throw OutOfBoundsError();
+        }
+        if (__builtin_mul_overflow(value, Pow10(total_scale), &value)) {
+            throw OutOfBoundsError();
+        }
+    } else if (total_scale < 0) {
+        const int64_t divisor = Pow10(-total_scale);
+        value = Div<RoundPolicy>(value, divisor);
+    }
+
+    return Decimal<Prec, RoundPolicy>::FromUnbiased(value);
+}
+
 struct UnpackedDecimal {
     int64_t before;
     int64_t after;
@@ -954,7 +1015,11 @@ enum class ParseOptions {
 
     /// Allow decimal digits beyond Prec, round according to RoundPolicy
     /// "0.123456" -> "0.1234" or "0.1235"
-    kAllowRounding = 1 << 3
+    kAllowRounding = 1 << 3,
+
+    /// Allow using exponential format (e or E)
+    /// 1e2 -> 100 or 1E2 -> 100
+    kAllowExponent = 1 << 4
 };
 
 enum class ParseErrorCode : uint8_t {
@@ -979,6 +1044,13 @@ enum class ParseErrorCode : uint8_t {
     /// When there are more decimal digits than in any Decimal and rounding is
     /// disallowed by options
     kRounding,
+
+    /// On inputs like "1e2" or "1E2" if exponent is not allowed by options
+    kExponentNotAllowed,
+
+    /// When there are no numbers after the exponent character (or after exponent sign if it exist)
+    /// On inputs like "1e" or "1E+" or "1e-"
+    kNoExponentDigits
 };
 
 struct ParseUnpackedResult {
@@ -986,8 +1058,11 @@ struct ParseUnpackedResult {
     int64_t after{0};
     uint8_t decimal_digits{0};
     bool is_negative{false};
+    uint8_t exponent{0};
+    bool is_negative_exponent{false};
     std::optional<ParseErrorCode> error;
     uint32_t error_position{-1U};
+    int zeros_after_dec{0};
 };
 
 enum class ParseState {
@@ -1006,13 +1081,33 @@ enum class ParseState {
     /// Reading fractional digits
     kAfterDec,
 
+    /// Only zeros (at least one) have been met after dot
+    kZerosAfterDec,
+
     /// Reading and rounding extra fractional digits
     kIgnoringAfterDec,
 
+    /// Exponent sign
+    kExpSign,
+
+    // First digit after sign
+    kExpFirstDigit,
+
+    /// Exponent digits
+    kExpDigits,
+
     /// A character unrelated to the Decimal has been met
     kEnd
 };
 
+constexpr inline void
+StateToExpSign(std::optional<ParseErrorCode>& error, ParseState& state, utils::Flags<ParseOptions>& options) {
+    if (!error && !(options & ParseOptions::kAllowExponent)) {
+        error = ParseErrorCode::kExponentNotAllowed;
+    }
+    state = ParseState::kExpSign;
+}
+
 /// Extract values from a CharSequence ready to be packed to Decimal
 template <typename CharSequence>
 [[nodiscard]] constexpr ParseUnpackedResult ParseUnpacked(CharSequence input, utils::Flags<ParseOptions> options) {
@@ -1027,6 +1122,9 @@ template <typename CharSequence>
     std::optional<ParseErrorCode> error;
     int before_digit_count = 0;
     uint8_t after_digit_count = 0;
+    bool is_negative_exp = false;
+    uint8_t exponent = 0;
+    int zeros_after_dec = 0;
 
     while (state != ParseState::kEnd) {
         const auto c = input.Get();
@@ -1051,7 +1149,7 @@ template <typename CharSequence>
                     if (!(options & ParseOptions::kAllowBoundaryDot) && !error) {
                         error = ParseErrorCode::kBoundaryDot;  // keep reading digits
                     }
-                    state = ParseState::kAfterDec;
+                    state = ParseState::kZerosAfterDec;
                 } else if (IsSpace(c)) {
                     if (!(options & ParseOptions::kAllowSpaces)) {
                         state = ParseState::kEnd;
@@ -1087,7 +1185,9 @@ template <typename CharSequence>
                     state = ParseState::kBeforeDec;
                     before = static_cast<int>(c - '0');
                 } else if (c == dec_point) {
-                    state = ParseState::kAfterDec;
+                    state = ParseState::kZerosAfterDec;
+                } else if (c == 'e' || c == 'E') {
+                    StateToExpSign(/*error*/ error, /*state*/ state, /*options*/ options);
                 } else {
                     state = ParseState::kEnd;
                 }
@@ -1101,12 +1201,24 @@ template <typename CharSequence>
                         error = ParseErrorCode::kOverflow;  // keep reading digits
                     }
                 } else if (c == dec_point) {
-                    state = ParseState::kAfterDec;
+                    state = ParseState::kZerosAfterDec;
+                } else if (c == 'e' || c == 'E') {
+                    StateToExpSign(/*error*/ error, /*state*/ state, /*options*/ options);
                 } else {
                     state = ParseState::kEnd;
                 }
                 break;
+
+            case ParseState::kZerosAfterDec:
+                if (c == '0') {
+                    zeros_after_dec++;
+                    after_digit_count++;
+                    break;
+                }
+                [[fallthrough]];
+
             case ParseState::kAfterDec:
+                state = ParseState::kAfterDec;
                 if ((c >= '0') && (c <= '9')) {
                     if (after_digit_count < kMaxDecimalDigits) {
                         after = 10 * after + static_cast<int>(c - '0');
@@ -1121,6 +1233,9 @@ template <typename CharSequence>
                             after++;
                         }
                     }
+
+                } else if (c == 'e' || c == 'E') {
+                    StateToExpSign(/*error*/ error, /*state*/ state, /*options*/ options);
                 } else {
                     if (!(options & ParseOptions::kAllowBoundaryDot) && after_digit_count == 0 && !error) {
                         error = ParseErrorCode::kBoundaryDot;
@@ -1128,13 +1243,61 @@ template <typename CharSequence>
                     state = ParseState::kEnd;
                 }
                 break;
+
             case ParseState::kIgnoringAfterDec:
                 if ((c >= '0') && (c <= '9')) {
                     // skip
+                } else if (c == 'e' || c == 'E') {
+                    StateToExpSign(/*error*/ error, /*state*/ state, /*options*/ options);
+                } else {
+                    state = ParseState::kEnd;
+                }
+                break;
+
+            case ParseState::kExpSign:
+                if (c == '+') {
+                    is_negative_exp = false;
+                    state = ParseState::kExpFirstDigit;
+                } else if (c == '-') {
+                    is_negative_exp = true;
+                    state = ParseState::kExpFirstDigit;
+                } else if (c >= '0' && c <= '9') {
+                    exponent = static_cast<int>(c - '0');
+                    state = ParseState::kExpDigits;
+                } else {
+                    if (!error) {
+                        error = ParseErrorCode::kWrongChar;
+                    }
+                    state = ParseState::kEnd;
+                }
+                break;
+
+            case ParseState::kExpFirstDigit:
+                if (c >= '0' && c <= '9') {
+                    exponent = static_cast<int>(c - '0');
+                    state = ParseState::kExpDigits;
+                } else {
+                    state = ParseState::kEnd;
+                    if (!error) error = ParseErrorCode::kWrongChar;
+                }
+                break;
+
+            case ParseState::kExpDigits:
+                if (c >= '0' && c <= '9') {
+                    if ((__builtin_mul_overflow(10, exponent, &exponent) ||
+                         __builtin_add_overflow(static_cast<int>(c - '0'), exponent, &exponent))) {
+                        if (is_negative_exp && !(options & ParseOptions::kAllowRounding) && !error) {
+                            error = ParseErrorCode::kRounding;  // keep reading digits
+                        }
+                        if (!is_negative_exp && !error) {
+                            error = ParseErrorCode::kOverflow;  // keep reading digits
+                        }
+                    }
                 } else {
                     state = ParseState::kEnd;
                 }
                 break;
+
             case ParseState::kEnd:
                 UASSERT(false);
                 break;
@@ -1167,12 +1330,33 @@ template <typename CharSequence>
         error = ParseErrorCode::kNoDigits;
     }
 
-    if (!error && state == ParseState::kAfterDec && !(options & ParseOptions::kAllowBoundaryDot) &&
+    if (!error && state == ParseState::kZerosAfterDec && !(options & ParseOptions::kAllowBoundaryDot) &&
         after_digit_count == 0) {
         error = ParseErrorCode::kBoundaryDot;
     }
 
-    return {before, after, after_digit_count, is_negative, error, static_cast<uint32_t>(position)};
+    if ((!error && state == ParseState::kExpSign) || (!error && state == ParseState::kExpFirstDigit)) {
+        error = ParseErrorCode::kNoExponentDigits;
+    }
+
+    if (zeros_after_dec >= kMaxDecimalDigits) {
+        after_digit_count = 0;
+        after = 0;
+        zeros_after_dec = 0;
+    }
+
+    return {
+        before,
+        after,
+        after_digit_count,
+        is_negative,
+        exponent,
+        is_negative_exp,
+        error,
+        static_cast<uint32_t>(position),
+        zeros_after_dec,
+
+    };
 }
 
 template <int Prec, typename RoundPolicy>
@@ -1191,12 +1375,18 @@ template <int Prec, typename RoundPolicy, typename CharSequence>
         return {{}, parsed.error, parsed.error_position};
     }
 
+    if (!(options & ParseOptions::kAllowRounding) && parsed.decimal_digits > Prec) {
+        return {{}, ParseErrorCode::kRounding, 0};
+    }
+
     if (parsed.before >= kMaxInt64 / kPow10<Prec>) {
         return {{}, ParseErrorCode::kOverflow, 0};
     }
 
-    if (!(options & ParseOptions::kAllowRounding) && parsed.decimal_digits > Prec) {
-        return {{}, ParseErrorCode::kRounding, 0};
+    if (parsed.after == 0 && parsed.decimal_digits > 0) {
+        parsed.after = 0;
+        parsed.decimal_digits = 0;
+        parsed.zeros_after_dec = 0;
     }
 
     if (parsed.is_negative) {
@@ -1204,6 +1394,21 @@ template <int Prec, typename RoundPolicy, typename CharSequence>
         parsed.after = -parsed.after;
     }
 
+    if (parsed.exponent != 0) {
+        return {
+            FromUnpackedWithExponent<Prec, RoundPolicy>(
+                parsed.before,
+                parsed.after,
+                parsed.decimal_digits,
+                parsed.exponent,
+                parsed.is_negative_exponent,
+                parsed.zeros_after_dec
+            ),
+            {},
+            0,
+        };
+    }
+
     return {FromUnpacked<Prec, RoundPolicy>(parsed.before, parsed.after, parsed.decimal_digits), {}, 0};
 }
 
@@ -1231,7 +1436,10 @@ template <int Prec, typename RoundPolicy>
 constexpr Decimal<Prec, RoundPolicy> Decimal<Prec, RoundPolicy>::FromStringPermissive(std::string_view input) {
     const auto result = impl::Parse<Prec, RoundPolicy>(
         impl::StringCharSequence(input),
-        {impl::ParseOptions::kAllowSpaces, impl::ParseOptions::kAllowBoundaryDot, impl::ParseOptions::kAllowRounding}
+        {impl::ParseOptions::kAllowSpaces,
+         impl::ParseOptions::kAllowBoundaryDot,
+         impl::ParseOptions::kAllowRounding,
+         impl::ParseOptions::kAllowExponent}
     );
 
     if (result.error) {
@@ -1303,7 +1511,8 @@ std::string ToStringFixed(Decimal<Prec, RoundPolicy> dec) {
 /// @brief Parses a `Decimal` from the `istream`
 ///
 /// Acts like the `Decimal(str)` constructor, except that it allows junk that
-/// immediately follows the number. Sets the stream's fail bit on failure.
+/// immediately follows the number and supports exponential format.
+/// Sets the stream's fail bit on failure.
 ///
 /// Usage example:
 ///
@@ -1319,8 +1528,9 @@ std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>&
     if (is.flags() & std::ios_base::skipws) {
         std::ws(is);
     }
-    const auto result =
-        impl::Parse<Prec, RoundPolicy>(impl::StreamCharSequence(is), {impl::ParseOptions::kAllowTrailingJunk});
+    const auto result = impl::Parse<Prec, RoundPolicy>(
+        impl::StreamCharSequence(is), {impl::ParseOptions::kAllowTrailingJunk, impl::ParseOptions::kAllowExponent}
+    );
 
     if (result.error) {
         is.setstate(std::ios_base::failbit);
diff --git a/universal/include/userver/formats/common/conversion_stack.hpp b/universal/include/userver/formats/common/conversion_stack.hpp
index d99c1572843d..c1a3da8bd8dc 100644
--- a/universal/include/userver/formats/common/conversion_stack.hpp
+++ b/universal/include/userver/formats/common/conversion_stack.hpp
@@ -10,7 +10,8 @@
 #include <utility>
 
 #include <fmt/format.h>
-#include <boost/container/small_vector.hpp>
+#include <boost/container/deque.hpp>
+#include <boost/container/options.hpp>
 
 #include <userver/compiler/demangle.hpp>
 #include <userver/formats/common/type.hpp>
@@ -140,7 +141,11 @@ class ConversionStack final {
         bool is_parsed{false};
     };
 
-    boost::container::small_vector<StackFrame, 10> stack_;
+    // The container must have stable references. For example, YamlConfig::const_iterator stores a pointer
+    // to the YamlConfig node that is being iterated over. If a stack frame moves, then the next frame's
+    // `current_parsing_elem` will be invalidated. Updating iterators in such cases would be complex and expensive.
+    boost::container::deque<StackFrame, void, boost::container::deque_options<boost::container::block_size<16>>::type>
+        stack_;
 };
 
 /// @brief Performs the conversion between different formats. Only supports
diff --git a/universal/include/userver/formats/common/meta.hpp b/universal/include/userver/formats/common/meta.hpp
index e0388a632c37..36ef82b861f8 100644
--- a/universal/include/userver/formats/common/meta.hpp
+++ b/universal/include/userver/formats/common/meta.hpp
@@ -34,20 +34,20 @@ template <typename Value>
 using IsFormatValue = typename Value::ParseException;
 
 template <class Value, class T>
-constexpr inline bool kHasParse = meta::kIsDetected<HasParse, Value, T>;
+constexpr inline bool kHasParse = meta::IsDetected<HasParse, Value, T>;
 
 template <class Value, class T>
-constexpr inline bool kHasSerialize = meta::kIsDetected<HasSerialize, Value, T>;
+constexpr inline bool kHasSerialize = meta::IsDetected<HasSerialize, Value, T>;
 
 template <class Value, class T>
-constexpr inline bool kHasConvert = meta::kIsDetected<HasConvert, Value, T>;
+constexpr inline bool kHasConvert = meta::IsDetected<HasConvert, Value, T>;
 
 }  // namespace impl
 
 /// Used in `Parse` overloads that are templated on `Value`, avoids clashing
 /// with `Parse` from string
 template <class Value>
-constexpr inline bool kIsFormatValue = meta::kIsDetected<impl::IsFormatValue, Value>;
+constexpr inline bool kIsFormatValue = meta::IsDetected<impl::IsFormatValue, Value>;
 
 // Unwraps a transient type - tag types, for which ADL-found `Parse` returns
 // another type, not the type specified in `formats::parse::To`. For example,
diff --git a/universal/include/userver/formats/parse/common_containers.hpp b/universal/include/userver/formats/parse/common_containers.hpp
index 721d3790c932..8620b0c5aad6 100644
--- a/universal/include/userver/formats/parse/common_containers.hpp
+++ b/universal/include/userver/formats/parse/common_containers.hpp
@@ -38,7 +38,7 @@ inline T ConvertToExtractor(const Value& value) {
 }
 
 template <typename ArrayType, class Value, typename ExtractFunc>
-ArrayType ParseArray(const Value& value, ExtractFunc&& extract_func) {
+ArrayType ParseArray(const Value& value, ExtractFunc extract_func) {
     value.CheckArrayOrNull();
     ArrayType response;
     auto inserter = std::inserter(response, response.end());
@@ -52,12 +52,18 @@ ArrayType ParseArray(const Value& value, ExtractFunc&& extract_func) {
 }
 
 template <typename ObjectType, class Value, typename ExtractFunc>
-ObjectType ParseObject(const Value& value, ExtractFunc&& extract_func) {
+ObjectType ParseObject(const Value& value, ExtractFunc extract_func) {
+    using KeyType = typename ObjectType::key_type;
+
     value.CheckObjectOrNull();
     ObjectType result;
 
     for (auto it = value.begin(); it != value.end(); ++it) {
-        result.emplace(it.GetName(), extract_func(*it));
+        if constexpr (std::is_constructible_v<KeyType, std::string>) {
+            result.emplace(it.GetName(), extract_func(*it));
+        } else {
+            result.emplace(Parse(std::string_view(it.GetName()), To<KeyType>{}), extract_func(*it));
+        }
     }
 
     return result;
diff --git a/universal/include/userver/formats/parse/variant.hpp b/universal/include/userver/formats/parse/variant.hpp
index 597746778676..7b718798366f 100644
--- a/universal/include/userver/formats/parse/variant.hpp
+++ b/universal/include/userver/formats/parse/variant.hpp
@@ -65,7 +65,8 @@ void ParseVariantSingle(const Value& value, std::optional<Result>& result) {
 }  // namespace impl
 
 template <class Value, typename... Types>
-auto Parse(const Value& value, formats::parse::To<std::variant<Types...>>) {
+std::variant<decltype(Parse(std::declval<Value>(), To<Types>{}))...>
+Parse(const Value& value, formats::parse::To<std::variant<Types...>>) {
     std::optional<std::variant<decltype(Parse(std::declval<Value>(), To<Types>{}))...>> result;
 
     if constexpr (std::is_same_v<Value, formats::json::Value>) {
diff --git a/universal/include/userver/formats/yaml/iterator.hpp b/universal/include/userver/formats/yaml/iterator.hpp
index 129f4d33d719..0477cb7bceca 100644
--- a/universal/include/userver/formats/yaml/iterator.hpp
+++ b/universal/include/userver/formats/yaml/iterator.hpp
@@ -15,16 +15,16 @@ USERVER_NAMESPACE_BEGIN
 namespace formats::yaml {
 
 /// @brief Iterator for `formats::yaml::Value`
-template <typename iter_traits>
+template <typename IterTraits>
 class Iterator final {
 public:
     using iterator_category = std::forward_iterator_tag;
     using difference_type = std::ptrdiff_t;
-    using value_type = typename iter_traits::value_type;
-    using reference = typename iter_traits::reference;
-    using pointer = typename iter_traits::pointer;
+    using value_type = typename IterTraits::value_type;
+    using reference = typename IterTraits::reference;
+    using pointer = typename IterTraits::pointer;
 
-    Iterator(const typename iter_traits::native_iter& iter, int index, const formats::yaml::Path& path);
+    Iterator(const typename IterTraits::native_iter& iter, int index, const formats::yaml::Path& path);
     Iterator(const Iterator& other);
     Iterator(Iterator&& other) noexcept;
     Iterator& operator=(const Iterator& other);
@@ -54,7 +54,7 @@ class Iterator final {
 
     static constexpr std::size_t kNativeIterSize = 48;
     static constexpr std::size_t kNativeIterAlignment = alignof(void*);
-    utils::FastPimpl<typename iter_traits::native_iter, kNativeIterSize, kNativeIterAlignment> iter_pimpl_;
+    utils::FastPimpl<typename IterTraits::native_iter, kNativeIterSize, kNativeIterAlignment> iter_pimpl_;
     formats::yaml::Path path_;
     // Temporary object replaced on every value access.
     mutable int index_;
diff --git a/universal/include/userver/formats/yaml/types.hpp b/universal/include/userver/formats/yaml/types.hpp
index ac2f6087e861..ba50563771c1 100644
--- a/universal/include/userver/formats/yaml/types.hpp
+++ b/universal/include/userver/formats/yaml/types.hpp
@@ -10,7 +10,7 @@
 #include <userver/formats/common/type.hpp>
 
 // Forward declarations
-namespace YAML {
+namespace YAML {  // NOLINT(readability-identifier-naming)
 class Node;
 namespace detail {
 struct iterator_value;
diff --git a/universal/include/userver/http/predefined_header.hpp b/universal/include/userver/http/predefined_header.hpp
index 60202671ff5c..0c29311c0d55 100644
--- a/universal/include/userver/http/predefined_header.hpp
+++ b/universal/include/userver/http/predefined_header.hpp
@@ -168,25 +168,25 @@ class Map;
 class PredefinedHeader final {
 public:
     explicit constexpr PredefinedHeader(utils::StringLiteral name)
-        : name{name}, hash{impl::UnsafeConstexprHasher{}(name)}, header_index{impl::GetHeaderIndexForLookup(name)} {}
+        : name_{name}, hash_{impl::UnsafeConstexprHasher{}(name)}, header_index_{impl::GetHeaderIndexForLookup(name)} {}
 
-    constexpr operator utils::StringLiteral() const { return name; }
+    constexpr operator utils::StringLiteral() const { return name_; }
 
-    constexpr operator utils::zstring_view() const { return name; }
+    constexpr operator utils::zstring_view() const { return name_; }
 
-    constexpr operator std::string_view() const { return name; }
+    constexpr operator std::string_view() const { return name_; }
 
-    explicit operator std::string() const { return std::string{name}; }
+    explicit operator std::string() const { return std::string{name_}; }
 
 private:
     friend class header_map::Danger;
     friend class header_map::Map;
 
     // Header name.
-    const utils::StringLiteral name;
+    const utils::StringLiteral name_;
 
     // Unsafe constexpr hash (unsafe in a hash-flood sense).
-    const std::size_t hash;
+    const std::size_t hash_;
 
     // We assign a different 'index' value to every known header,
     // which allows us to do not perform case-insensitive names compare if indexes
@@ -194,7 +194,7 @@ class PredefinedHeader final {
     // With this trick a successful lookup for PredefinedHeader in HeaderMap
     // is basically "access an array by index and compare both hash and index".
     // You can think of this field as an enum discriminant.
-    const std::int8_t header_index;
+    const std::int8_t header_index_;
 };
 
 }  // namespace http::headers
diff --git a/universal/include/userver/http/url.hpp b/universal/include/userver/http/url.hpp
index e8ce32af00da..90be52659bab 100644
--- a/universal/include/userver/http/url.hpp
+++ b/universal/include/userver/http/url.hpp
@@ -9,6 +9,7 @@
 #include <string>
 #include <string_view>
 #include <unordered_map>
+#include <vector>
 
 #include <userver/utils/impl/internal_tag_fwd.hpp>
 #include <userver/utils/str_icase.hpp>
@@ -121,6 +122,13 @@ std::string MakeUrl(std::string_view path, const Args& query_args, MultiArgs que
 std::string
 MakeUrl(std::string_view path, std::initializer_list<std::pair<std::string_view, std::string_view>> query_args);
 
+/// @brief Make an URL with query arguments
+/// @param path Base URL path
+/// @param query_args vector of query parameters as key-value pairs
+/// @returns Complete URL with query string
+std::string
+MakeUrl(std::string_view path, const std::vector<std::pair<std::string_view, std::string_view>>& query_args);
+
 /// @brief Make a path from a template and arguments
 /// @param path Template string with placeholders in format {name}
 /// @param path_args Map of placeholder names to their values
diff --git a/universal/include/userver/logging/impl/log_extra_tskv_formatter.hpp b/universal/include/userver/logging/impl/log_extra_tskv_formatter.hpp
new file mode 100644
index 000000000000..773b3da2eb79
--- /dev/null
+++ b/universal/include/userver/logging/impl/log_extra_tskv_formatter.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string_view>
+
+#include <userver/logging/format.hpp>
+#include <userver/logging/impl/formatters/base.hpp>
+#include <userver/logging/impl/logger_base.hpp>
+#include <userver/logging/log_extra.hpp>
+#include <userver/utils/box.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace logging::impl {
+
+namespace formatters {
+class Tskv;
+}  // namespace formatters
+
+using TskvPtr = utils::Box<formatters::Tskv>;
+
+class LogExtraTskvFormatter final {
+public:
+    explicit LogExtraTskvFormatter(logging::Format format);
+
+    LogExtraTskvFormatter(LogExtraTskvFormatter&&) noexcept;
+
+    LogExtraTskvFormatter& operator=(LogExtraTskvFormatter&&) noexcept;
+
+    ~LogExtraTskvFormatter();
+
+    void Append(const LogExtra& log_extra);
+
+    // Returns log line
+    TextLogItem& GetTextLogItem();
+
+    // Finishes log line and returns it
+    TextLogItem& ExtractTextLogItem();
+
+private:
+    TskvPtr formatter_;
+};
+
+}  // namespace logging::impl
+
+USERVER_NAMESPACE_END
diff --git a/universal/include/userver/logging/log_extra.hpp b/universal/include/userver/logging/log_extra.hpp
index 8675d0a541c8..0d8a14e8d5fc 100644
--- a/universal/include/userver/logging/log_extra.hpp
+++ b/universal/include/userver/logging/log_extra.hpp
@@ -31,6 +31,7 @@ class LogHelper;
 
 namespace impl {
 class TagWriter;
+class LogExtraTskvFormatter;
 }  // namespace impl
 
 /// Extra tskv fields storage
@@ -120,6 +121,7 @@ class LogExtra final {
     void SetFrozen(const std::string& key);
 
     friend class LogHelper;
+    friend class impl::LogExtraTskvFormatter;
     friend class impl::TagWriter;
     friend class tracing::Span;
     friend class tracing::TagScope;
diff --git a/universal/include/userver/logging/log_helper.hpp b/universal/include/userver/logging/log_helper.hpp
index f9bae2ef75a1..db8e9bbeee69 100644
--- a/universal/include/userver/logging/log_helper.hpp
+++ b/universal/include/userver/logging/log_helper.hpp
@@ -141,11 +141,7 @@ class LogHelper final {
             // may throw a non std::exception based exception
             PutRange(value);
         } else {
-            static_assert(
-                !sizeof(T),
-                "Please implement logging for your type: "
-                "logging::LogHelper& operator<<(logging::LogHelper& lh, const T& value)"
-            );
+            VFormat("{}", fmt::make_format_args(value));
         }
 
         return *this;
diff --git a/universal/include/userver/logging/stacktrace_cache.hpp b/universal/include/userver/logging/stacktrace_cache.hpp
index faad4e7d6f12..a6b1ca6d597e 100644
--- a/universal/include/userver/logging/stacktrace_cache.hpp
+++ b/universal/include/userver/logging/stacktrace_cache.hpp
@@ -11,7 +11,7 @@ namespace logging::stacktrace_cache {
 
 /// Get cached stacktrace
 /// @see GlobalEnableStacktrace
-std::string to_string(const boost::stacktrace::stacktrace& st);
+std::string to_string(const boost::stacktrace::stacktrace& st);  // NOLINT(readability-identifier-naming)
 
 /// Enable/disable stacktraces. If disabled, stacktrace_cache::to_string()
 /// returns with a const string.
diff --git a/universal/include/userver/utils/assert.hpp b/universal/include/userver/utils/assert.hpp
index 1f2839aabf3d..7402854e853d 100644
--- a/universal/include/userver/utils/assert.hpp
+++ b/universal/include/userver/utils/assert.hpp
@@ -14,6 +14,7 @@ namespace utils {
 
 namespace impl {
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 [[noreturn]] void UASSERT_failed(
     std::string_view expr,
     const char* file,
diff --git a/universal/include/userver/utils/encoding/hex.hpp b/universal/include/userver/utils/encoding/hex.hpp
index 7b353d91aa25..b0c519accecc 100644
--- a/universal/include/userver/utils/encoding/hex.hpp
+++ b/universal/include/userver/utils/encoding/hex.hpp
@@ -47,7 +47,7 @@ constexpr size_t FromHexUpperBound(size_t size) noexcept {
 void ToHex(std::string_view input, std::string& out) noexcept;
 
 /// @brief Converts input to hex and writes data to output @p out.
-/// @warning `out` must be pre-allocated to at least @ref LengthInHexForm bytes.
+/// @warning `out` must be pre-allocated to at least @ref utils::encoding::LengthInHexForm bytes.
 /// @param input bytes to convert
 /// @param out buffer to write data
 void ToHexBuffer(std::string_view input, utils::span<char> out) noexcept;
diff --git a/universal/include/userver/utils/enumerate.hpp b/universal/include/userver/utils/enumerate.hpp
index 33dd8c2403ef..b63e51b0b0d5 100644
--- a/universal/include/userver/utils/enumerate.hpp
+++ b/universal/include/userver/utils/enumerate.hpp
@@ -82,7 +82,7 @@ namespace utils {
 /// for (auto [pos, elem] : enumerate(someContainer)) {...}
 /// @endcode
 template <typename Container>
-constexpr auto enumerate(Container&& iterable) {
+constexpr auto enumerate(Container&& iterable) {  // NOLINT(readability-identifier-naming)
     return impl::ContainerWrapper<Container>{std::forward<Container>(iterable)};
 }
 
diff --git a/universal/include/userver/utils/expected.hpp b/universal/include/userver/utils/expected.hpp
index 96977e4ec4b2..827a50736f55 100644
--- a/universal/include/userver/utils/expected.hpp
+++ b/universal/include/userver/utils/expected.hpp
@@ -11,6 +11,8 @@ USERVER_NAMESPACE_BEGIN
 
 namespace utils {
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 class bad_expected_access : public std::exception {
 public:
     using std::exception::exception;
@@ -182,6 +184,8 @@ const E& expected<S, E>::error() const {
     return result->error();
 }
 
+// NOLINTEND(readability-identifier-naming)
+
 }  // namespace utils
 
 USERVER_NAMESPACE_END
diff --git a/universal/include/userver/utils/filter_bloom.hpp b/universal/include/userver/utils/filter_bloom.hpp
index d49e5e66abff..2d1f8b42516c 100644
--- a/universal/include/userver/utils/filter_bloom.hpp
+++ b/universal/include/userver/utils/filter_bloom.hpp
@@ -40,7 +40,7 @@ class FilterBloom final {
     /// @note If expected to increment n times is recommended to set counters_num
     /// to 16 * n
     explicit FilterBloom(std::size_t counters_num = 256, Hash1 hash_1 = Hash1{}, Hash2 hash_2 = Hash2{})
-        : counters_(counters_num, 0), hasher_1(std::move(hash_1)), hasher_2(std::move(hash_2)) {
+        : counters_(counters_num, 0), hasher_1_(std::move(hash_1)), hasher_2_(std::move(hash_2)) {
         UASSERT((!std::is_same_v<Hash1, Hash2>));
         UASSERT((std::is_same_v<std::invoke_result_t<Hash1, const T&>, std::invoke_result_t<Hash2, const T&>>));
     }
@@ -65,8 +65,8 @@ class FilterBloom final {
     Counter MinFrequency(const HashedType& hashed_value_1, const HashedType& hashed_value_2) const;
 
     utils::FixedArray<Counter> counters_;
-    const Hash1 hasher_1;
-    const Hash2 hasher_2;
+    const Hash1 hasher_1_;
+    const Hash2 hasher_2_;
 
     static constexpr std::size_t kHashFunctionsCount = 4;
 };
@@ -104,8 +104,8 @@ Counter FilterBloom<T, Counter, Hash1, Hash2>::MinFrequency(
 
 template <typename T, typename Counter, typename Hash1, typename Hash2>
 void FilterBloom<T, Counter, Hash1, Hash2>::Increment(const T& item) {
-    auto hash_value_1 = hasher_1(item);
-    auto hash_value_2 = hasher_2(item);
+    auto hash_value_1 = hasher_1_(item);
+    auto hash_value_2 = hasher_2_(item);
     Counter min_frequency = MinFrequency(hash_value_1, hash_value_2);
 
     for (std::size_t step = 0; step < kHashFunctionsCount; ++step) {
@@ -118,8 +118,8 @@ void FilterBloom<T, Counter, Hash1, Hash2>::Increment(const T& item) {
 
 template <typename T, typename Counter, typename Hash1, typename Hash2>
 Counter FilterBloom<T, Counter, Hash1, Hash2>::Estimate(const T& item) const {
-    auto hash_value_1 = hasher_1(item);
-    auto hash_value_2 = hasher_2(item);
+    auto hash_value_1 = hasher_1_(item);
+    auto hash_value_2 = hasher_2_(item);
     return MinFrequency(hash_value_1, hash_value_2);
 }
 
diff --git a/universal/include/userver/utils/from_string.hpp b/universal/include/userver/utils/from_string.hpp
index 2ca5df4dcc97..277d22112058 100644
--- a/universal/include/userver/utils/from_string.hpp
+++ b/universal/include/userver/utils/from_string.hpp
@@ -26,7 +26,7 @@ namespace utils {
 namespace impl {
 
 [[noreturn]] void
-ThrowFromStringException(std::string_view message, std::string_view input, std::type_index resultType);
+ThrowFromStringException(std::string_view message, std::string_view input, std::type_index result_type);
 
 template <typename T>
 std::enable_if_t<std::is_floating_point_v<T>, T> FromString(const char* str) {
diff --git a/universal/include/userver/utils/get_if.hpp b/universal/include/userver/utils/get_if.hpp
index 8c4aa128f4c1..5577ebec5dc5 100644
--- a/universal/include/userver/utils/get_if.hpp
+++ b/universal/include/userver/utils/get_if.hpp
@@ -20,7 +20,7 @@ template <typename T>
 using IsPointerLike = decltype(std::declval<T&>() ? std::addressof(*std::declval<T&&>()) : nullptr);
 
 template <typename T>
-inline constexpr bool kIsPointerLike = meta::kIsDetected<IsPointerLike, T>;
+inline constexpr bool kIsPointerLike = meta::IsDetected<IsPointerLike, T>;
 
 }  // namespace impl
 
diff --git a/universal/include/userver/utils/impl/projecting_view.hpp b/universal/include/userver/utils/impl/projecting_view.hpp
index d39f22fcb74c..266436412ef5 100644
--- a/universal/include/userver/utils/impl/projecting_view.hpp
+++ b/universal/include/userver/utils/impl/projecting_view.hpp
@@ -7,14 +7,14 @@ USERVER_NAMESPACE_BEGIN
 
 namespace utils::impl {
 
-struct first {
+struct First {
     template <class T>
     auto operator()(T& value) const noexcept -> decltype(value.first)& {
         return value.first;
     }
 };
 
-struct second {
+struct Second {
     template <class T>
     auto operator()(T& value) const noexcept -> decltype(value.second)& {
         return value.second;
@@ -101,14 +101,14 @@ class ProjectingView : private Projection {
 
 // A backport of std::ranges::views::keys.
 template <class Container>
-ProjectingView<const Container, impl::first> MakeKeysView(const Container& c) {
-    return ProjectingView<const Container, impl::first>{c};
+ProjectingView<const Container, impl::First> MakeKeysView(const Container& c) {
+    return ProjectingView<const Container, impl::First>{c};
 }
 
 // A backport of std::ranges::views::values.
 template <class Container>
-ProjectingView<Container, impl::second> MakeValuesView(Container& c) {
-    return ProjectingView<Container, impl::second>{c};
+ProjectingView<Container, impl::Second> MakeValuesView(Container& c) {
+    return ProjectingView<Container, impl::Second>{c};
 }
 
 }  // namespace utils::impl
diff --git a/universal/include/userver/utils/make_intrusive_ptr.hpp b/universal/include/userver/utils/make_intrusive_ptr.hpp
index b610cceff612..f136eb397be5 100644
--- a/universal/include/userver/utils/make_intrusive_ptr.hpp
+++ b/universal/include/userver/utils/make_intrusive_ptr.hpp
@@ -14,7 +14,7 @@ namespace utils {
 
 /// @brief Factory function for boost::intrusive_ptr, like std::make_unique
 template <class Target, class... Args>
-boost::intrusive_ptr<Target> make_intrusive_ptr(Args&&... args) {
+boost::intrusive_ptr<Target> make_intrusive_ptr(Args&&... args) {  // NOLINT(readability-identifier-naming)
     auto ret = std::make_unique<Target>(std::forward<Args>(args)...);
     return ret.release();
 }
diff --git a/universal/include/userver/utils/meta.hpp b/universal/include/userver/utils/meta.hpp
index 84bc7fd3403c..cefac2746522 100644
--- a/universal/include/userver/utils/meta.hpp
+++ b/universal/include/userver/utils/meta.hpp
@@ -32,7 +32,7 @@ using IsRange =
     ExpectSame<std::decay_t<decltype(begin(std::declval<T&>()))>, std::decay_t<decltype(end(std::declval<T&>()))>>;
 
 template <typename T>
-using IteratorType = std::enable_if_t<kIsDetected<IsRange, T>, decltype(begin(std::declval<T&>()))>;
+using IteratorType = std::enable_if_t<IsDetected<IsRange, T>, decltype(begin(std::declval<T&>()))>;
 
 template <typename T, typename = void>
 struct IsIterator : std::false_type {};
@@ -77,7 +77,7 @@ struct IsFixedSizeContainer<Array<T, Size>> : std::bool_constant<sizeof(Array<T,
 template <typename... Args>
 constexpr bool IsSingleRange() {
     if constexpr (sizeof...(Args) == 1) {
-        return kIsDetected<IsRange, Args...>;
+        return IsDetected<IsRange, Args...>;
     } else {
         return false;
     }
@@ -89,16 +89,16 @@ template <typename T>
 inline constexpr bool kIsVector = kIsInstantiationOf<std::vector, T>;
 
 template <typename T>
-inline constexpr bool kIsRange = kIsDetected<impl::IsRange, T>;
+inline constexpr bool kIsRange = IsDetected<impl::IsRange, T>;
 
 /// Returns true if T is an ordered or unordered map or multimap
 template <typename T>
 inline constexpr bool kIsMap =
-    kIsDetected<impl::IsRange, T> && kIsDetected<impl::KeyType, T> && kIsDetected<impl::MappedType, T>;
+    IsDetected<impl::IsRange, T> && IsDetected<impl::KeyType, T> && IsDetected<impl::MappedType, T>;
 
 /// Returns true if T is a map (but not a multimap!)
 template <typename T>
-inline constexpr bool kIsUniqueMap = kIsMap<T> && kIsDetected<
+inline constexpr bool kIsUniqueMap = kIsMap<T> && IsDetected<
                                                       impl::SubscriptOperatorResult,
                                                       T>;  // no operator[] in multimaps
 
@@ -132,15 +132,15 @@ inline constexpr bool kIsStdHashable =
 
 /// @brief  Check if std::size is applicable to container
 template <typename T>
-inline constexpr bool kIsSizable = kIsDetected<impl::IsSizable, T>;
+inline constexpr bool kIsSizable = IsDetected<impl::IsSizable, T>;
 
 /// @brief Check if a container has `reserve`
 template <typename T>
-inline constexpr bool kIsReservable = kIsDetected<impl::ReserveResult, T>;
+inline constexpr bool kIsReservable = IsDetected<impl::ReserveResult, T>;
 
 /// @brief Check if a container has 'push_back'
 template <typename T>
-inline constexpr bool kIsPushBackable = kIsDetected<impl::PushBackResult, T>;
+inline constexpr bool kIsPushBackable = IsDetected<impl::PushBackResult, T>;
 
 /// @brief Check if a container has fixed size (e.g. std::array)
 template <typename T>
diff --git a/universal/include/userver/utils/meta_light.hpp b/universal/include/userver/utils/meta_light.hpp
index 1c3fc86de0a2..5ed78126dd94 100644
--- a/universal/include/userver/utils/meta_light.hpp
+++ b/universal/include/userver/utils/meta_light.hpp
@@ -36,7 +36,7 @@ struct IsInstantiationOf<Template, Template<Args...>> : std::true_type {};
 
 }  // namespace impl
 
-/// @see utils::meta::kIsDetected
+/// @see utils::meta::IsDetected
 struct NotDetected {};
 
 #if defined(__cpp_concepts) || defined(DOXYGEN)
@@ -53,38 +53,42 @@ struct NotDetected {};
 /// template <typename T>
 /// using HasValueType = typename T::ValueType;
 /// ...
-/// if constexpr (utils::meta::kIsDetected<HasValueType, T>) { ... }
+/// if constexpr (utils::meta::IsDetected<HasValueType, T>) { ... }
 /// @endcode
 template <template <typename...> typename Trait, typename... Args>
-concept kIsDetected = requires { typename Trait<Args...>; };
+concept IsDetected = requires { typename Trait<Args...>; };
 
 #else
 
 template <template <typename...> typename Trait, typename... Args>
-inline constexpr bool kIsDetected = impl::Detector<NotDetected, void, Trait, Args...>::value_t::value;
+inline constexpr bool IsDetected = impl::Detector<NotDetected, void, Trait, Args...>::value_t::value;
 
 #endif
 
 /// @brief Produces the result type of a trait, or utils::meta::NotDetected if
 /// it's incorrect for the given template args
-/// @see utils::meta::kIsDetected
+/// @see utils::meta::IsDetected
 template <template <typename...> typename Trait, typename... Args>
 using DetectedType = typename impl::Detector<NotDetected, void, Trait, Args...>::type;
 
 /// @brief Produces the result type of a trait, or @a Default if it's incorrect
 /// for the given template args
-/// @see utils::meta::kIsDetected
+/// @see utils::meta::IsDetected
 template <typename Default, template <typename...> typename Trait, typename... Args>
 using DetectedOr = typename impl::Detector<Default, void, Trait, Args...>::type;
 
-/// Helps in definitions of traits for utils::meta::kIsDetected
+/// Helps in definitions of traits for utils::meta::IsDetected
 template <typename T, typename U>
 using ExpectSame = std::enable_if_t<std::is_same_v<T, U>>;
 
-/// Returns `true` if the type if an instantiation of the specified template.
+/// Returns `true` if the type is an instantiation of the specified template.
 template <template <typename...> typename Template, typename T>
 inline constexpr bool kIsInstantiationOf = impl::IsInstantiationOf<Template, T>::value;
 
+/// Returns `true` if the type (with remove cv-qualifiers) is an instantiation of the specified template.
+template <template <typename...> typename Template, typename T>
+inline constexpr bool kIsCvInstantiationOf = kIsInstantiationOf<Template, std::remove_cv_t<T>>;
+
 /// Returns `true` if the type is a fundamental character type.
 /// `signed char` and `unsigned char` are not character types.
 template <typename T>
diff --git a/universal/include/userver/utils/numeric_cast.hpp b/universal/include/userver/utils/numeric_cast.hpp
index b8896d5eeac0..b6f613c2a865 100644
--- a/universal/include/userver/utils/numeric_cast.hpp
+++ b/universal/include/userver/utils/numeric_cast.hpp
@@ -28,7 +28,7 @@ using PrintableValue = std::conditional_t<(sizeof(T) > 1), T, int>;
 ///
 /// @snippet utils/numeric_cast_test.cpp  Sample utils::numeric_cast usage
 template <typename To, typename From>
-constexpr To numeric_cast(From input) {
+constexpr To numeric_cast(From input) {  // NOLINT(readability-identifier-naming)
     static_assert(std::is_integral_v<From>);
     static_assert(std::is_integral_v<To>);
     using FromLimits = std::numeric_limits<From>;
diff --git a/universal/include/userver/utils/projected_set.hpp b/universal/include/userver/utils/projected_set.hpp
index ca035a0c4ceb..082d63231c94 100644
--- a/universal/include/userver/utils/projected_set.hpp
+++ b/universal/include/userver/utils/projected_set.hpp
@@ -120,7 +120,7 @@ void ProjectedInsertOrAssign(Container& set, Value&& value) {
 /// @note Always returns const iterator, even for a non-const `set` parameter.
 template <typename Container, typename Key>
 auto ProjectedFind(Container& set, const Key& key) {
-    if constexpr (meta::kIsDetected<impl::projected_set::HasHasher, std::decay_t<Container>>) {
+    if constexpr (meta::IsDetected<impl::projected_set::HasHasher, std::decay_t<Container>>) {
         return utils::impl::FindTransparent(set, key);
     } else {
         return set.find(key);
diff --git a/universal/include/userver/utils/regex.hpp b/universal/include/userver/utils/regex.hpp
index c2de764926cc..ec3c23a71f6e 100644
--- a/universal/include/userver/utils/regex.hpp
+++ b/universal/include/userver/utils/regex.hpp
@@ -13,6 +13,8 @@ USERVER_NAMESPACE_BEGIN
 
 namespace utils {
 
+// NOLINTBEGIN(readability-identifier-naming)
+
 class match_results;
 struct Re2Replacement;
 
@@ -189,6 +191,8 @@ struct Re2Replacement final {
 /// @see utils::Re2Replacement
 std::string regex_replace(std::string_view str, const regex& pattern, Re2Replacement repl);
 
+// NOLINTEND(readability-identifier-naming)
+
 }  // namespace utils
 
 USERVER_NAMESPACE_END
diff --git a/universal/include/userver/utils/span.hpp b/universal/include/userver/utils/span.hpp
index 118b49249fd0..209fcb9e174f 100644
--- a/universal/include/userver/utils/span.hpp
+++ b/universal/include/userver/utils/span.hpp
@@ -27,7 +27,7 @@ using TypeIdentity = typename TypeIdentityImpl<T>::type;
 
 /// A polyfill for std::span from C++20
 template <typename T>
-class span final {
+class span final {  // NOLINT(readability-identifier-naming)
 public:
     using iterator = T*;
     using value_type = std::remove_cv_t<T>;
@@ -117,14 +117,14 @@ span(Container&& cont) -> span<std::remove_reference_t<decltype(*std::begin(cont
 
 /// A polyfill for std::as_bytes from C++20
 template <typename T>
-span<const std::byte> as_bytes(span<T> s) noexcept {
+span<const std::byte> as_bytes(span<T> s) noexcept {  // NOLINT(readability-identifier-naming)
     const auto* const data = reinterpret_cast<const std::byte*>(s.data());
     return {data, data + s.size() * sizeof(T)};
 }
 
 /// A polyfill for std::as_writable_bytes from C++20
 template <typename T, typename = std::enable_if_t<!std::is_const_v<T>>>
-span<std::byte> as_writable_bytes(span<T> s) noexcept {
+span<std::byte> as_writable_bytes(span<T> s) noexcept {  // NOLINT(readability-identifier-naming)
     auto* const data = reinterpret_cast<std::byte*>(s.data());
     return {data, data + s.size() * sizeof(T)};
 }
diff --git a/universal/include/userver/utils/strerror.hpp b/universal/include/userver/utils/strerror.hpp
index 17aa61907d07..87d9a79d645f 100644
--- a/universal/include/userver/utils/strerror.hpp
+++ b/universal/include/userver/utils/strerror.hpp
@@ -10,10 +10,10 @@ USERVER_NAMESPACE_BEGIN
 namespace utils {
 
 /// MT-safe version of POSIX function `::strerror`
-std::string strerror(int return_code);
+std::string strerror(int return_code);  // NOLINT(readability-identifier-naming)
 
 /// MT-safe version of POSIX function `::strsignal`
-std::string strsignal(int signal_num);
+std::string strsignal(int signal_num);  // NOLINT(readability-identifier-naming)
 
 }  // namespace utils
 
diff --git a/universal/include/userver/utils/strong_typedef.hpp b/universal/include/userver/utils/strong_typedef.hpp
index 04a75e849a64..eb8313c35ce3 100644
--- a/universal/include/userver/utils/strong_typedef.hpp
+++ b/universal/include/userver/utils/strong_typedef.hpp
@@ -17,6 +17,7 @@
 #include <userver/compiler/impl/three_way_comparison.hpp>
 #include <userver/formats/common/meta.hpp>
 #include <userver/utils/meta.hpp>
+#include <userver/utils/strong_typedef_fwd.hpp>
 #include <userver/utils/underlying_value.hpp>
 #include <userver/utils/void_t.hpp>
 
@@ -35,16 +36,6 @@ class LogHelper;  // Forward declaration
 
 namespace utils {
 
-enum class StrongTypedefOps {
-    kNoCompare = 0,  /// Forbid all comparisons for StrongTypedef
-
-    kCompareStrong = 1,           /// Allow comparing two StrongTypedef<Tag, T>
-    kCompareTransparentOnly = 2,  /// Allow comparing StrongTypedef<Tag, T> and T
-    kCompareTransparent = 3,      /// Allow both of the above
-
-    kNonLoggable = 4,  /// Forbid logging and serializing for StrongTypedef
-};
-
 constexpr bool operator&(StrongTypedefOps op, StrongTypedefOps mask) noexcept {
     return utils::UnderlyingValue(op) & utils::UnderlyingValue(mask);
 }
@@ -53,44 +44,6 @@ constexpr auto operator|(StrongTypedefOps op1, StrongTypedefOps op2) noexcept {
     return StrongTypedefOps{utils::UnderlyingValue(op1) | utils::UnderlyingValue(op2)};
 }
 
-/// @ingroup userver_universal userver_containers
-///
-/// @brief Strong typedef for a type T.
-///
-/// Typical usage:
-/// @code
-///   using MyString = utils::StrongTypedef<class MyStringTag, std::string>;
-/// @endcode
-///
-/// Or:
-/// @code
-///   struct MyString final : utils::StrongTypedef<MyString, std::string> {
-///     using StrongTypedef::StrongTypedef;
-///   };
-/// @endcode
-///
-/// Has all the:
-/// * comparison (see "Operators" below)
-/// * hashing
-/// * streaming operators
-/// * optimizaed logging for LOG_XXX()
-///
-/// If used with container-like type also has common STL functions:
-/// * begin()
-/// * end()
-/// * cbegin()
-/// * cend()
-/// * size()
-/// * empty()
-/// * clear()
-/// * operator[]
-///
-/// Operators:
-///   You can customize the operators that are available by passing the third
-///   argument of type StrongTypedefOps. See its docs for more info.
-template <class Tag, class T, StrongTypedefOps Ops = StrongTypedefOps::kCompareStrong, class /*Enable*/ = void>
-class StrongTypedef;  // Forward declaration
-
 // Helpers
 namespace impl::strong_typedef {
 
@@ -128,12 +81,6 @@ constexpr void CheckTransparentCompare() {
     );
 }
 
-struct StrongTypedefTag {};
-
-template <typename T>
-using IsStrongTypedef =
-    std::conjunction<std::is_base_of<StrongTypedefTag, T>, std::is_convertible<T&, StrongTypedefTag&>>;
-
 template <class T>
 const auto& UnwrapIfStrongTypedef(const T& value) {
     if constexpr (IsStrongTypedef<T>{}) {
@@ -180,8 +127,41 @@ constexpr bool IsStrongToStrongConversion() noexcept {
 
 }  // namespace impl::strong_typedef
 
-using impl::strong_typedef::IsStrongTypedef;
-
+/// @ingroup userver_universal userver_containers
+///
+/// @brief Strong typedef for a type T.
+///
+/// Typical usage:
+/// @code
+///   using MyString = utils::StrongTypedef<class MyStringTag, std::string>;
+/// @endcode
+///
+/// Or:
+/// @code
+///   struct MyString final : utils::StrongTypedef<MyString, std::string> {
+///     using StrongTypedef::StrongTypedef;
+///   };
+/// @endcode
+///
+/// Has all the:
+/// * comparison (see "Operators" below)
+/// * hashing
+/// * streaming operators
+/// * optimizaed logging for LOG_XXX()
+///
+/// If used with container-like type also has common STL functions:
+/// * begin()
+/// * end()
+/// * cbegin()
+/// * cend()
+/// * size()
+/// * empty()
+/// * clear()
+/// * operator[]
+///
+/// Operators:
+///   You can customize the operators that are available by passing the third
+///   argument of type StrongTypedefOps. See its docs for more info.
 template <class Tag, class T, StrongTypedefOps Ops, class /*Enable*/>
 class StrongTypedef : public impl::strong_typedef::StrongTypedefTag {
     static_assert(!std::is_reference<T>::value);
@@ -340,7 +320,7 @@ constexpr T UnderlyingValue(StrongTypedef<Tag, T, Ops>&& v) noexcept {
     return std::move(v).GetUnderlying();
 }
 
-constexpr bool IsStrongTypedefLoggable(StrongTypedefOps Ops) { return !(Ops & StrongTypedefOps::kNonLoggable); }
+constexpr bool IsStrongTypedefLoggable(StrongTypedefOps ops) { return !(ops & StrongTypedefOps::kNonLoggable); }
 
 // Serialization
 
@@ -408,7 +388,7 @@ constexpr Target StrongCast(StrongTypedef<Tag, T, Ops, Enable>&& src) {
 }
 
 template <class Tag, class T, StrongTypedefOps Ops>
-std::size_t hash_value(const StrongTypedef<Tag, T, Ops>& v) {
+std::size_t hash_value(const StrongTypedef<Tag, T, Ops>& v) {  // NOLINT(readability-identifier-naming)
     return boost::hash<T>{}(v.GetUnderlying());
 }
 
diff --git a/universal/include/userver/utils/strong_typedef_fwd.hpp b/universal/include/userver/utils/strong_typedef_fwd.hpp
new file mode 100644
index 000000000000..790b9312d9a3
--- /dev/null
+++ b/universal/include/userver/utils/strong_typedef_fwd.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <type_traits>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace utils {
+
+enum class StrongTypedefOps {
+    kNoCompare = 0,  /// Forbid all comparisons for StrongTypedef
+
+    kCompareStrong = 1,           /// Allow comparing two StrongTypedef<Tag, T>
+    kCompareTransparentOnly = 2,  /// Allow comparing StrongTypedef<Tag, T> and T
+    kCompareTransparent = 3,      /// Allow both of the above
+
+    kNonLoggable = 4,  /// Forbid logging and serializing for StrongTypedef
+};
+
+template <class Tag, class T, StrongTypedefOps Ops = StrongTypedefOps::kCompareStrong, class /*Enable*/ = void>
+class StrongTypedef;
+
+// Helpers
+namespace impl::strong_typedef {
+
+struct StrongTypedefTag {};
+
+template <typename T>
+using IsStrongTypedef =
+    std::conjunction<std::is_base_of<StrongTypedefTag, T>, std::is_convertible<T&, StrongTypedefTag&>>;
+
+}  // namespace impl::strong_typedef
+
+template <typename T>
+using IsStrongTypedef = impl::strong_typedef::IsStrongTypedef<T>;
+
+}  // namespace utils
+
+USERVER_NAMESPACE_END
diff --git a/universal/include/userver/utils/trivial_map.hpp b/universal/include/userver/utils/trivial_map.hpp
index 16a0c22681db..18fb0b26f05d 100644
--- a/universal/include/userver/utils/trivial_map.hpp
+++ b/universal/include/userver/utils/trivial_map.hpp
@@ -668,7 +668,7 @@ class TrivialBiMap final {
     using First = typename TypesPair::first_type;
     using Second = typename TypesPair::second_type;
 
-    struct value_type {
+    struct ValueType {
         First first;
         Second second;
     };
@@ -788,45 +788,45 @@ class TrivialBiMap final {
         }
     }
 
-    constexpr value_type GetValuesByIndex(std::size_t index) const {
+    constexpr ValueType GetValuesByIndex(std::size_t index) const {
         UASSERT_MSG(index < size(), "Index is out of bounds");
         auto result = func_([index]() { return impl::CaseGetValuesByIndex<First, Second>{index}; });
-        return value_type{result.GetFirst(), result.GetSecond()};
+        return ValueType{result.GetFirst(), result.GetSecond()};
     }
 
-    class iterator {
+    class Iterator {
     public:
         using iterator_category = std::input_iterator_tag;
         using difference_type = std::ptrdiff_t;
 
-        explicit constexpr iterator(const TrivialBiMap& map, std::size_t position) : map_{map}, position_{position} {}
+        explicit constexpr Iterator(const TrivialBiMap& map, std::size_t position) : map_{map}, position_{position} {}
 
-        constexpr bool operator==(iterator other) const { return position_ == other.position_; }
+        constexpr bool operator==(Iterator other) const { return position_ == other.position_; }
 
-        constexpr bool operator!=(iterator other) const { return position_ != other.position_; }
+        constexpr bool operator!=(Iterator other) const { return position_ != other.position_; }
 
-        constexpr iterator operator++() {
+        constexpr Iterator operator++() {
             ++position_;
             return *this;
         }
 
-        constexpr iterator operator++(int) {
-            iterator copy{*this};
+        constexpr Iterator operator++(int) {
+            Iterator copy{*this};
             ++position_;
             return copy;
         }
 
-        constexpr value_type operator*() const { return map_.GetValuesByIndex(position_); }
+        constexpr ValueType operator*() const { return map_.GetValuesByIndex(position_); }
 
     private:
         const TrivialBiMap& map_;
         std::size_t position_;
     };
 
-    constexpr iterator begin() const { return iterator(*this, 0); }
-    constexpr iterator end() const { return iterator(*this, size()); }
-    constexpr iterator cbegin() const { return begin(); }
-    constexpr iterator cend() const { return end(); }
+    constexpr Iterator begin() const { return Iterator(*this, 0); }
+    constexpr Iterator end() const { return Iterator(*this, size()); }
+    constexpr Iterator cbegin() const { return begin(); }
+    constexpr Iterator cend() const { return end(); }
 
 private:
     const BuilderFunc func_;
diff --git a/universal/include/userver/utils/void_t.hpp b/universal/include/userver/utils/void_t.hpp
index fc5578902b8f..c685a2a85485 100644
--- a/universal/include/userver/utils/void_t.hpp
+++ b/universal/include/userver/utils/void_t.hpp
@@ -18,7 +18,7 @@ using void_t = std::void_t<T...>;
 #else
 
 template <typename... T>
-struct make_void_t {
+struct make_void_t {  // NOLINT(readability-identifier-naming)
     using type = void;
 };
 template <typename... T>
diff --git a/universal/include/userver/utils/zstring_view.hpp b/universal/include/userver/utils/zstring_view.hpp
index cedf7420ae93..c6058bae4309 100644
--- a/universal/include/userver/utils/zstring_view.hpp
+++ b/universal/include/userver/utils/zstring_view.hpp
@@ -20,7 +20,7 @@ namespace utils {
 /// @ingroup userver_containers
 ///
 /// @brief Non-empty string view type that guarantees null-termination and has a `c_str()` member function.
-class zstring_view : public std::string_view {
+class zstring_view : public std::string_view {  // NOLINT(readability-identifier-naming)
 public:
     zstring_view() = delete;
     zstring_view(const zstring_view& str) = default;
@@ -65,7 +65,7 @@ namespace fmt {
 
 // Allow fmt::runtime() to work with utils::zstring_view
 template <class... NotUsed>
-inline auto runtime(USERVER_NAMESPACE::utils::zstring_view s, NotUsed...)
+inline auto runtime(USERVER_NAMESPACE::utils::zstring_view s, NotUsed...)  // NOLINT(readability-identifier-naming)
     -> decltype(fmt::runtime(std::string_view{s})) {
     static_assert(sizeof...(NotUsed) == 0);
     return fmt::runtime(std::string_view{s});
diff --git a/universal/include/userver/yaml_config/iterator.hpp b/universal/include/userver/yaml_config/iterator.hpp
index 34b26355af35..1d3a9caec74e 100644
--- a/universal/include/userver/yaml_config/iterator.hpp
+++ b/universal/include/userver/yaml_config/iterator.hpp
@@ -8,15 +8,15 @@ USERVER_NAMESPACE_BEGIN
 
 namespace yaml_config {
 
-template <typename iter_traits>
+template <typename IterTraits>
 class Iterator final {
 public:
     using YamlIterator = formats::yaml::Value::const_iterator;
     using iterator_category = std::forward_iterator_tag;
     using difference_type = std::ptrdiff_t;
-    using value_type = typename iter_traits::value_type;
-    using reference = typename iter_traits::reference;
-    using pointer = typename iter_traits::pointer;
+    using value_type = typename IterTraits::value_type;
+    using reference = typename IterTraits::reference;
+    using pointer = typename IterTraits::pointer;
 
     Iterator(const value_type& container, YamlIterator it) : container_(&container), it_(std::move(it)) {}
 
diff --git a/universal/include/userver/yaml_config/yaml_config.hpp b/universal/include/userver/yaml_config/yaml_config.hpp
index b429cadee99d..1ce71544af02 100644
--- a/universal/include/userver/yaml_config/yaml_config.hpp
+++ b/universal/include/userver/yaml_config/yaml_config.hpp
@@ -37,7 +37,7 @@ using ParseException = formats::yaml::ParseException;
 /// If YAML key ends on `#env` and the mode is YamlConfig::Mode::kEnvAllowed
 /// or YamlConfig::Mode::kEnvAndFileAllowed,
 /// then the value of the key is searched in
-/// environment variables of the process and returned as a value. For example:
+/// environment variables of the process and returned as a string value. For example:
 /// @snippet universal/src/yaml_config/yaml_config_test.cpp  sample env
 ///
 /// If YAML key ends on `#file` and the mode is
diff --git a/universal/src/crypto/certificate.cpp b/universal/src/crypto/certificate.cpp
index 9f8ac5abf942..bc3281d32c23 100644
--- a/universal/src/crypto/certificate.cpp
+++ b/universal/src/crypto/certificate.cpp
@@ -86,6 +86,36 @@ CertificatesChain LoadCertificatesChainFromString(std::string_view chain) {
     return certificates;
 }
 
+std::string Certificate::GetSubject() const {
+    X509* x509 = GetNative();
+    if (!x509) {
+        throw KeyParseError(FormatSslError("Invalid certificate"));
+    }
+
+    X509_NAME* subject_name = X509_get_subject_name(x509);
+    if (!subject_name) {
+        throw KeyParseError(FormatSslError("Failed to get subject name from certificate"));
+    }
+
+    BIO* bio = BIO_new(BIO_s_mem());
+    if (!bio) {
+        throw KeyParseError(FormatSslError("Failed to create BIO"));
+    }
+
+    const int flags = XN_FLAG_RFC2253;
+    if (X509_NAME_print_ex(bio, subject_name, 0, flags) < 0) {
+        BIO_free(bio);
+        throw KeyParseError(FormatSslError("Failed to print subject name"));
+    }
+
+    char* data = nullptr;
+    long len = BIO_get_mem_data(bio, &data);  // NOLINT(cppcoreguidelines-pro-type-cstyle-cast)
+    std::string result(data, len);
+
+    BIO_free(bio);
+    return result;
+}
+
 }  // namespace crypto
 
 USERVER_NAMESPACE_END
diff --git a/universal/src/crypto/hash.cpp b/universal/src/crypto/hash.cpp
index d52f9a676fc7..1f89bd9a9157 100644
--- a/universal/src/crypto/hash.cpp
+++ b/universal/src/crypto/hash.cpp
@@ -58,17 +58,20 @@ std::string EncodeString(std::string_view data, crypto::hash::OutputEncoding enc
 }
 
 template <typename HashAlgorithm>
-std::string CalculateHmac(std::string_view key, std::string_view data, crypto::hash::OutputEncoding encoding) {
+std::string CalculateHmac(
+    std::string_view key,
+    std::initializer_list<std::string_view> data_list,
+    crypto::hash::OutputEncoding encoding
+) {
     std::string mac;
 
     try {
         CryptoPP::HMAC<HashAlgorithm> hmac(reinterpret_cast<const byte*>(key.data()), key.size());
-        const CryptoPP::StringSource ss_key(
-            reinterpret_cast<const byte*>(data.data()),
-            data.size(),
-            true,
-            new CryptoPP::HashFilter(hmac, new CryptoPP::StringSink(mac))
-        );
+        for (const auto& data : data_list) {
+            hmac.Update(reinterpret_cast<const byte*>(data.data()), data.size());
+        }
+        mac.resize(HashAlgorithm::DIGESTSIZE);
+        hmac.Final(reinterpret_cast<byte*>(&mac[0]));
     } catch (const CryptoPP::Exception& exc) {
         throw crypto::CryptoException(exc.what());
     }
@@ -77,12 +80,15 @@ std::string CalculateHmac(std::string_view key, std::string_view data, crypto::h
 }
 
 template <typename HashAlgorithm>
-std::string CalculateHash(std::string_view data, crypto::hash::OutputEncoding encoding) {
+std::string CalculateHash(std::initializer_list<std::string_view> data_list, crypto::hash::OutputEncoding encoding) {
     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init): performance
     std::array<byte, HashAlgorithm::DIGESTSIZE> digest;
     try {
         HashAlgorithm hash;
-        hash.CalculateDigest(digest.data(), reinterpret_cast<const byte*>(data.data()), data.size());
+        for (const auto& data : data_list) {
+            hash.Update(reinterpret_cast<const byte*>(data.data()), data.size());
+        }
+        hash.Final(digest.data());
     } catch (const CryptoPP::Exception& exc) {
         throw crypto::CryptoException(exc.what());
     }
@@ -96,49 +102,93 @@ namespace crypto::hash {
 
 #ifndef USERVER_NO_CRYPTOPP_BLAKE2
 std::string Blake2b128(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<AlgoBlake2b128>({data}, encoding);
+}
+
+std::string Blake2b128(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<AlgoBlake2b128>(data, encoding);
 }
 #endif
 
 std::string Sha1(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<CryptoPP::SHA1>({data}, encoding);
+}
+
+std::string Sha1(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<CryptoPP::SHA1>(data, encoding);
 }
 
 std::string Sha224(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<CryptoPP::SHA224>({data}, encoding);
+}
+
+std::string Sha224(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<CryptoPP::SHA224>(data, encoding);
 }
 
 std::string Sha256(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<CryptoPP::SHA256>({data}, encoding);
+}
+
+std::string Sha256(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<CryptoPP::SHA256>(data, encoding);
 }
 
 std::string Sha384(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<CryptoPP::SHA384>({data}, encoding);
+}
+
+std::string Sha384(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<CryptoPP::SHA384>(data, encoding);
 }
 
 std::string Sha512(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<CryptoPP::SHA512>({data}, encoding);
+}
+
+std::string Sha512(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<CryptoPP::SHA512>(data, encoding);
 }
 
 std::string HmacSha512(std::string_view key, std::string_view message, OutputEncoding encoding) {
+    return CalculateHmac<CryptoPP::SHA512>(key, {message}, encoding);
+}
+
+std::string HmacSha512(std::string_view key, std::initializer_list<std::string_view> message, OutputEncoding encoding) {
     return CalculateHmac<CryptoPP::SHA512>(key, message, encoding);
 }
 
 std::string HmacSha384(std::string_view key, std::string_view message, OutputEncoding encoding) {
+    return CalculateHmac<CryptoPP::SHA384>(key, {message}, encoding);
+}
+
+std::string HmacSha384(std::string_view key, std::initializer_list<std::string_view> message, OutputEncoding encoding) {
     return CalculateHmac<CryptoPP::SHA384>(key, message, encoding);
 }
 
 std::string HmacSha256(std::string_view key, std::string_view message, OutputEncoding encoding) {
+    return CalculateHmac<CryptoPP::SHA256>(key, {message}, encoding);
+}
+
+std::string HmacSha256(std::string_view key, std::initializer_list<std::string_view> message, OutputEncoding encoding) {
     return CalculateHmac<CryptoPP::SHA256>(key, message, encoding);
 }
 
 std::string HmacSha1(std::string_view key, std::string_view message, OutputEncoding encoding) {
+    return CalculateHmac<CryptoPP::SHA1>(key, {message}, encoding);
+}
+
+std::string HmacSha1(std::string_view key, std::initializer_list<std::string_view> message, OutputEncoding encoding) {
     return CalculateHmac<CryptoPP::SHA1>(key, message, encoding);
 }
 
 namespace weak {
 
 std::string Md5(std::string_view data, OutputEncoding encoding) {
+    return CalculateHash<CryptoPP::Weak::MD5>({data}, encoding);
+}
+
+std::string Md5(std::initializer_list<std::string_view> data, OutputEncoding encoding) {
     return CalculateHash<CryptoPP::Weak::MD5>(data, encoding);
 }
 
diff --git a/universal/src/crypto/hash_test.cpp b/universal/src/crypto/hash_test.cpp
index 7ec293ce34d7..d607d908d03f 100644
--- a/universal/src/crypto/hash_test.cpp
+++ b/universal/src/crypto/hash_test.cpp
@@ -6,38 +6,56 @@ USERVER_NAMESPACE_BEGIN
 
 TEST(Crypto, Sha1) {
     EXPECT_EQ("da39a3ee5e6b4b0d3255bfef95601890afd80709", crypto::hash::Sha1({}));
+    EXPECT_EQ("da39a3ee5e6b4b0d3255bfef95601890afd80709", crypto::hash::Sha1({"", "", ""}));
     EXPECT_EQ("a94a8fe5ccb19ba61c4c0873d391e987982fbbd3", crypto::hash::Sha1("test"));
+    EXPECT_EQ("a94a8fe5ccb19ba61c4c0873d391e987982fbbd3", crypto::hash::Sha1({"te", "st"}));
     EXPECT_EQ("4e1243bd22c66e76c2ba9eddc1f91394e57f9f83", crypto::hash::Sha1("test\n"));
+    EXPECT_EQ("4e1243bd22c66e76c2ba9eddc1f91394e57f9f83", crypto::hash::Sha1({"test", "\n"}));
 }
 
 TEST(Crypto, Sha224) {
     EXPECT_EQ("d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", crypto::hash::Sha224({}));
+    EXPECT_EQ("d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", crypto::hash::Sha224({"", ""}));
     EXPECT_EQ("90a3ed9e32b2aaf4c61c410eb925426119e1a9dc53d4286ade99a809", crypto::hash::Sha224("test"));
+    EXPECT_EQ("90a3ed9e32b2aaf4c61c410eb925426119e1a9dc53d4286ade99a809", crypto::hash::Sha224({"t", "est"}));
     EXPECT_EQ("52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec", crypto::hash::Sha224("test\n"));
+    EXPECT_EQ("52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec", crypto::hash::Sha224({"te", "st\n"}));
 }
 
 TEST(Crypto, Sha256) {
     EXPECT_EQ("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", crypto::hash::Sha256({}));
+    EXPECT_EQ("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", crypto::hash::Sha256({""}));
     EXPECT_EQ("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08", crypto::hash::Sha256("test"));
+    EXPECT_EQ("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08", crypto::hash::Sha256({"tes", "t"}));
     EXPECT_EQ("f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2", crypto::hash::Sha256("test\n"));
+    EXPECT_EQ("f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2", crypto::hash::Sha256({"te", "st\n"}));
 }
 
 TEST(Crypto, Sha384) {
     EXPECT_EQ(
-        "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebf"
-        "e76f65fbd51ad2f14898b95b",
+        "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
         crypto::hash::Sha384({})
     );
     EXPECT_EQ(
-        "768412320f7b0aa5812fce428dc4706b3cae50e02a64caa16a782249bfe8efc4b7ef1ccb"
-        "126255d196047dfedf17a0a9",
+        "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
+        crypto::hash::Sha384({"", "", {}, {}, {}, {}, {}, {}})
+    );
+    EXPECT_EQ(
+        "768412320f7b0aa5812fce428dc4706b3cae50e02a64caa16a782249bfe8efc4b7ef1ccb126255d196047dfedf17a0a9",
         crypto::hash::Sha384("test")
     );
     EXPECT_EQ(
-        "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b"
-        "878f3d8234e1a170b154b72d",
+        "768412320f7b0aa5812fce428dc4706b3cae50e02a64caa16a782249bfe8efc4b7ef1ccb126255d196047dfedf17a0a9",
+        crypto::hash::Sha384({"te", "st", ""})
+    );
+    EXPECT_EQ(
+        "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d",
         crypto::hash::Sha384("test\n")
     );
+    EXPECT_EQ(
+        "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d",
+        crypto::hash::Sha384({"te", "st\n", ""})
+    );
 }
 
 TEST(Crypto, Sha512) {
@@ -46,22 +64,40 @@ TEST(Crypto, Sha512) {
         "5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
         crypto::hash::Sha512({})
     );
+    EXPECT_EQ(
+        "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c"
+        "5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+        crypto::hash::Sha512({"", ""})
+    );
     EXPECT_EQ(
         "ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8"
         "a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff",
         crypto::hash::Sha512("test")
     );
+    EXPECT_EQ(
+        "ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8"
+        "a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff",
+        crypto::hash::Sha512({"t", "e", "s", "t"})
+    );
     EXPECT_EQ(
         "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c"
         "1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123",
         crypto::hash::Sha512("test\n")
     );
+    EXPECT_EQ(
+        "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c"
+        "1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123",
+        crypto::hash::Sha512({"te", "st", "\n"})
+    );
 }
 
 TEST(Crypto, Md5) {
     EXPECT_EQ("d41d8cd98f00b204e9800998ecf8427e", crypto::hash::weak::Md5({}));
+    EXPECT_EQ("d41d8cd98f00b204e9800998ecf8427e", crypto::hash::weak::Md5({"", "", ""}));
     EXPECT_EQ("098f6bcd4621d373cade4e832627b4f6", crypto::hash::weak::Md5("test"));
+    EXPECT_EQ("098f6bcd4621d373cade4e832627b4f6", crypto::hash::weak::Md5({"te", "st"}));
     EXPECT_EQ("d8e8fca2dc0f896fd7cb4cb0031ba249", crypto::hash::weak::Md5("test\n"));
+    EXPECT_EQ("d8e8fca2dc0f896fd7cb4cb0031ba249", crypto::hash::weak::Md5({"t", "est\n"}));
 }
 
 TEST(Crypto, Hmac) {
@@ -70,26 +106,51 @@ TEST(Crypto, Hmac) {
         "60da3d43b82c2a040c931119d2dfc6d08e253742293a868cc2d82015",
         crypto::hash::HmacSha512("test", "test", crypto::hash::OutputEncoding::kHex)
     );
+    EXPECT_EQ(
+        "9ba1f63365a6caf66e46348f43cdef956015bea997adeb06e69007ee3ff517df10fc5eb8"
+        "60da3d43b82c2a040c931119d2dfc6d08e253742293a868cc2d82015",
+        crypto::hash::HmacSha512("test", {"t", "e", "st"}, crypto::hash::OutputEncoding::kHex)
+    );
+
     EXPECT_EQ(
         "m6H2M2WmyvZuRjSPQ83vlWAVvqmXresG5pAH7j/1F98Q/F64YNo9Q7gsKgQMkxEZ0t/"
         "G0I4lN0IpOoaMwtggFQ==",
         crypto::hash::HmacSha512("test", "test", crypto::hash::OutputEncoding::kBase64)
     );
+    EXPECT_EQ(
+        "m6H2M2WmyvZuRjSPQ83vlWAVvqmXresG5pAH7j/1F98Q/F64YNo9Q7gsKgQMkxEZ0t/"
+        "G0I4lN0IpOoaMwtggFQ==",
+        crypto::hash::HmacSha512("test", {"te", "s", "t"}, crypto::hash::OutputEncoding::kBase64)
+    );
 
     EXPECT_EQ(
         "88cd2108b5347d973cf39cdf9053d7dd42704876d8c9a9bd8e2d168259d3ddf7",
         crypto::hash::HmacSha256("test", "test", crypto::hash::OutputEncoding::kHex)
     );
+    EXPECT_EQ(
+        "88cd2108b5347d973cf39cdf9053d7dd42704876d8c9a9bd8e2d168259d3ddf7",
+        crypto::hash::HmacSha256("test", {"tes", "t"}, crypto::hash::OutputEncoding::kHex)
+    );
 
     EXPECT_EQ(
         "0c94515c15e5095b8a87a50ba0df3bf38ed05fe6",
         crypto::hash::HmacSha1("test", "test", crypto::hash::OutputEncoding::kHex)
     );
+    EXPECT_EQ(
+        "0c94515c15e5095b8a87a50ba0df3bf38ed05fe6",
+        crypto::hash::HmacSha1("test", {"t", "e", "s", "t"}, crypto::hash::OutputEncoding::kHex)
+    );
+
     EXPECT_EQ(
         "b818f4664d0826b102b72cf2a687f558368f2152b15b83a7f389e48c335fc455282c61e9"
         "7335dae370bac31a8196772d",
         crypto::hash::HmacSha384("secret", "", crypto::hash::OutputEncoding::kHex)
     );
+    EXPECT_EQ(
+        "b818f4664d0826b102b72cf2a687f558368f2152b15b83a7f389e48c335fc455282c61e9"
+        "7335dae370bac31a8196772d",
+        crypto::hash::HmacSha384("secret", {"", "", ""}, crypto::hash::OutputEncoding::kHex)
+    );
 }
 
 #ifndef USERVER_NO_CRYPTOPP_BLAKE2
@@ -97,7 +158,14 @@ TEST(Crypto, Blake2b128) {
     EXPECT_EQ(
         "e9a804b2e527fd3601d2ffc0bb023cd6", crypto::hash::Blake2b128("hello world", crypto::hash::OutputEncoding::kHex)
     );
+    EXPECT_EQ(
+        "e9a804b2e527fd3601d2ffc0bb023cd6",
+        crypto::hash::Blake2b128({"hello ", "world"}, crypto::hash::OutputEncoding::kHex)
+    );
     EXPECT_EQ("cae66941d9efbd404e4d88758ea67670", crypto::hash::Blake2b128("", crypto::hash::OutputEncoding::kHex));
+    EXPECT_EQ(
+        "cae66941d9efbd404e4d88758ea67670", crypto::hash::Blake2b128({"", ""}, crypto::hash::OutputEncoding::kHex)
+    );
 }
 #endif
 
diff --git a/universal/src/crypto/helpers.cpp b/universal/src/crypto/helpers.cpp
index 7286ea6fd776..019fc0b0f367 100644
--- a/universal/src/crypto/helpers.cpp
+++ b/universal/src/crypto/helpers.cpp
@@ -92,21 +92,6 @@ EvpMdCtx::~EvpMdCtx() {
 
 EvpMdCtx::EvpMdCtx(EvpMdCtx&& other) noexcept : ctx_(std::exchange(other.ctx_, nullptr)) {}
 
-decltype(&crypto::hash::HmacSha256) GetHmacFuncByEnum(DigestSize bits) {
-    switch (bits) {
-        case DigestSize::k160:
-            return crypto::hash::HmacSha1;
-        case DigestSize::k256:
-            return crypto::hash::HmacSha256;
-        case DigestSize::k384:
-            return crypto::hash::HmacSha384;
-        case DigestSize::k512:
-            return crypto::hash::HmacSha512;
-    }
-
-    UINVARIANT(false, "Unexpected DigestSize");
-}
-
 const EVP_MD* GetShaMdByEnum(DigestSize bits) {
     switch (bits) {
         case DigestSize::k160:
@@ -122,7 +107,6 @@ const EVP_MD* GetShaMdByEnum(DigestSize bits) {
     UINVARIANT(false, "Unexpected DigestSize");
 }
 
-// TODO: remove after finishing the https://st.yandex-team.ru/TAXICOMMON-1754
 std::string InitListToString(std::initializer_list<std::string_view> data) {
     std::string combined_value;
 
diff --git a/universal/src/crypto/helpers.hpp b/universal/src/crypto/helpers.hpp
index a2df4bb8201f..692923f7cf94 100644
--- a/universal/src/crypto/helpers.hpp
+++ b/universal/src/crypto/helpers.hpp
@@ -49,7 +49,6 @@ constexpr size_t GetDigestLength(DigestSize digest_size) {
     return (bits + CHAR_BIT - 1) / CHAR_BIT;
 }
 
-decltype(&crypto::hash::HmacSha256) GetHmacFuncByEnum(DigestSize bits);
 const EVP_MD* GetShaMdByEnum(DigestSize bits);
 
 std::string InitListToString(std::initializer_list<std::string_view> data);
diff --git a/universal/src/crypto/signature_test.cpp b/universal/src/crypto/signature_test.cpp
index 0dbcc9a9604c..c3935cc6769d 100644
--- a/universal/src/crypto/signature_test.cpp
+++ b/universal/src/crypto/signature_test.cpp
@@ -197,9 +197,13 @@ void TestDsaSignature(
     utils::Flags<TestFlags> flags = {}
 ) {
     const auto sig = signer.Sign({message});
+    const auto sig2 = signer.Sign({message.substr(0, 1), message.substr(1), "", ""});
     const auto bad_sig = signer.Sign({"bad ", message});
 
     EXPECT_NO_THROW(verifier.Verify({message}, sig));
+    EXPECT_NO_THROW(verifier.Verify({message}, sig2));
+    EXPECT_NO_THROW(verifier.Verify({message.substr(0, 2), message.substr(2)}, sig));
+    EXPECT_NO_THROW(verifier.Verify({message.substr(0, 1), message.substr(1, 1), message.substr(2)}, sig));
     EXPECT_THROW(verifier.Verify({message}, {}), crypto::VerificationError);
     EXPECT_THROW(verifier.Verify({"not ", message}, sig), crypto::VerificationError);
     EXPECT_THROW(verifier.Verify({message}, bad_sig), crypto::VerificationError);
@@ -227,18 +231,23 @@ void TestDsaSignature(
 
 TEST(Crypto, SignatureNone) {
     EXPECT_TRUE(crypto::SignerNone{}.Sign({"test"}).empty());
+    EXPECT_TRUE(crypto::SignerNone{}.Sign({"te", "st"}).empty());
     EXPECT_NO_THROW(crypto::VerifierNone{}.Verify({"test"}, {}));
+    EXPECT_NO_THROW(crypto::VerifierNone{}.Verify({"tes", "t"}, {}));
     EXPECT_THROW(crypto::VerifierNone{}.Verify({"test"}, "test"), crypto::VerificationError);
 }
 
 TEST(Crypto, SignatureHs1) {
     const crypto::SignerHs1 signer("secret");
     auto sig = signer.Sign({"test"});
+    auto sig2 = signer.Sign({"te", "st"});
     auto bad_sig = signer.Sign({"bad test"});
     EXPECT_EQ("1aa349585ed7ecbd3b9c486a30067e395ca4b356", utils::encoding::ToHex(sig));
+    EXPECT_EQ(utils::encoding::ToHex(sig2), utils::encoding::ToHex(sig));
 
     const crypto::VerifierHs1 verifier("secret");
     EXPECT_NO_THROW(verifier.Verify({"test"}, sig));
+    EXPECT_NO_THROW(verifier.Verify({"t", "es", "t"}, sig));
     EXPECT_THROW(verifier.Verify({"test"}, {}), crypto::VerificationError);
     EXPECT_THROW(verifier.Verify({"not test"}, sig), crypto::VerificationError);
     EXPECT_THROW(verifier.Verify({"test"}, bad_sig), crypto::VerificationError);
@@ -247,11 +256,15 @@ TEST(Crypto, SignatureHs1) {
 TEST(Crypto, SignatureHs256) {
     const crypto::SignerHs256 signer("secret");
     auto sig = signer.Sign({"test"});
+    auto sig2 = signer.Sign({"te", "st"});
     auto bad_sig = signer.Sign({"bad test"});
     EXPECT_EQ("0329a06b62cd16b33eb6792be8c60b158d89a2ee3a876fce9a881ebb488c0914", utils::encoding::ToHex(sig));
+    EXPECT_EQ(utils::encoding::ToHex(sig2), utils::encoding::ToHex(sig));
 
     const crypto::VerifierHs256 verifier("secret");
     EXPECT_NO_THROW(verifier.Verify({"test"}, sig));
+    EXPECT_NO_THROW(verifier.Verify({"te", "st"}, sig));
+    EXPECT_NO_THROW(verifier.Verify({"t", "e", "st"}, sig));
     EXPECT_THROW(verifier.Verify({"test"}, {}), crypto::VerificationError);
     EXPECT_THROW(verifier.Verify({"not test"}, sig), crypto::VerificationError);
     EXPECT_THROW(verifier.Verify({"test"}, bad_sig), crypto::VerificationError);
diff --git a/universal/src/crypto/signers.cpp b/universal/src/crypto/signers.cpp
index a0e4edc6239a..2ab0a2c3279a 100644
--- a/universal/src/crypto/signers.cpp
+++ b/universal/src/crypto/signers.cpp
@@ -112,29 +112,29 @@ std::string SignerNone::Sign(std::initializer_list<std::string_view> /*data*/) c
 /// HMAC-SHA
 ///
 
-template <DigestSize bits>
-HmacShaSigner<bits>::HmacShaSigner(std::string secret)
-    : Signer("HS" + EnumValueToString(bits)), secret_(std::move(secret)) {}
+template <DigestSize Bits>
+HmacShaSigner<Bits>::HmacShaSigner(std::string secret)
+    : Signer("HS" + EnumValueToString(Bits)), secret_(std::move(secret)) {}
 
-template <DigestSize bits>
-HmacShaSigner<bits>::~HmacShaSigner() {
+template <DigestSize Bits>
+HmacShaSigner<Bits>::~HmacShaSigner() {
     OPENSSL_cleanse(secret_.data(), secret_.size());
 }
 
-template <DigestSize bits>
-std::string HmacShaSigner<bits>::Sign(std::initializer_list<std::string_view> data) const {
-    const auto hmac = GetHmacFuncByEnum(bits);
-
-    if (data.size() <= 1) {
-        std::string_view single_value{};
-        if (data.size()) {
-            single_value = *data.begin();
-        }
-
-        return hmac(secret_, single_value, crypto::hash::OutputEncoding::kBinary);
+template <DigestSize Bits>
+std::string HmacShaSigner<Bits>::Sign(std::initializer_list<std::string_view> data) const {
+    switch (Bits) {
+        case DigestSize::k160:
+            return crypto::hash::HmacSha1(secret_, data, crypto::hash::OutputEncoding::kBinary);
+        case DigestSize::k256:
+            return crypto::hash::HmacSha256(secret_, data, crypto::hash::OutputEncoding::kBinary);
+        case DigestSize::k384:
+            return crypto::hash::HmacSha384(secret_, data, crypto::hash::OutputEncoding::kBinary);
+        case DigestSize::k512:
+            return crypto::hash::HmacSha512(secret_, data, crypto::hash::OutputEncoding::kBinary);
+        default:
+            UINVARIANT(false, "Unexpected DigestSize");
     }
-
-    return hmac(secret_, InitListToString(data), crypto::hash::OutputEncoding::kBinary);
 }
 
 template class HmacShaSigner<DigestSize::k160>;
@@ -146,16 +146,16 @@ template class HmacShaSigner<DigestSize::k512>;
 /// *SA
 ///
 
-template <DsaType type, DigestSize bits>
-DsaSigner<type, bits>::DsaSigner(const std::string& key, const std::string& password)
-    : Signer(EnumValueToString(type) + EnumValueToString(bits)), pkey_(PrivateKey::LoadFromString(key, password)) {
+template <DsaType Type, DigestSize Bits>
+DsaSigner<Type, Bits>::DsaSigner(const std::string& key, const std::string& password)
+    : Signer(EnumValueToString(Type) + EnumValueToString(Bits)), pkey_(PrivateKey::LoadFromString(key, password)) {
     Openssl::Init();
 
-    if constexpr (type == DsaType::kEc) {
+    if constexpr (Type == DsaType::kEc) {
         if (EVP_PKEY_base_id(pkey_.GetNative()) != EVP_PKEY_EC) {
             throw SignError("Non-EC key supplied for " + Name() + " signer");
         }
-        if (!IsMatchingKeyCurve(pkey_.GetNative(), bits)) {
+        if (!IsMatchingKeyCurve(pkey_.GetNative(), Bits)) {
             throw SignError("Key curve mismatch for " + Name() + " signer");
         }
     } else {
@@ -165,16 +165,16 @@ DsaSigner<type, bits>::DsaSigner(const std::string& key, const std::string& pass
     }
 }
 
-template <DsaType type, DigestSize bits>
-std::string DsaSigner<type, bits>::Sign(std::initializer_list<std::string_view> data) const {
+template <DsaType Type, DigestSize Bits>
+std::string DsaSigner<Type, Bits>::Sign(std::initializer_list<std::string_view> data) const {
     EvpMdCtx ctx;
     EVP_PKEY_CTX* pkey_ctx = nullptr;  // non-owning
-    if (1 != EVP_DigestSignInit(ctx.Get(), &pkey_ctx, GetShaMdByEnum(bits), nullptr, pkey_.GetNative())) {
+    if (1 != EVP_DigestSignInit(ctx.Get(), &pkey_ctx, GetShaMdByEnum(Bits), nullptr, pkey_.GetNative())) {
         throw SignError(FormatSslError("Failed to sign: EVP_DigestSignInit"));
     }
 
-    if constexpr (type == DsaType::kRsaPss) {
-        SetupJwaRsaPssPadding(pkey_ctx, bits);
+    if constexpr (Type == DsaType::kRsaPss) {
+        SetupJwaRsaPssPadding(pkey_ctx, Bits);
     }
 
     for (const auto& part : data) {
@@ -194,20 +194,20 @@ std::string DsaSigner<type, bits>::Sign(std::initializer_list<std::string_view>
     }
     signature.resize(siglen);
 
-    if constexpr (type == DsaType::kEc) {
-        return ConvertEcSignature(signature, bits);
+    if constexpr (Type == DsaType::kEc) {
+        return ConvertEcSignature(signature, Bits);
     }
     return signature;
 }
 
-template <DsaType type, DigestSize bits>
-std::string DsaSigner<type, bits>::SignDigest(std::string_view digest) const {
-    if constexpr (type == DsaType::kRsaPss) {
+template <DsaType Type, DigestSize Bits>
+std::string DsaSigner<Type, Bits>::SignDigest(std::string_view digest) const {
+    if constexpr (Type == DsaType::kRsaPss) {
         UASSERT_MSG(false, "SignDigest is not available with PSS padding");
         throw CryptoException("SignDigest is not available with PSS padding");
     }
 
-    if (digest.size() != GetDigestLength(bits)) {
+    if (digest.size() != GetDigestLength(Bits)) {
         throw SignError("Invalid digest size for " + Name() + " signer");
     }
 
@@ -220,7 +220,7 @@ std::string DsaSigner<type, bits>::SignDigest(std::string_view digest) const {
     if (1 != EVP_PKEY_sign_init(pkey_ctx.get())) {
         throw SignError(FormatSslError("Failed to sign digest: EVP_PKEY_sign_init"));
     }
-    if (EVP_PKEY_CTX_set_signature_md(pkey_ctx.get(), GetShaMdByEnum(bits)) <= 0) {
+    if (EVP_PKEY_CTX_set_signature_md(pkey_ctx.get(), GetShaMdByEnum(Bits)) <= 0) {
         throw SignError(FormatSslError("Failed to sign digest: EVP_PKEY_CTX_set_signature_md"));
     }
 
@@ -243,8 +243,8 @@ std::string DsaSigner<type, bits>::SignDigest(std::string_view digest) const {
     }
     signature.resize(siglen);
 
-    if constexpr (type == DsaType::kEc) {
-        return ConvertEcSignature(signature, bits);
+    if constexpr (Type == DsaType::kEc) {
+        return ConvertEcSignature(signature, Bits);
     }
     return signature;
 }
diff --git a/universal/src/crypto/ssl_ctx.cpp b/universal/src/crypto/ssl_ctx.cpp
new file mode 100644
index 000000000000..1dd267a9692b
--- /dev/null
+++ b/universal/src/crypto/ssl_ctx.cpp
@@ -0,0 +1,192 @@
+#include <userver/crypto/ssl_ctx.hpp>
+
+#include <fmt/core.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+
+#include <crypto/helpers.hpp>
+#include <userver/crypto/openssl.hpp>
+#include <userver/logging/log.hpp>
+#include <userver/utils/assert.hpp>
+
+USERVER_NAMESPACE_BEGIN
+namespace crypto {
+
+class SslCtx::Impl {
+public:
+    static std::unique_ptr<Impl> MakeSslCtx();
+
+    explicit Impl(SSL_CTX* ctx) : ctx_{ctx} {}
+
+    ~Impl() {
+        if (ctx_) SSL_CTX_free(ctx_);
+    }
+
+    SSL_CTX* Get() noexcept { return ctx_; }
+
+private:
+    SSL_CTX* ctx_;
+};
+
+std::unique_ptr<SslCtx::Impl> SslCtx::Impl::MakeSslCtx() {
+    crypto::Openssl::Init();
+
+    SSL_CTX* ssl_ctx = SSL_CTX_new(SSLv23_method());
+    if (!ssl_ctx) {
+        throw CryptoException(crypto::FormatSslError("Failed create an SSL context: SSL_CTX_new"));
+    }
+#if OPENSSL_VERSION_NUMBER >= 0x010100000L
+    if (1 != SSL_CTX_set_min_proto_version(ssl_ctx, TLS1_VERSION)) {
+        throw CryptoException(crypto::FormatSslError("Failed create an SSL context: SSL_CTX_set_min_proto_version"));
+    }
+#endif
+
+    constexpr auto options = SSL_OP_ALL | SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_COMPRESSION
+#if OPENSSL_VERSION_NUMBER >= 0x010100000L
+                             | SSL_OP_NO_RENEGOTIATION
+#endif
+        ;
+    SSL_CTX_set_options(ssl_ctx, options);
+    SSL_CTX_set_mode(ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
+    SSL_CTX_clear_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
+    if (1 != SSL_CTX_set_default_verify_paths(ssl_ctx)) {
+        LOG_LIMITED_WARNING() << crypto::FormatSslError("Failed create an SSL context: SSL_CTX_set_default_verify_paths"
+        );
+    }
+
+    return std::make_unique<Impl>(ssl_ctx);
+}
+
+void* SslCtx::GetRawSslCtx() const noexcept { return static_cast<void*>(impl_->Get()); }
+
+SslCtx::SslCtx(std::unique_ptr<Impl>&& impl) : impl_(std::move(impl)) {}
+
+SslCtx::SslCtx(SslCtx&& other) noexcept = default;
+SslCtx& SslCtx::operator=(SslCtx&& other) noexcept = default;
+SslCtx::~SslCtx() = default;
+
+void SslCtx::AddCertAuthorities(const std::vector<crypto::Certificate>& cert_authorities) {
+    UASSERT(!cert_authorities.empty());
+    auto* store = SSL_CTX_get_cert_store(impl_->Get());
+    UASSERT(store);
+    for (const auto& ca : cert_authorities) {
+        if (1 != X509_STORE_add_cert(store, ca.GetNative())) {
+            throw CryptoException(crypto::FormatSslError("X509_STORE_add_cert failed"));
+        }
+    }
+}
+
+void SslCtx::EnableVerifyClientCertificate() {
+    SSL_CTX_set_verify(impl_->Get(), SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
+}
+
+void SslCtx::SetServerName(std::string_view server_name) {
+    if (server_name.empty()) {
+        return;
+    }
+
+    X509_VERIFY_PARAM* verify_param = SSL_CTX_get0_param(impl_->Get());
+    if (!verify_param) {
+        throw CryptoException("SSL_CTX_get0_param failed");
+    }
+    if (1 != X509_VERIFY_PARAM_set1_host(verify_param, server_name.data(), server_name.size())) {
+        throw CryptoException(crypto::FormatSslError("X509_VERIFY_PARAM_set1_host failed"));
+    }
+    SSL_CTX_set_verify(impl_->Get(), SSL_VERIFY_PEER, nullptr);
+}
+
+void SslCtx::SetCertificate(const crypto::Certificate& cert) {
+    if (1 != SSL_CTX_use_certificate(impl_->Get(), cert.GetNative())) {
+        throw CryptoException(crypto::FormatSslError("SSL_CTX_use_certificate failed"));
+    }
+
+    LOG_INFO() << "Loaded server cert: subject=" << cert.GetSubject();
+}
+
+void SslCtx::SetCertificates(const crypto::CertificatesChain& cert_chain) {
+    if (cert_chain.empty()) {
+        throw CryptoException(crypto::FormatSslError("Empty certificate chain provided"));
+    }
+
+    SetCertificate(*cert_chain.begin());
+
+    if (cert_chain.size() > 1) {
+        auto it = std::next(cert_chain.begin());
+        for (; it != cert_chain.end(); ++it) {
+            // cast in openssl1.0 macro expansion
+            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
+            if (SSL_CTX_add_extra_chain_cert(impl_->Get(), it->GetNative()) <= 0) {
+                throw CryptoException(crypto::FormatSslError("SSL_CTX_add_extra_chain_cert failed"));
+            }
+
+            LOG_INFO() << "Loaded extra chain cert: subject=" << it->GetSubject();
+
+            // After SSL_CTX_add_extra_chain_cert we should not free the cert
+            const auto ret = X509_up_ref(it->GetNative());
+            UASSERT(ret == 1);
+        }
+    }
+}
+
+void SslCtx::SetPrivateKey(const crypto::PrivateKey& key) {
+    if (1 != SSL_CTX_use_PrivateKey(impl_->Get(), key.GetNative())) {
+        throw CryptoException(crypto::FormatSslError("SSL_CTX_use_PrivateKey failed"));
+    }
+
+    LOG_INFO() << "Loaded server private key";
+
+    if (1 != SSL_CTX_check_private_key(impl_->Get())) {
+        throw CryptoException("Private key does not match the certificate public key");
+    }
+}
+
+SslCtx SslCtx::CreateClientTlsContext(std::string_view server_name) {
+    SslCtx ssl_ctx(Impl::MakeSslCtx());
+    ssl_ctx.SetServerName(server_name);
+    return ssl_ctx;
+}
+
+SslCtx SslCtx::CreateClientTlsContext(
+    std::string_view server_name,
+    const crypto::Certificate& cert,
+    const crypto::PrivateKey& key,
+    const std::vector<crypto::Certificate>& extra_cert_authorities
+) {
+    SslCtx ssl_ctx(Impl::MakeSslCtx());
+
+    ssl_ctx.SetServerName(server_name);
+
+    if (!extra_cert_authorities.empty()) {
+        ssl_ctx.AddCertAuthorities(extra_cert_authorities);
+    }
+
+    ssl_ctx.SetCertificate(cert);
+    ssl_ctx.SetPrivateKey(key);
+
+    return ssl_ctx;
+}
+
+SslCtx SslCtx::CreateServerTlsContext(
+    const crypto::CertificatesChain& cert_chain,
+    const crypto::PrivateKey& key,
+    const std::vector<crypto::Certificate>& extra_cert_authorities
+) {
+    SslCtx ssl_ctx(Impl::MakeSslCtx());
+
+    if (!extra_cert_authorities.empty()) {
+        ssl_ctx.AddCertAuthorities(extra_cert_authorities);
+        ssl_ctx.EnableVerifyClientCertificate();
+        LOG_INFO() << "Client SSL cert will be verified";
+    } else {
+        LOG_INFO() << "Client SSL cert will not be verified";
+    }
+
+    ssl_ctx.SetCertificates(cert_chain);
+    ssl_ctx.SetPrivateKey(key);
+
+    return ssl_ctx;
+}
+
+}  // namespace crypto
+
+USERVER_NAMESPACE_END
diff --git a/universal/src/crypto/verifiers.cpp b/universal/src/crypto/verifiers.cpp
index 056d0f017d3d..a4390fb8b39b 100644
--- a/universal/src/crypto/verifiers.cpp
+++ b/universal/src/crypto/verifiers.cpp
@@ -10,6 +10,7 @@
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 
+#include <userver/crypto/algorithm.hpp>
 #include <userver/crypto/openssl.hpp>
 #include <userver/utils/assert.hpp>
 
@@ -107,31 +108,36 @@ void VerifierNone::Verify(std::initializer_list<std::string_view> /*data*/, std:
 /// HMAC-SHA
 ///
 
-template <DigestSize bits>
-HmacShaVerifier<bits>::HmacShaVerifier(std::string secret)
-    : Verifier("HS" + EnumValueToString(bits)), secret_(std::move(secret)) {}
+template <DigestSize Bits>
+HmacShaVerifier<Bits>::HmacShaVerifier(std::string secret)
+    : Verifier("HS" + EnumValueToString(Bits)), secret_(std::move(secret)) {}
 
-template <DigestSize bits>
-HmacShaVerifier<bits>::~HmacShaVerifier() {
+template <DigestSize Bits>
+HmacShaVerifier<Bits>::~HmacShaVerifier() {
     OPENSSL_cleanse(secret_.data(), secret_.size());
 }
 
-template <DigestSize bits>
-void HmacShaVerifier<bits>::Verify(std::initializer_list<std::string_view> data, std::string_view raw_signature) const {
-    const auto hmac = GetHmacFuncByEnum(bits);
+template <DigestSize Bits>
+void HmacShaVerifier<Bits>::Verify(std::initializer_list<std::string_view> data, std::string_view raw_signature) const {
     std::string signature;
-    if (data.size() <= 1) {
-        std::string_view single_value{};
-        if (data.size() == 1) {
-            single_value = *data.begin();
-        }
-
-        signature = hmac(secret_, single_value, crypto::hash::OutputEncoding::kBinary);
-    } else {
-        signature = hmac(secret_, InitListToString(data), crypto::hash::OutputEncoding::kBinary);
+    switch (Bits) {
+        case DigestSize::k160:
+            signature = crypto::hash::HmacSha1(secret_, data, crypto::hash::OutputEncoding::kBinary);
+            break;
+        case DigestSize::k256:
+            signature = crypto::hash::HmacSha256(secret_, data, crypto::hash::OutputEncoding::kBinary);
+            break;
+        case DigestSize::k384:
+            signature = crypto::hash::HmacSha384(secret_, data, crypto::hash::OutputEncoding::kBinary);
+            break;
+        case DigestSize::k512:
+            signature = crypto::hash::HmacSha512(secret_, data, crypto::hash::OutputEncoding::kBinary);
+            break;
+        default:
+            UINVARIANT(false, "Unexpected DigestSize");
     }
 
-    if (raw_signature != signature) {
+    if (!algorithm::AreStringsEqualConstTime(raw_signature, signature)) {
         throw VerificationError("Invalid signature");
     }
 }
@@ -145,16 +151,16 @@ template class HmacShaVerifier<DigestSize::k512>;
 /// *SA
 ///
 
-template <DsaType type, DigestSize bits>
-DsaVerifier<type, bits>::DsaVerifier(PublicKey pubkey)
-    : Verifier(EnumValueToString(type) + EnumValueToString(bits)), pkey_(std::move(pubkey)) {
+template <DsaType Type, DigestSize Bits>
+DsaVerifier<Type, Bits>::DsaVerifier(PublicKey pubkey)
+    : Verifier(EnumValueToString(Type) + EnumValueToString(Bits)), pkey_(std::move(pubkey)) {
     Openssl::Init();
 
-    if constexpr (type == DsaType::kEc) {
+    if constexpr (Type == DsaType::kEc) {
         if (EVP_PKEY_base_id(pkey_.GetNative()) != EVP_PKEY_EC) {
             throw VerificationError("Non-EC key supplied for " + Name() + " verifier");
         }
-        if (!IsMatchingKeyCurve(pkey_.GetNative(), bits)) {
+        if (!IsMatchingKeyCurve(pkey_.GetNative(), Bits)) {
             throw VerificationError("Key curve mismatch for " + Name() + " verifier");
         }
     } else {
@@ -164,20 +170,20 @@ DsaVerifier<type, bits>::DsaVerifier(PublicKey pubkey)
     }
 }
 
-template <DsaType type, DigestSize bits>
-DsaVerifier<type, bits>::DsaVerifier(std::string_view key) : DsaVerifier{PublicKey::LoadFromString(key)} {}
+template <DsaType Type, DigestSize Bits>
+DsaVerifier<Type, Bits>::DsaVerifier(std::string_view key) : DsaVerifier{PublicKey::LoadFromString(key)} {}
 
-template <DsaType type, DigestSize bits>
-void DsaVerifier<type, bits>::Verify(std::initializer_list<std::string_view> data, std::string_view raw_signature)
+template <DsaType Type, DigestSize Bits>
+void DsaVerifier<Type, Bits>::Verify(std::initializer_list<std::string_view> data, std::string_view raw_signature)
     const {
     EvpMdCtx ctx;
     EVP_PKEY_CTX* pkey_ctx = nullptr;
-    if (1 != EVP_DigestVerifyInit(ctx.Get(), &pkey_ctx, GetShaMdByEnum(bits), nullptr, pkey_.GetNative())) {
+    if (1 != EVP_DigestVerifyInit(ctx.Get(), &pkey_ctx, GetShaMdByEnum(Bits), nullptr, pkey_.GetNative())) {
         throw VerificationError(FormatSslError("Failed to verify: EVP_DigestVerifyInit"));
     }
 
-    if constexpr (type == DsaType::kRsaPss) {
-        SetupJwaRsaPssPadding(pkey_ctx, bits);
+    if constexpr (Type == DsaType::kRsaPss) {
+        SetupJwaRsaPssPadding(pkey_ctx, Bits);
     }
 
     for (const auto& part : data) {
@@ -187,7 +193,7 @@ void DsaVerifier<type, bits>::Verify(std::initializer_list<std::string_view> dat
     }
 
     int verification_result = -1;
-    if constexpr (type == DsaType::kEc) {
+    if constexpr (Type == DsaType::kEc) {
         auto der_signature = ConvertEcSignature(raw_signature);
         verification_result = EVP_DigestVerifyFinal(ctx.Get(), der_signature.data(), der_signature.size());
     } else {
@@ -201,14 +207,14 @@ void DsaVerifier<type, bits>::Verify(std::initializer_list<std::string_view> dat
     }
 }
 
-template <DsaType type, DigestSize bits>
-void DsaVerifier<type, bits>::VerifyDigest(std::string_view digest, std::string_view raw_signature) const {
-    if constexpr (type == DsaType::kRsaPss) {
+template <DsaType Type, DigestSize Bits>
+void DsaVerifier<Type, Bits>::VerifyDigest(std::string_view digest, std::string_view raw_signature) const {
+    if constexpr (Type == DsaType::kRsaPss) {
         UASSERT_MSG(false, "VerifyDigest is not available with PSS padding");
         throw CryptoException("VerifyDigest is not available with PSS padding");
     }
 
-    if (digest.size() != GetDigestLength(bits)) {
+    if (digest.size() != GetDigestLength(Bits)) {
         throw VerificationError("Invalid digest size for " + Name() + " verifier");
     }
 
@@ -221,12 +227,12 @@ void DsaVerifier<type, bits>::VerifyDigest(std::string_view digest, std::string_
     if (1 != EVP_PKEY_verify_init(pkey_ctx.get())) {
         throw VerificationError(FormatSslError("Failed to verify digest: EVP_PKEY_verify_init"));
     }
-    if (EVP_PKEY_CTX_set_signature_md(pkey_ctx.get(), GetShaMdByEnum(bits)) <= 0) {
+    if (EVP_PKEY_CTX_set_signature_md(pkey_ctx.get(), GetShaMdByEnum(Bits)) <= 0) {
         throw VerificationError(FormatSslError("Failed to sign digest: EVP_PKEY_CTX_set_signature_md"));
     }
 
     int verification_result = -1;
-    if constexpr (type == DsaType::kEc) {
+    if constexpr (Type == DsaType::kEc) {
         auto der_signature = ConvertEcSignature(raw_signature);
         verification_result = EVP_PKEY_verify(
             pkey_ctx.get(),
diff --git a/universal/src/decimal64/decimal64.cpp b/universal/src/decimal64/decimal64.cpp
index 3ad9f6376f51..2735ace8aea8 100644
--- a/universal/src/decimal64/decimal64.cpp
+++ b/universal/src/decimal64/decimal64.cpp
@@ -34,6 +34,10 @@ std::string_view ErrorDescription(ParseErrorCode error_code) {
         case ParseErrorCode::kBoundaryDot:
             return "the input includes leading or trailing dot (like '42.'), while "
                    "such notation is disallowed";
+        case ParseErrorCode::kExponentNotAllowed:
+            return "the input contains an exponent character, but exponent notation is disabled";
+        case ParseErrorCode::kNoExponentDigits:
+            return "exponent detected, but no digits follow it (or its sign)";
     }
 
     UINVARIANT(false, "Unexpected decimal64 error code");
diff --git a/universal/src/decimal64/decimal64_parsing_test.cpp b/universal/src/decimal64/decimal64_parsing_test.cpp
index 0a77d8ccb6a6..312f68b65fea 100644
--- a/universal/src/decimal64/decimal64_parsing_test.cpp
+++ b/universal/src/decimal64/decimal64_parsing_test.cpp
@@ -242,4 +242,155 @@ TEST(Decimal64, RoundPolicies) {
     EXPECT_EQ(Down::FromStringPermissive("-0.000099999999999999"), Down{0});
 }
 
+TEST(Decimal64, BannedRounding) {
+    EXPECT_EQ(Dec4{"1.0000"}, Dec4{1});
+    EXPECT_THROW(Dec4{"1.00000"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"11.20000"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"1.123546"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"-1.00000"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"-1.123546"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"-1.20000"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"0.00000"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"0.20000"}, decimal64::ParseError);
+    EXPECT_THROW(Dec4{"0.123546"}, decimal64::ParseError);
+}
+
+TEST(Decimal64Exponent, Stream) {
+    TestFromStream("33e1.123", true, Dec4{"330"}, ".123");
+    TestFromStream("0.1233e1#.342", true, Dec4{"1.233"}, "#.342");
+    TestFromStream("33e1", true, Dec4{"330"}, "");
+    TestFromStream("3.3e2", true, Dec4{"330"}, "");
+    TestFromStream("0.03e3", true, Dec4{"30"}, "");
+    TestFromStream("0.3e-2", true, Dec4{"0.003"}, "");
+    TestFromStream("-33e1", true, Dec4{"-330"}, "");
+    TestFromStream("-3.3e2", true, Dec4{"-330"}, "");
+    TestFromStream("-0.03e3", true, Dec4{"-30"}, "");
+    TestFromStream("-0.3e-2", true, Dec4{"-0.003"}, "");
+}
+
+TEST(Decimal64Exponent, Simple) {
+    EXPECT_EQ(Dec4::FromStringPermissive("1e2"), Dec4{"100"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1e+2"), Dec4{"100"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.234e2"), Dec4{"123.4"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.234e+2"), Dec4{"123.4"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1234e0"), Dec4{"1234"});
+    EXPECT_EQ(Dec4::FromStringPermissive("0e5"), Dec4{0});
+}
+
+TEST(Decimal64Exponent, Negative) {
+    EXPECT_EQ(Dec4::FromStringPermissive("1234e-1"), Dec4{"123.4"});
+    EXPECT_EQ(Dec4::FromStringPermissive("123e-4"), Dec4{"0.0123"});
+    EXPECT_EQ(Dec4::FromStringPermissive("-1.234e2"), Dec4{"-123.4"});
+    EXPECT_EQ(Dec4::FromStringPermissive("-1234e-2"), Dec4{"-12.34"});
+}
+
+TEST(Decimal64Exponent, RoundDefault) {
+    EXPECT_EQ(Dec4::FromStringPermissive("1.23456e1"), Dec4{"12.3456"});
+    EXPECT_EQ(Dec4::FromStringPermissive("-1.2345678e1"), Dec4{"-12.3457"});
+    EXPECT_EQ(Dec4::FromStringPermissive("0.2345678e1"), Dec4{"2.3457"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.34e-3"), Dec4{"0.0013"});
+    EXPECT_EQ(Dec4::FromStringPermissive("12e-5"), Dec4{"0.0001"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1e-1000"), Dec4{0});
+    EXPECT_EQ(Dec4::FromStringPermissive("0.00001e1"), Dec4{"0.0001"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.00000000000000000000000000000000e2"), Dec4{"100"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.00000000000000000000000000000000e-2"), Dec4{"0.01"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.00000000000000000000000000000001e2"), Dec4{"100"});
+    EXPECT_EQ(Dec4::FromStringPermissive("0.0123456789123456789123456789e1"), Dec4{"0.1235"});
+    EXPECT_EQ(Dec4::FromStringPermissive("0.0123456789123456789123456789e-1"), Dec4{"0.0012"});
+}
+
+TEST(Decimal64Exponent, RoundUp) {
+    using Up = decimal64::Decimal<4, decimal64::RoundUpRoundPolicy>;
+    EXPECT_EQ(Up::FromStringPermissive("0.00000000000000002e1"), Up{"0.0001"});
+    EXPECT_EQ(Up::FromStringPermissive("0.0000000000000000002e17"), Up{"0"});
+    EXPECT_EQ(Up::FromStringPermissive("0.00000000000000002e17"), Up{"2"});
+    EXPECT_EQ(Up::FromStringPermissive("3.999999e2"), Up{"399.9999"});
+    EXPECT_EQ(Up::FromStringPermissive("3.9999999e2"), Up{"400"});
+    EXPECT_EQ(Up::FromStringPermissive("3.9999999e-2"), Up{"0.04"});
+}
+
+TEST(Decimal64Exponent, Zero) {
+    // kSign->kLeadingZeros->kExpSign->kExpDigits->kEnd
+    EXPECT_EQ(Dec4::FromStringPermissive("0e1"), Dec4(0));
+
+    // kSign->kLeadingZeros->kExpSign->kExpFirstDigit->kExpDigits->kEnd
+    EXPECT_EQ(Dec4::FromStringPermissive("0e+1"), Dec4(0));
+
+    // kSign->kLeadingZeros->kExpSign->kExpDigits->kExpDigits->kEnd
+    EXPECT_EQ(Dec4::FromStringPermissive("0e12"), Dec4(0));
+
+    // kSign->kLeadingZeros->kExpSign->kExpFirstDigit->kExpDigits->kEnd
+    EXPECT_EQ(Dec4::FromStringPermissive("0e-3"), Dec4(0));
+}
+
+namespace {
+std::optional<decimal64::impl::ParseErrorCode>
+ParseError(std::string input, std::initializer_list<decimal64::impl::ParseOptions> options) {
+    return decimal64::impl::Parse<4, decimal64::DefRoundPolicy>(
+               decimal64::impl::StringCharSequence(std::string_view{input}), options
+    )
+        .error;
+};
+
+const std::initializer_list<decimal64::impl::ParseOptions> OPTIONS = {
+    decimal64::impl::ParseOptions::kAllowSpaces,
+    decimal64::impl::ParseOptions::kAllowBoundaryDot,
+    decimal64::impl::ParseOptions::kAllowExponent,
+    decimal64::impl::ParseOptions::kAllowRounding,
+};
+}  // namespace
+
+TEST(Decimal64Exponent, Errors) {
+    EXPECT_EQ(ParseError("1e1000", OPTIONS), decimal64::impl::ParseErrorCode::kOverflow);
+    // kSign->kLeadingZeros->kExpSign
+    EXPECT_EQ(ParseError("0e", OPTIONS), decimal64::impl::ParseErrorCode::kNoExponentDigits);
+    // kSign->kBeforeDec->kExpSign
+    EXPECT_EQ(ParseError("1e", OPTIONS), decimal64::impl::ParseErrorCode::kNoExponentDigits);
+    // kSign->kLeadingZeros->kAfterDec->kExpSign
+    EXPECT_EQ(ParseError("0.1e", OPTIONS), decimal64::impl::ParseErrorCode::kNoExponentDigits);
+    // kSign->kLeadingZeros->kExpSign->kExpFirstDigit
+    EXPECT_EQ(ParseError("0e+", OPTIONS), decimal64::impl::ParseErrorCode::kNoExponentDigits);
+    // kSign->kLeadingZeros->kExpSign->kExpFirstDigit
+    EXPECT_EQ(ParseError("0e-", OPTIONS), decimal64::impl::ParseErrorCode::kNoExponentDigits);
+
+    EXPECT_EQ(
+        ParseError(
+            "1e-10000",
+            {decimal64::impl::ParseOptions::kAllowSpaces,
+             decimal64::impl::ParseOptions::kAllowBoundaryDot,
+             decimal64::impl::ParseOptions::kAllowExponent}
+        ),
+        decimal64::impl::ParseErrorCode::kRounding
+    );
+
+    EXPECT_EQ(
+        ParseError(
+            "123e4",
+            {
+                decimal64::impl::ParseOptions::kAllowSpaces,
+                decimal64::impl::ParseOptions::kAllowBoundaryDot,
+            }
+        ),
+        decimal64::impl::ParseErrorCode::kExponentNotAllowed
+    );
+    EXPECT_THROW(Dec4::FromStringPermissive("1.2e3e4"), decimal64::ParseError);
+}
+
+TEST(Decimal64Exponent, DotCases) {
+    EXPECT_THROW(Dec4::FromStringPermissive(".e-2"), decimal64::ParseError);
+    EXPECT_EQ(Dec4::FromStringPermissive(".2e1"), Dec4{"2"});
+    EXPECT_EQ(Dec4::FromStringPermissive("1.e-2"), Dec4{"0.01"});
+}
+
+TEST(Decimal64Exponent, MaxSize) {
+    EXPECT_EQ(Dec4::FromStringPermissive("0.00000000000000002e20"), Dec4{"2000"});
+    EXPECT_EQ(Dec4::FromStringPermissive("0.0000000000000000002e17"), Dec4{0});
+    EXPECT_EQ(
+        ParseError("10000000000000000e-19", OPTIONS), decimal64::impl::ParseErrorCode::kOverflow
+    );  // limitation of the current implementation. Truth result is 0.001
+    EXPECT_EQ(
+        ParseError("-10000000000000000e-19", OPTIONS), decimal64::impl::ParseErrorCode::kOverflow
+    );  // limitation of the current implementation. Truth result is -0.001
+}
+
 USERVER_NAMESPACE_END
diff --git a/universal/src/formats/common/member_access_test.hpp b/universal/src/formats/common/member_access_test.hpp
index 0c0e485ea38d..6a63ae41a589 100644
--- a/universal/src/formats/common/member_access_test.hpp
+++ b/universal/src/formats/common/member_access_test.hpp
@@ -12,45 +12,45 @@ TYPED_TEST_SUITE_P(MemberAccess);
 TYPED_TEST_P(MemberAccess, ChildBySquareBrackets) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    EXPECT_FALSE(this->doc_["key1"].IsMissing());
-    EXPECT_EQ(this->doc_["key1"], ValueBuilder(1).ExtractValue());
+    EXPECT_FALSE(this->doc["key1"].IsMissing());
+    EXPECT_EQ(this->doc["key1"], ValueBuilder(1).ExtractValue());
 }
 
 TYPED_TEST_P(MemberAccess, ChildBySquareBracketsTwice) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    EXPECT_FALSE(this->doc_["key3"]["sub"].IsMissing());
-    EXPECT_EQ(this->doc_["key3"]["sub"], ValueBuilder(-1).ExtractValue());
+    EXPECT_FALSE(this->doc["key3"]["sub"].IsMissing());
+    EXPECT_EQ(this->doc["key3"]["sub"], ValueBuilder(-1).ExtractValue());
 }
 
 TYPED_TEST_P(MemberAccess, ChildBySquareBracketsMissing) {
     using MemberMissingException = typename TestFixture::MemberMissingException;
 
-    EXPECT_NO_THROW(this->doc_["key_missing"]);
-    EXPECT_EQ(this->doc_["key_missing"].GetPath(), "key_missing");
-    EXPECT_TRUE(this->doc_["key_missing"].IsMissing());
-    EXPECT_FALSE(this->doc_["key_missing"].IsNull());
+    EXPECT_NO_THROW(this->doc["key_missing"]);
+    EXPECT_EQ(this->doc["key_missing"].GetPath(), "key_missing");
+    EXPECT_TRUE(this->doc["key_missing"].IsMissing());
+    EXPECT_FALSE(this->doc["key_missing"].IsNull());
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key_missing"].template As<bool>(), MemberMissingException);
+    EXPECT_THROW(this->doc["key_missing"].template As<bool>(), MemberMissingException);
 }
 
 TYPED_TEST_P(MemberAccess, ChildBySquareBracketsMissingTwice) {
     using MemberMissingException = typename TestFixture::MemberMissingException;
 
-    EXPECT_NO_THROW(this->doc_["key_missing"]["sub"]);
-    EXPECT_EQ(this->doc_["key_missing"]["sub"].GetPath(), "key_missing.sub");
-    EXPECT_TRUE(this->doc_["key_missing"]["sub"].IsMissing());
-    EXPECT_FALSE(this->doc_["key_missing"]["sub"].IsNull());
+    EXPECT_NO_THROW(this->doc["key_missing"]["sub"]);
+    EXPECT_EQ(this->doc["key_missing"]["sub"].GetPath(), "key_missing.sub");
+    EXPECT_TRUE(this->doc["key_missing"]["sub"].IsMissing());
+    EXPECT_FALSE(this->doc["key_missing"]["sub"].IsNull());
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key_missing"]["sub"].template As<bool>(), MemberMissingException);
+    EXPECT_THROW(this->doc["key_missing"]["sub"].template As<bool>(), MemberMissingException);
 }
 
 TYPED_TEST_P(MemberAccess, ChildBySquareBracketsArray) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    EXPECT_EQ(this->doc_["key4"][1], ValueBuilder(2).ExtractValue());
+    EXPECT_EQ(this->doc["key4"][1], ValueBuilder(2).ExtractValue());
 }
 
 TYPED_TEST_P(MemberAccess, ChildBySquareBracketsBounds) {
@@ -58,18 +58,18 @@ TYPED_TEST_P(MemberAccess, ChildBySquareBracketsBounds) {
 
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key4"][9], OutOfBoundsException);
+    EXPECT_THROW(this->doc["key4"][9], OutOfBoundsException);
 }
 
 TYPED_TEST_P(MemberAccess, IterateMemberNames) {
     using TypeMismatchException = typename TestFixture::TypeMismatchException;
 
-    EXPECT_TRUE(this->doc_.IsObject());
+    EXPECT_TRUE(this->doc.IsObject());
     size_t ind = 1;
     std::unordered_set<std::string> all_keys;
-    for (auto it = this->doc_.begin(); it != this->doc_.end(); ++it, ++ind) {
+    for (auto it = this->doc.begin(); it != this->doc.end(); ++it, ++ind) {
         const auto key = it.GetName();
-        EXPECT_EQ(this->doc_[key], *it) << "Failed for key " << key;
+        EXPECT_EQ(this->doc[key], *it) << "Failed for key " << key;
         EXPECT_TRUE(all_keys.insert(key).second) << "Already met key " << key;
         // possible false positive because of conditional in catch?
         // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
@@ -81,8 +81,8 @@ TYPED_TEST_P(MemberAccess, Items) {
     using formats::common::Items;
     size_t ind = 1;
     std::unordered_set<std::string> all_keys;
-    for (const auto& [key, value] : Items(this->doc_)) {
-        EXPECT_EQ(this->doc_[key], value) << "Failed for key " << key;
+    for (const auto& [key, value] : Items(this->doc)) {
+        EXPECT_EQ(this->doc[key], value) << "Failed for key " << key;
         EXPECT_TRUE(all_keys.insert(key).second) << "Already met key " << key;
         ++ind;
     }
@@ -93,7 +93,7 @@ TYPED_TEST_P(MemberAccess, Items) {
 TYPED_TEST_P(MemberAccess, IterateAndCheckValues) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    for (auto it = this->doc_.begin(); it != this->doc_.end(); ++it) {
+    for (auto it = this->doc.begin(); it != this->doc.end(); ++it) {
         if (it.GetName() == "key1") {
             EXPECT_EQ(*it, ValueBuilder(1).ExtractValue());
         } else if (it.GetName() == "key2") {
@@ -110,7 +110,7 @@ TYPED_TEST_P(MemberAccess, IterateAndCheckValues) {
 TYPED_TEST_P(MemberAccess, IterateMembersAndCheckKey4) {
     using OutOfBoundsException = typename TestFixture::OutOfBoundsException;
 
-    for (auto it = this->doc_.begin(); it != this->doc_.end(); ++it) {
+    for (auto it = this->doc.begin(); it != this->doc.end(); ++it) {
         if (it.GetName() == "key4") {
             // possible false positive because of conditional in catch?
             // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
@@ -122,7 +122,7 @@ TYPED_TEST_P(MemberAccess, IterateMembersAndCheckKey4) {
 TYPED_TEST_P(MemberAccess, IterateMembersAndCheckKey4Index) {
     using TypeMismatchException = typename TestFixture::TypeMismatchException;
 
-    for (auto it = this->doc_.begin(); it != this->doc_.end(); ++it) {
+    for (auto it = this->doc.begin(); it != this->doc.end(); ++it) {
         if (it.GetName() == "key4") {
             EXPECT_TRUE(it->IsArray());
 
@@ -146,7 +146,7 @@ TYPED_TEST_P(MemberAccess, IterateMembersAndCheckKey4Index) {
 TYPED_TEST_P(MemberAccess, IterateMembersAndCheckKey4IndexPostincrement) {
     using TypeMismatchException = typename TestFixture::TypeMismatchException;
 
-    for (auto it = this->doc_.begin(); it != this->doc_.end(); it++) {
+    for (auto it = this->doc.begin(); it != this->doc.end(); it++) {
         if (it.GetName() == "key4") {
             EXPECT_TRUE(it->IsArray());
 
@@ -168,17 +168,17 @@ TYPED_TEST_P(MemberAccess, IterateMembersAndCheckKey4IndexPostincrement) {
 }
 
 TYPED_TEST_P(MemberAccess, Algorithms) {
-    auto it = std::find_if(this->doc_.begin(), this->doc_.end(), [](const auto& v) {
+    auto it = std::find_if(this->doc.begin(), this->doc.end(), [](const auto& v) {
         return v.IsString() && v.template As<std::string>() == "val";
     });
-    ASSERT_NE(it, this->doc_.end()) << "failed to find array";
+    ASSERT_NE(it, this->doc.end()) << "failed to find array";
     EXPECT_EQ(it->template As<std::string>(), "val");
     EXPECT_EQ(it.GetName(), "key2");
 
     auto it_new = it;
     ++it_new;
     EXPECT_NE(it_new, it);
-    if (this->doc_.end() != it_new) {
+    if (this->doc.end() != it_new) {
         EXPECT_NE(it_new.GetName(), it.GetName());
     }
 
@@ -186,28 +186,28 @@ TYPED_TEST_P(MemberAccess, Algorithms) {
 
     ++it;
     EXPECT_EQ(it_new, it);
-    if (this->doc_.end() != it_new) {
+    if (this->doc.end() != it_new) {
         EXPECT_EQ(it_new.GetName(), it.GetName());
     }
 }
 
 TYPED_TEST_P(MemberAccess, CheckPrimitiveTypes) {
-    EXPECT_TRUE(this->doc_["key1"].IsUInt64());
-    EXPECT_EQ(this->doc_["key1"].template As<uint64_t>(), 1);
+    EXPECT_TRUE(this->doc["key1"].IsUInt64());
+    EXPECT_EQ(this->doc["key1"].template As<uint64_t>(), 1);
 
-    EXPECT_TRUE(this->doc_["key2"].IsString());
-    EXPECT_EQ(this->doc_["key2"].template As<std::string>(), "val");
+    EXPECT_TRUE(this->doc["key2"].IsString());
+    EXPECT_EQ(this->doc["key2"].template As<std::string>(), "val");
 
-    EXPECT_TRUE(this->doc_["key3"].IsObject());
-    EXPECT_TRUE(this->doc_["key3"]["sub"].IsInt64());
-    EXPECT_EQ(this->doc_["key3"]["sub"].template As<int>(), -1);
+    EXPECT_TRUE(this->doc["key3"].IsObject());
+    EXPECT_TRUE(this->doc["key3"]["sub"].IsInt64());
+    EXPECT_EQ(this->doc["key3"]["sub"].template As<int>(), -1);
 
-    EXPECT_TRUE(this->doc_["key4"].IsArray());
-    EXPECT_TRUE(this->doc_["key4"][0].IsUInt64());
-    EXPECT_EQ(this->doc_["key4"][0].template As<uint64_t>(), 1);
+    EXPECT_TRUE(this->doc["key4"].IsArray());
+    EXPECT_TRUE(this->doc["key4"][0].IsUInt64());
+    EXPECT_EQ(this->doc["key4"][0].template As<uint64_t>(), 1);
 
-    EXPECT_TRUE(this->doc_["key5"].IsDouble());
-    EXPECT_DOUBLE_EQ(this->doc_["key5"].template As<double>(), 10.5);
+    EXPECT_TRUE(this->doc["key5"].IsDouble());
+    EXPECT_DOUBLE_EQ(this->doc["key5"].template As<double>(), 10.5);
 }
 
 TYPED_TEST_P(MemberAccess, CheckPrimitiveTypeExceptions) {
@@ -215,43 +215,43 @@ TYPED_TEST_P(MemberAccess, CheckPrimitiveTypeExceptions) {
 
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key1"].template As<bool>(), TypeMismatchException);
-    EXPECT_NO_THROW(this->doc_["key1"].template As<double>());
+    EXPECT_THROW(this->doc["key1"].template As<bool>(), TypeMismatchException);
+    EXPECT_NO_THROW(this->doc["key1"].template As<double>());
 
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key2"].template As<bool>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key2"].template As<bool>(), TypeMismatchException);
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key2"].template As<double>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key2"].template As<double>(), TypeMismatchException);
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key2"].template As<uint64_t>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key2"].template As<uint64_t>(), TypeMismatchException);
 
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key5"].template As<bool>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key5"].template As<bool>(), TypeMismatchException);
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key5"].template As<uint64_t>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key5"].template As<uint64_t>(), TypeMismatchException);
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key5"].template As<int>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key5"].template As<int>(), TypeMismatchException);
 
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key6"].template As<double>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key6"].template As<double>(), TypeMismatchException);
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key6"].template As<uint64_t>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key6"].template As<uint64_t>(), TypeMismatchException);
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->doc_["key6"].template As<int>(), TypeMismatchException);
+    EXPECT_THROW(this->doc["key6"].template As<int>(), TypeMismatchException);
 }
 
 TYPED_TEST_P(MemberAccess, MemberPaths) {
     using Value = typename TestFixture::Value;
 
     // copy/move constructor behaves as if it copied references not values
-    const Value js_copy = this->doc_;
+    const Value js_copy = this->doc;
     // check pointer equality of native objects
-    EXPECT_TRUE(js_copy.DebugIsReferencingSameMemory(this->doc_));
+    EXPECT_TRUE(js_copy.DebugIsReferencingSameMemory(this->doc));
 
-    EXPECT_EQ(this->doc_.GetPath(), "/");
-    EXPECT_EQ(this->doc_["key1"].GetPath(), "key1");
-    EXPECT_EQ(this->doc_["key3"]["sub"].GetPath(), "key3.sub");
-    EXPECT_EQ(this->doc_["key4"][2].GetPath(), "key4[2]");
+    EXPECT_EQ(this->doc.GetPath(), "/");
+    EXPECT_EQ(this->doc["key1"].GetPath(), "key1");
+    EXPECT_EQ(this->doc["key3"]["sub"].GetPath(), "key3.sub");
+    EXPECT_EQ(this->doc["key4"][2].GetPath(), "key4[2]");
 
     EXPECT_EQ(js_copy.GetPath(), "/");
     EXPECT_EQ(js_copy["key1"].GetPath(), "key1");
@@ -260,37 +260,37 @@ TYPED_TEST_P(MemberAccess, MemberPaths) {
 }
 
 TYPED_TEST_P(MemberAccess, MemberPathsByIterator) {
-    EXPECT_EQ(this->doc_["key3"].begin()->GetPath(), "key3.sub");
+    EXPECT_EQ(this->doc["key3"].begin()->GetPath(), "key3.sub");
 
-    auto arr_it = this->doc_["key4"].begin();
+    auto arr_it = this->doc["key4"].begin();
     EXPECT_EQ((arr_it++)->GetPath(), "key4[0]");
     EXPECT_EQ((++arr_it)->GetPath(), "key4[2]");
 }
 
 TYPED_TEST_P(MemberAccess, MemberEmpty) {
-    EXPECT_FALSE(this->doc_.IsEmpty()) << "Map is not empty when it should be";
-    EXPECT_FALSE(this->doc_["key4"].IsEmpty()) << "Array is not empty when it should be";
+    EXPECT_FALSE(this->doc.IsEmpty()) << "Map is not empty when it should be";
+    EXPECT_FALSE(this->doc["key4"].IsEmpty()) << "Array is not empty when it should be";
 }
 
 TYPED_TEST_P(MemberAccess, MemberCount) {
-    EXPECT_EQ(this->doc_.GetSize(), 6) << "Incorrect size of a map";
-    EXPECT_EQ(this->doc_["key4"].GetSize(), 3) << "Incorrect size of an array";
+    EXPECT_EQ(this->doc.GetSize(), 6) << "Incorrect size of a map";
+    EXPECT_EQ(this->doc["key4"].GetSize(), 3) << "Incorrect size of an array";
 }
 
 TYPED_TEST_P(MemberAccess, HasMember) {
-    EXPECT_TRUE(this->doc_.HasMember("key1"));
-    EXPECT_FALSE(this->doc_.HasMember("keyX"));
-    EXPECT_FALSE(this->doc_["keyX"].HasMember("key1"));
+    EXPECT_TRUE(this->doc.HasMember("key1"));
+    EXPECT_FALSE(this->doc.HasMember("keyX"));
+    EXPECT_FALSE(this->doc["keyX"].HasMember("key1"));
 }
 
 TYPED_TEST_P(MemberAccess, CopyMoveSubobject) {
     using Value = typename TestFixture::Value;
 
     // copy/move constructor behaves as if it copied references from subobjects
-    const Value v(this->doc_["key3"]);
+    const Value v(this->doc["key3"]);
 
-    EXPECT_EQ(v, this->doc_["key3"]);
-    EXPECT_TRUE(v.DebugIsReferencingSameMemory(this->doc_["key3"]));
+    EXPECT_EQ(v, this->doc["key3"]);
+    EXPECT_TRUE(v.DebugIsReferencingSameMemory(this->doc["key3"]));
 }
 
 TYPED_TEST_P(MemberAccess, IteratorOnNull) {
@@ -314,12 +314,12 @@ TYPED_TEST_P(MemberAccess, CloneValues) {
     using Value = typename TestFixture::Value;
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    const Value v = this->doc_.Clone();
-    EXPECT_EQ(v, this->doc_);
+    const Value v = this->doc.Clone();
+    EXPECT_EQ(v, this->doc);
 
-    this->doc_ = ValueBuilder(-1).ExtractValue();
+    this->doc = ValueBuilder(-1).ExtractValue();
 
-    EXPECT_FALSE(v.DebugIsReferencingSameMemory(this->doc_));
+    EXPECT_FALSE(v.DebugIsReferencingSameMemory(this->doc));
 }
 
 TYPED_TEST_P(MemberAccess, CreateEmptyAndAccess) {
@@ -343,35 +343,35 @@ TYPED_TEST_P(MemberAccess, Subfield) {
 
     ValueBuilder body_builder(Type::kObject);
 
-    const Value old = this->doc_["key1"].Clone();
-    EXPECT_EQ(old, this->doc_["key1"]);
+    const Value old = this->doc["key1"].Clone();
+    EXPECT_EQ(old, this->doc["key1"]);
 
-    body_builder["key1"] = this->doc_["key1"];
+    body_builder["key1"] = this->doc["key1"];
 
-    EXPECT_EQ(old, this->doc_["key1"]);
+    EXPECT_EQ(old, this->doc["key1"]);
 }
 
 TYPED_TEST_P(MemberAccess, ValueAssignment) {
     using Value = typename TestFixture::Value;
 
     Value v;
-    v = this->doc_["key4"];
+    v = this->doc["key4"];
     EXPECT_TRUE(v.IsArray());
 
-    v = this->doc_["key1"];
+    v = this->doc["key1"];
     EXPECT_FALSE(v.IsArray());
-    EXPECT_TRUE(this->doc_["key4"].IsArray());
+    EXPECT_TRUE(this->doc["key4"].IsArray());
 
     Value v2;
     v2 = v;
-    v = this->doc_["key4"];
+    v = this->doc["key4"];
     EXPECT_TRUE(v.IsArray());
     EXPECT_FALSE(v2.IsArray());
 
     Value v3;
-    v = this->doc_["key1"];
+    v = this->doc["key1"];
     v3 = std::move(v);
-    v = this->doc_["key4"];
+    v = this->doc["key4"];
     EXPECT_TRUE(v.IsArray());
     EXPECT_FALSE(v3.IsArray());
 }
@@ -411,21 +411,21 @@ TYPED_TEST_P(MemberAccess, AsWithDefault) {
     using Value = typename TestFixture::Value;
 
     EXPECT_EQ(Value()["missing"].template As<int>(42), 42);
-    EXPECT_EQ(this->doc_["key4"][1].template As<int>(42), 2);
+    EXPECT_EQ(this->doc["key4"][1].template As<int>(42), 2);
 }
 
 TYPED_TEST_P(MemberAccess, RootAndPathOfCloned) {
-    EXPECT_TRUE(this->doc_.Clone().IsRoot());
-    EXPECT_TRUE(this->doc_.IsRoot());
+    EXPECT_TRUE(this->doc.Clone().IsRoot());
+    EXPECT_TRUE(this->doc.IsRoot());
 
-    EXPECT_TRUE(this->doc_["key4"].Clone().IsRoot());
-    EXPECT_FALSE(this->doc_["key4"].IsRoot());
+    EXPECT_TRUE(this->doc["key4"].Clone().IsRoot());
+    EXPECT_FALSE(this->doc["key4"].IsRoot());
 
-    EXPECT_EQ(this->doc_.Clone().GetPath(), this->doc_.GetPath());
-    EXPECT_EQ(this->doc_.Clone().GetPath(), "/");
+    EXPECT_EQ(this->doc.Clone().GetPath(), this->doc.GetPath());
+    EXPECT_EQ(this->doc.Clone().GetPath(), "/");
 
-    EXPECT_EQ(this->doc_["key4"].Clone().GetPath(), "/");
-    EXPECT_EQ(this->doc_["key4"].GetPath(), "key4");
+    EXPECT_EQ(this->doc["key4"].Clone().GetPath(), "/");
+    EXPECT_EQ(this->doc["key4"].GetPath(), "key4");
 }
 
 REGISTER_TYPED_TEST_SUITE_P(
diff --git a/universal/src/formats/common/member_modify_test.hpp b/universal/src/formats/common/member_modify_test.hpp
index 77784acabe5c..9ad5df0c4305 100644
--- a/universal/src/formats/common/member_modify_test.hpp
+++ b/universal/src/formats/common/member_modify_test.hpp
@@ -13,27 +13,27 @@ TYPED_TEST_P(MemberModify, BuildNewValueEveryTime) {
 }
 
 TYPED_TEST_P(MemberModify, CheckPrimitiveTypesChange) {
-    this->builder_["key1"] = -100;
+    this->builder["key1"] = -100;
     EXPECT_EQ(this->GetBuiltValue()["key1"].template As<int>(), -100);
 
-    this->builder_["key1"] = "100";
+    this->builder["key1"] = "100";
     EXPECT_EQ(this->GetBuiltValue()["key1"].template As<std::string>(), "100");
-    this->builder_["key1"] = true;
+    this->builder["key1"] = true;
     EXPECT_TRUE(this->GetBuiltValue()["key1"].template As<bool>());
 }
 
 TYPED_TEST_P(MemberModify, CheckNestedTypesChange) {
-    this->builder_["key3"]["sub"] = false;
+    this->builder["key3"]["sub"] = false;
     EXPECT_FALSE(this->GetBuiltValue()["key3"]["sub"].template As<bool>());
-    this->builder_["key3"] = -100;
+    this->builder["key3"] = -100;
     EXPECT_EQ(this->GetBuiltValue()["key3"].template As<int>(), -100);
-    this->builder_["key3"] = this->FromString("{\"sub\":-1}");
+    this->builder["key3"] = this->FromString("{\"sub\":-1}");
     EXPECT_EQ(this->GetBuiltValue()["key3"]["sub"].template As<int>(), -1);
 }
 
 TYPED_TEST_P(MemberModify, CheckNestedArrayChange) {
-    this->builder_["key4"][1] = 10;
-    this->builder_["key4"][2] = 100;
+    this->builder["key4"][1] = 10;
+    this->builder["key4"][2] = 100;
     EXPECT_EQ(this->GetBuiltValue()["key4"][0].template As<int>(), 1);
     EXPECT_EQ(this->GetBuiltValue()["key4"][1].template As<int>(), 10);
     EXPECT_EQ(this->GetBuiltValue()["key4"][2].template As<int>(), 100);
@@ -42,16 +42,16 @@ TYPED_TEST_P(MemberModify, CheckNestedArrayChange) {
 TYPED_TEST_P(MemberModify, ArrayResize) {
     using OutOfBoundsException = typename TestFixture::OutOfBoundsException;
 
-    this->builder_["key4"].Resize(4);
+    this->builder["key4"].Resize(4);
     EXPECT_FALSE(this->GetBuiltValue()["key4"].IsEmpty());
     EXPECT_EQ(this->GetBuiltValue()["key4"].GetSize(), 4);
 
-    this->builder_["key4"][3] = 4;
+    this->builder["key4"][3] = 4;
     for (size_t i = 0; i < 4; ++i) {
         EXPECT_EQ(this->GetBuiltValue()["key4"][i].template As<int>(), i + 1);
     }
 
-    this->builder_["key4"].Resize(1);
+    this->builder["key4"].Resize(1);
 
     EXPECT_FALSE(this->GetBuiltValue()["key4"].IsEmpty());
     EXPECT_EQ(this->GetBuiltValue()["key4"].GetSize(), 1);
@@ -65,15 +65,15 @@ TYPED_TEST_P(MemberModify, ArrayFromNull) {
     using OutOfBoundsException = typename TestFixture::OutOfBoundsException;
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    this->builder_ = ValueBuilder();
+    this->builder = ValueBuilder();
     EXPECT_TRUE(this->GetBuiltValue().IsEmpty());
     EXPECT_EQ(this->GetBuiltValue().GetSize(), 0);
 
-    this->builder_.Resize(1);
+    this->builder.Resize(1);
     EXPECT_FALSE(this->GetBuiltValue().IsEmpty());
     EXPECT_EQ(this->GetBuiltValue().GetSize(), 1);
 
-    this->builder_[0] = 0;
+    this->builder[0] = 0;
     EXPECT_EQ(this->GetBuiltValue()[0].template As<int>(), 0);
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
@@ -84,11 +84,11 @@ TYPED_TEST_P(MemberModify, ArrayPushBack) {
     using Type = typename TestFixture::Type;
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    this->builder_ = ValueBuilder(Type::kArray);
+    this->builder = ValueBuilder(Type::kArray);
 
     const auto size = 5;
     for (auto i = 0; i < size; ++i) {
-        this->builder_.PushBack(i);
+        this->builder.PushBack(i);
     }
     EXPECT_EQ(this->GetBuiltValue().IsEmpty(), !size);
     EXPECT_EQ(this->GetBuiltValue().GetSize(), size);
@@ -99,7 +99,7 @@ TYPED_TEST_P(MemberModify, ArrayPushBack) {
 }
 
 TYPED_TEST_P(MemberModify, PushBackFromExisting) {
-    this->builder_["key4"].PushBack(this->builder_["key1"]);
+    this->builder["key4"].PushBack(this->builder["key1"]);
     EXPECT_FALSE(this->GetBuiltValue()["key4"].IsEmpty());
     EXPECT_EQ(this->GetBuiltValue()["key4"].GetSize(), 4);
     EXPECT_EQ(this->GetBuiltValue()["key4"][3].template As<int>(), 1);
@@ -107,7 +107,7 @@ TYPED_TEST_P(MemberModify, PushBackFromExisting) {
 }
 
 TYPED_TEST_P(MemberModify, PushBackFromBefore) {
-    this->builder_["key4"].PushBack(this->builder_["key4"][0]);
+    this->builder["key4"].PushBack(this->builder["key4"][0]);
     EXPECT_FALSE(this->GetBuiltValue()["key4"].IsEmpty());
     EXPECT_EQ(this->GetBuiltValue()["key4"].GetSize(), 4);
     EXPECT_EQ(this->GetBuiltValue()["key4"][0].template As<int>(), 1);
@@ -115,7 +115,7 @@ TYPED_TEST_P(MemberModify, PushBackFromBefore) {
 }
 
 TYPED_TEST_P(MemberModify, PushBackFromIterator) {
-    this->builder_["key4"].PushBack(typename TestFixture::ValueBuilder{*this->builder_["key4"].begin()});
+    this->builder["key4"].PushBack(typename TestFixture::ValueBuilder{*this->builder["key4"].begin()});
     EXPECT_FALSE(this->GetBuiltValue()["key4"].IsEmpty());
     EXPECT_EQ(this->GetBuiltValue()["key4"].GetSize(), 4);
     EXPECT_EQ(this->GetBuiltValue()["key4"][0].template As<int>(), 1);
@@ -123,8 +123,8 @@ TYPED_TEST_P(MemberModify, PushBackFromIterator) {
 }
 
 TYPED_TEST_P(MemberModify, CopyExistingMember) {
-    const auto key1 = this->builder_["key1"];
-    this->builder_["key1_copy"] = key1;
+    const auto key1 = this->builder["key1"];
+    this->builder["key1_copy"] = key1;
     EXPECT_TRUE(this->GetBuiltValue().HasMember("key1"));
     EXPECT_TRUE(this->GetBuiltValue().HasMember("key1_copy"));
     EXPECT_EQ(this->GetBuiltValue()["key1"].template As<int>(), 1);
@@ -132,11 +132,11 @@ TYPED_TEST_P(MemberModify, CopyExistingMember) {
 }
 
 TYPED_TEST_P(MemberModify, CopyExistingMemberByIt) {
-    auto it = this->builder_.begin();
-    while (it != this->builder_.end() && it.GetName() != "key1") ++it;
-    ASSERT_NE(this->builder_.end(), it);
+    auto it = this->builder.begin();
+    while (it != this->builder.end() && it.GetName() != "key1") ++it;
+    ASSERT_NE(this->builder.end(), it);
 
-    this->builder_["key1_copy"] = *it;
+    this->builder["key1_copy"] = *it;
     EXPECT_TRUE(this->GetBuiltValue().HasMember("key1"));
     EXPECT_TRUE(this->GetBuiltValue().HasMember("key1_copy"));
     EXPECT_EQ(this->GetBuiltValue()["key1"].template As<int>(), 1);
@@ -154,18 +154,18 @@ TYPED_TEST_P(MemberModify, CopyExistingMemberByIt) {
 // }
 
 TYPED_TEST_P(MemberModify, ContainerTypeChangeToScalar) {
-    auto builder = this->builder_["key4"];  // NB: not a copy
+    auto builder = this->builder["key4"];  // NB: not a copy
     EXPECT_NO_THROW(builder.PushBack(0));
-    this->builder_["key4"] = 0;
+    this->builder["key4"] = 0;
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
     EXPECT_THROW(builder.PushBack(0), typename TestFixture::TypeMismatchException);
 }
 
 TYPED_TEST_P(MemberModify, ContainerTypeChangeArrToObj) {
-    auto builder = this->builder_["key4"];  // NB: not a copy
+    auto builder = this->builder["key4"];  // NB: not a copy
     EXPECT_NO_THROW(builder.PushBack(0));
-    this->builder_["key4"] = typename TestFixture::ValueBuilder{formats::common::Type::kObject};
+    this->builder["key4"] = typename TestFixture::ValueBuilder{formats::common::Type::kObject};
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
     EXPECT_THROW(builder.PushBack(0), typename TestFixture::TypeMismatchException);
@@ -173,9 +173,9 @@ TYPED_TEST_P(MemberModify, ContainerTypeChangeArrToObj) {
 }
 
 TYPED_TEST_P(MemberModify, ContainerTypeChangeObjToArr) {
-    auto builder = this->builder_["key3"];  // NB: not a copy
+    auto builder = this->builder["key3"];  // NB: not a copy
     EXPECT_NO_THROW(builder["test"] = 0);
-    this->builder_["key3"] = typename TestFixture::ValueBuilder{formats::common::Type::kArray};
+    this->builder["key3"] = typename TestFixture::ValueBuilder{formats::common::Type::kArray};
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
     EXPECT_THROW(builder["test"] = 0, typename TestFixture::TypeMismatchException);
@@ -187,13 +187,13 @@ TYPED_TEST_P(MemberModify, PushBackWrongTypeThrows) {
 
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
-    EXPECT_THROW(this->builder_["key1"].PushBack(1), TypeMismatchException);
+    EXPECT_THROW(this->builder["key1"].PushBack(1), TypeMismatchException);
 }
 
 TYPED_TEST_P(MemberModify, ExtractFromSubBuilderThrows) {
     using Exception = typename TestFixture::Exception;
 
-    auto bld = this->builder_["key1"];
+    auto bld = this->builder["key1"];
     // possible false positive because of conditional in catch?
     // NOLINTNEXTLINE(misc-throw-by-value-catch-by-reference)
     EXPECT_THROW(bld.ExtractValue(), Exception);
@@ -204,8 +204,8 @@ TYPED_TEST_P(MemberModify, ObjectIteratorModify) {
     std::size_t sum = 0;
     {
         std::size_t size = 0;
-        auto it = this->builder_.begin();
-        for (; it != this->builder_.end(); ++it, ++size) {
+        auto it = this->builder.begin();
+        for (; it != this->builder.end(); ++it, ++size) {
             *it = offset + size;
             sum += offset + size;
         }
@@ -220,9 +220,9 @@ TYPED_TEST_P(MemberModify, ObjectIteratorModify) {
     }
 }
 
-TYPED_TEST_P(MemberModify, MemberEmpty) { EXPECT_FALSE(this->builder_.IsEmpty()); }
+TYPED_TEST_P(MemberModify, MemberEmpty) { EXPECT_FALSE(this->builder.IsEmpty()); }
 
-TYPED_TEST_P(MemberModify, MemberCount) { EXPECT_EQ(this->builder_.GetSize(), 5); }
+TYPED_TEST_P(MemberModify, MemberCount) { EXPECT_EQ(this->builder.GetSize(), 5); }
 
 TYPED_TEST_P(MemberModify, NonArrayThrowIsEmpty) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
@@ -247,39 +247,39 @@ TYPED_TEST_P(MemberModify, NonArrayThrowGetSize) {
 TYPED_TEST_P(MemberModify, ArrayIteratorRead) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    this->builder_ = ValueBuilder();
+    this->builder = ValueBuilder();
     const auto size = 10;
-    this->builder_.Resize(size);
+    this->builder.Resize(size);
 
     for (auto i = 0; i < size; ++i) {
-        this->builder_[i] = i;
+        this->builder[i] = i;
     }
 
     auto it = this->GetBuiltValue().begin();
     for (auto i = 0; i < size; ++i, ++it) {
         EXPECT_EQ(it->template As<int>(), i) << "Failed at index " << i;
     }
-    EXPECT_EQ(this->builder_.IsEmpty(), !size);
-    EXPECT_EQ(this->builder_.GetSize(), size);
+    EXPECT_EQ(this->builder.IsEmpty(), !size);
+    EXPECT_EQ(this->builder.GetSize(), size);
 }
 
 TYPED_TEST_P(MemberModify, ArrayIteratorModify) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    this->builder_ = ValueBuilder();
+    this->builder = ValueBuilder();
     const auto size = 10;
-    this->builder_.Resize(size);
+    this->builder.Resize(size);
 
     const size_t offset = 3;
     {
         // Cannot initialize values of array
         // with iterators (need to first set values with operator[])
         for (auto i = 0; i < size; ++i) {
-            this->builder_[i] = 0;
+            this->builder[i] = 0;
         }
 
-        auto it = this->builder_.begin();
-        for (auto i = offset; it != this->builder_.end(); ++it, ++i) {
+        auto it = this->builder.begin();
+        for (auto i = offset; it != this->builder.end(); ++it, ++i) {
             *it = i;
         }
     }
@@ -290,8 +290,8 @@ TYPED_TEST_P(MemberModify, ArrayIteratorModify) {
             EXPECT_EQ(it->template As<int>(), i + offset) << "Failed at index " << i;
         }
     }
-    EXPECT_EQ(this->builder_.IsEmpty(), !size);
-    EXPECT_EQ(this->builder_.GetSize(), size);
+    EXPECT_EQ(this->builder.IsEmpty(), !size);
+    EXPECT_EQ(this->builder.GetSize(), size);
 }
 
 TYPED_TEST_P(MemberModify, CreateSpecificType) {
@@ -331,7 +331,7 @@ TYPED_TEST_P(MemberModify, SubdocOutlivesRoot) {
 TYPED_TEST_P(MemberModify, MoveValueBuilder) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
-    ValueBuilder v = std::move(this->builder_);
+    ValueBuilder v = std::move(this->builder);
     EXPECT_FALSE(this->GetValue(v).IsNull());
     EXPECT_TRUE(this->GetBuiltValue().IsNull());
 }
@@ -340,7 +340,7 @@ TYPED_TEST_P(MemberModify, CheckSubobjectChange) {
     using ValueBuilder = typename TestFixture::ValueBuilder;
 
     ValueBuilder v = this->GetBuiltValue();
-    this->builder_["key4"] = v["key3"];
+    this->builder["key4"] = v["key3"];
     EXPECT_TRUE(this->GetBuiltValue()["key4"].HasMember("sub"));
     EXPECT_EQ(this->GetBuiltValue()["key4"]["sub"].template As<int>(), -1);
     EXPECT_TRUE(this->GetValue(v)["key3"].HasMember("sub"));
diff --git a/universal/src/formats/common/value_test.hpp b/universal/src/formats/common/value_test.hpp
index c7caef18561b..66d2bc4c8125 100644
--- a/universal/src/formats/common/value_test.hpp
+++ b/universal/src/formats/common/value_test.hpp
@@ -12,6 +12,7 @@
 #include <unordered_set>
 #include <vector>
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <boost/container/flat_map.hpp>
 #include <boost/container/flat_set.hpp>
@@ -39,6 +40,13 @@ template <class Value>
 inline TestType Parse(const Value& val, formats::parse::To<TestType>) {
     return TestType{val.template As<int>()};
 }
+
+struct KeyType {
+    std::string name;
+};
+
+inline bool operator==(const KeyType& lhs, const KeyType& rhs) { return lhs.name == rhs.name; }
+inline bool operator<(const KeyType& lhs, const KeyType& rhs) { return lhs.name < rhs.name; }
 }  // namespace testing_namespace
 
 namespace testing_namespace2 {
@@ -52,6 +60,10 @@ template <class Value>
 testing_namespace2::TestType Parse(const Value& val, To<testing_namespace2::TestType>) {
     return testing_namespace2::TestType{val.template As<int>()};
 }
+
+inline testing_namespace::KeyType Parse(std::string_view value, To<testing_namespace::KeyType>) {
+    return {std::string(value)};
+}
 }  // namespace formats::parse
 
 template <class T>
@@ -100,6 +112,12 @@ TYPED_TEST_P(Parsing, VectorVectorIntNull) {
     EXPECT_EQ(std::vector<std::vector<int>>{}, v);
 }
 
+TYPED_TEST_P(Parsing, MapWithCustomKey) {
+    auto value = this->FromString(R"({"foo": "bar"})");
+    auto v = value.template As<std::map<testing_namespace::KeyType, std::string>>();
+    EXPECT_THAT(v, testing::ElementsAre(testing::Pair(testing_namespace::KeyType{"foo"}, "bar")));
+}
+
 TYPED_TEST_P(Parsing, BoostContainerFlatSet) {
     auto value = this->FromString("[3,3,5,2,1,5,6,4]");
     auto v = value.template As<boost::container::flat_set<int>>();
@@ -337,6 +355,8 @@ REGISTER_TYPED_TEST_SUITE_P(
     VectorVectorInt,
     VectorVectorIntNull,
 
+    MapWithCustomKey,
+
     BoostContainerFlatSet,
     BoostContainerFlatMap,
 
diff --git a/universal/src/formats/json/impl/accept.hpp b/universal/src/formats/json/impl/accept.hpp
index 8695061be1a9..361389517e78 100644
--- a/universal/src/formats/json/impl/accept.hpp
+++ b/universal/src/formats/json/impl/accept.hpp
@@ -16,7 +16,7 @@ namespace formats::json {
 
 enum class ObjectProcessing { kNone, kInplaceSorting };
 
-template <ObjectProcessing kProcessing>
+template <ObjectProcessing Processing>
 struct ValueTypes {};
 
 template <>
@@ -45,14 +45,14 @@ struct SubRange {
     Iter end;
 };
 
-template <ObjectProcessing kProcessing>
+template <ObjectProcessing Processing>
 class StackCell final {
 public:
-    using Member = typename ValueTypes<kProcessing>::Member;
-    using MemberIterator = typename ValueTypes<kProcessing>::MemberIterator;
+    using Member = typename ValueTypes<Processing>::Member;
+    using MemberIterator = typename ValueTypes<Processing>::MemberIterator;
 
-    using Value = typename ValueTypes<kProcessing>::Value;
-    using ArrayIterator = typename ValueTypes<kProcessing>::ArrayIterator;
+    using Value = typename ValueTypes<Processing>::Value;
+    using ArrayIterator = typename ValueTypes<Processing>::ArrayIterator;
 
     StackCell(MemberIterator cur_it, MemberIterator end)
         : sub_range_(SubRange<MemberIterator>{cur_it, end}),
@@ -89,8 +89,8 @@ class StackCell final {
     std::size_t size_;
 };
 
-template <ObjectProcessing kProcessing>
-using Stack = boost::container::small_vector<StackCell<kProcessing>, 20>;
+template <ObjectProcessing Processing>
+using Stack = boost::container::small_vector<StackCell<Processing>, 20>;
 
 template <typename Handler, typename Cell>
 bool WriteEnd(Handler& handler, const Cell& cell) {
@@ -109,24 +109,24 @@ bool WriteEnd(Handler& handler, const Cell& cell) {
 
 void InplaceSortObjectChildren(impl::Value& value);
 
-template <ObjectProcessing kProcessing>
-void EmplaceObject(Stack<kProcessing>& stack, typename ValueTypes<kProcessing>::Value& value) {
-    if constexpr (kProcessing == ObjectProcessing::kInplaceSorting) {
+template <ObjectProcessing Processing>
+void EmplaceObject(Stack<Processing>& stack, typename ValueTypes<Processing>::Value& value) {
+    if constexpr (Processing == ObjectProcessing::kInplaceSorting) {
         InplaceSortObjectChildren(value);
     }
     stack.emplace_back(value.MemberBegin(), value.MemberEnd());
 }
 
-template <ObjectProcessing kProcessing>
-void EmplaceArray(Stack<kProcessing>& stack, typename ValueTypes<kProcessing>::Value& value) {
+template <ObjectProcessing Processing>
+void EmplaceArray(Stack<Processing>& stack, typename ValueTypes<Processing>::Value& value) {
     stack.emplace_back(value.Begin(), value.End());
 }
 
-template <ObjectProcessing kProcessing, typename Handler>
-bool WriteStartAndEnterValue(Stack<kProcessing>& stack, Handler& handler) {
-    using Value = typename ValueTypes<kProcessing>::Value;
-    using MemberIterator = typename ValueTypes<kProcessing>::MemberIterator;
-    using ArrayIterator = typename ValueTypes<kProcessing>::ArrayIterator;
+template <ObjectProcessing Processing, typename Handler>
+bool WriteStartAndEnterValue(Stack<Processing>& stack, Handler& handler) {
+    using Value = typename ValueTypes<Processing>::Value;
+    using MemberIterator = typename ValueTypes<Processing>::MemberIterator;
+    using ArrayIterator = typename ValueTypes<Processing>::ArrayIterator;
 
     bool was_written = true;
     Value& value = stack.back().Visit(
@@ -160,11 +160,11 @@ bool WriteStartAndEnterValue(Stack<kProcessing>& stack, Handler& handler) {
 
 }  // namespace impl
 
-template <ObjectProcessing kProcessing, typename Handler>
-bool AcceptNoRecursion(typename ValueTypes<kProcessing>::Value& process_value, Handler& handler) {
-    using ArrayIterator = typename ValueTypes<kProcessing>::ArrayIterator;
+template <ObjectProcessing Processing, typename Handler>
+bool AcceptNoRecursion(typename ValueTypes<Processing>::Value& process_value, Handler& handler) {
+    using ArrayIterator = typename ValueTypes<Processing>::ArrayIterator;
 
-    impl::Stack<kProcessing> stack;
+    impl::Stack<Processing> stack;
 
     stack.emplace_back(static_cast<ArrayIterator>(&process_value), static_cast<ArrayIterator>(&process_value + 1));
 
diff --git a/universal/src/formats/json/impl/mutable_value_wrapper.cpp b/universal/src/formats/json/impl/mutable_value_wrapper.cpp
index e241357f6930..acbc7d3564fe 100644
--- a/universal/src/formats/json/impl/mutable_value_wrapper.cpp
+++ b/universal/src/formats/json/impl/mutable_value_wrapper.cpp
@@ -21,8 +21,8 @@ struct MutableValueWrapper::JsonPath {
     std::shared_ptr<JsonPath> parent;
 
     template <typename T>
-    JsonPath(T&& element_, std::shared_ptr<JsonPath> parent_)
-        : element(std::forward<T>(element_)), parent(std::move(parent_)) {}
+    JsonPath(T&& element, std::shared_ptr<JsonPath> parent)
+        : element(std::forward<T>(element)), parent(std::move(parent)) {}
 
     static Value& FetchMember(Value& root, const std::shared_ptr<JsonPath>& path);
     static std::string ToString(const std::shared_ptr<JsonPath>&);
diff --git a/universal/src/formats/json/member_access_benchmark.cpp b/universal/src/formats/json/member_access_benchmark.cpp
index 89f303c60794..35516b84d9b6 100644
--- a/universal/src/formats/json/member_access_benchmark.cpp
+++ b/universal/src/formats/json/member_access_benchmark.cpp
@@ -52,7 +52,7 @@ constexpr char bench_json_data[] = R"({
 
 }  // anonymous namespace
 
-void json_path_short(benchmark::State& state) {
+void JsonPathShort(benchmark::State& state) {
     auto json = formats::json::FromString(bench_json_data);
 
     for ([[maybe_unused]] auto _ : state) {
@@ -61,9 +61,9 @@ void json_path_short(benchmark::State& state) {
         if (!res) throw std::runtime_error("unexpected");
     }
 }
-BENCHMARK(json_path_short);
+BENCHMARK(JsonPathShort);
 
-void json_path_long(benchmark::State& state) {
+void JsonPathLong(benchmark::State& state) {
     auto json = formats::json::FromString(bench_json_data);
 
     for ([[maybe_unused]] auto _ : state) {
@@ -72,9 +72,9 @@ void json_path_long(benchmark::State& state) {
         if (!res) throw std::runtime_error("unexpected");
     }
 }
-BENCHMARK(json_path_long);
+BENCHMARK(JsonPathLong);
 
-void json_path_deeply_nested(benchmark::State& state) {
+void JsonPathDeeplyNested(benchmark::State& state) {
     auto json = formats::json::FromString(bench_json_data);
 
     for ([[maybe_unused]] auto _ : state) {
@@ -85,9 +85,9 @@ void json_path_deeply_nested(benchmark::State& state) {
         if (!res) throw std::runtime_error("unexpected");
     }
 }
-BENCHMARK(json_path_deeply_nested);
+BENCHMARK(JsonPathDeeplyNested);
 
-void json_path_long_and_deeply_nested(benchmark::State& state) {
+void JsonPathLongAndDeeplyNested(benchmark::State& state) {
     auto json = formats::json::FromString(bench_json_data);
 
     for ([[maybe_unused]] auto _ : state) {
@@ -99,7 +99,7 @@ void json_path_long_and_deeply_nested(benchmark::State& state) {
         if (!res) throw std::runtime_error("unexpected");
     }
 }
-BENCHMARK(json_path_long_and_deeply_nested);
+BENCHMARK(JsonPathLongAndDeeplyNested);
 
 formats::json::ValueBuilder Build(size_t count) {
     formats::json::ValueBuilder builder;
@@ -107,15 +107,15 @@ formats::json::ValueBuilder Build(size_t count) {
     return builder;
 }
 
-void json_object_append(benchmark::State& state) {
+void JsonObjectAppend(benchmark::State& state) {
     const auto size = state.range(0);
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(Build(size));
     }
 }
-BENCHMARK(json_object_append)->RangeMultiplier(2)->Range(1, 10240);
+BENCHMARK(JsonObjectAppend)->RangeMultiplier(2)->Range(1, 10240);
 
-void json_object_compare(benchmark::State& state) {
+void JsonObjectCompare(benchmark::State& state) {
     const auto size = state.range(0);
     const auto a = Build(size).ExtractValue();
     const auto b = Build(size).ExtractValue();
@@ -123,7 +123,7 @@ void json_object_compare(benchmark::State& state) {
         benchmark::DoNotOptimize(a == b);
     }
 }
-BENCHMARK(json_object_compare)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(JsonObjectCompare)->RangeMultiplier(2)->Range(1, 1024);
 
 formats::json::ValueBuilder BuildNocheck(size_t count) {
     formats::json::ValueBuilder builder;
@@ -133,15 +133,15 @@ formats::json::ValueBuilder BuildNocheck(size_t count) {
     return builder;
 }
 
-void json_object_append_nocheck(benchmark::State& state) {
+void JsonObjectAppendNocheck(benchmark::State& state) {
     const auto size = state.range(0);
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(BuildNocheck(size));
     }
 }
-BENCHMARK(json_object_append_nocheck)->RangeMultiplier(2)->Range(1, 128);
+BENCHMARK(JsonObjectAppendNocheck)->RangeMultiplier(2)->Range(1, 128);
 
-void json_object_from_unordered(benchmark::State& state) {
+void JsonObjectFromUnordered(benchmark::State& state) {
     const auto size = state.range(0);
 
     std::unordered_map<std::string, int> map;
@@ -151,9 +151,9 @@ void json_object_from_unordered(benchmark::State& state) {
         benchmark::DoNotOptimize(formats::json::ValueBuilder(map));
     }
 }
-BENCHMARK(json_object_from_unordered)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(JsonObjectFromUnordered)->RangeMultiplier(2)->Range(1, 1024);
 
-void json_object_from_unordered_strong_typedef(benchmark::State& state) {
+void JsonObjectFromUnorderedStrongTypedef(benchmark::State& state) {
     const auto size = state.range(0);
 
     using MyString = utils::StrongTypedef<class Tag, std::string>;
@@ -164,9 +164,9 @@ void json_object_from_unordered_strong_typedef(benchmark::State& state) {
         benchmark::DoNotOptimize(formats::json::ValueBuilder(map));
     }
 }
-BENCHMARK(json_object_from_unordered_strong_typedef)->RangeMultiplier(2)->Range(1, 1024);
+BENCHMARK(JsonObjectFromUnorderedStrongTypedef)->RangeMultiplier(2)->Range(1, 1024);
 
-void json_object_wide_object_operator_equals(benchmark::State& state) {
+void JsonObjectWideObjectOperatorEquals(benchmark::State& state) {
     const std::size_t size = state.range(0);
 
     formats::json::ValueBuilder builder{formats::json::Type::kObject};
@@ -182,6 +182,6 @@ void json_object_wide_object_operator_equals(benchmark::State& state) {
         benchmark::DoNotOptimize(first_value == second_value);
     }
 }
-BENCHMARK(json_object_wide_object_operator_equals)->DenseRange(4, 16, 4)->Range(32, 8192)->RangeMultiplier(2);
+BENCHMARK(JsonObjectWideObjectOperatorEquals)->DenseRange(4, 16, 4)->Range(32, 8192)->RangeMultiplier(2);
 
 USERVER_NAMESPACE_END
diff --git a/universal/src/formats/json/member_access_test.cpp b/universal/src/formats/json/member_access_test.cpp
index f47bdf27eb54..5dbf508809f1 100644
--- a/universal/src/formats/json/member_access_test.cpp
+++ b/universal/src/formats/json/member_access_test.cpp
@@ -38,8 +38,8 @@ struct MemberAccess<formats::json::Value> : public ::testing::Test {
         "Value iterators are not assignable"
     );
 
-    MemberAccess() : doc_(kDoc) {}
-    formats::json::Value doc_;
+    MemberAccess() : doc(kDoc) {}
+    formats::json::Value doc;
 
     using ValueBuilder = formats::json::ValueBuilder;
     using Value = formats::json::Value;
@@ -59,19 +59,19 @@ TEST_F(FormatsJsonSpecificMemberAccess, CheckPrimitiveTypes) {
     using TypeMismatchException = formats::json::TypeMismatchException;
 
     // Differs from YAML:
-    EXPECT_FALSE(doc_["key3"]["sub"].IsUInt64());
-    EXPECT_THROW(doc_["key1"].As<std::string>(), TypeMismatchException);
-    EXPECT_THROW(doc_["key5"].As<std::string>(), TypeMismatchException);
-    EXPECT_THROW(doc_["key6"].As<std::string>(), TypeMismatchException);
+    EXPECT_FALSE(doc["key3"]["sub"].IsUInt64());
+    EXPECT_THROW(doc["key1"].As<std::string>(), TypeMismatchException);
+    EXPECT_THROW(doc["key5"].As<std::string>(), TypeMismatchException);
+    EXPECT_THROW(doc["key6"].As<std::string>(), TypeMismatchException);
 }
 
 TEST_F(FormatsJsonSpecificMemberAccess, Items) {
-    for ([[maybe_unused]] const auto& [key, value] : Items(doc_)) {
+    for ([[maybe_unused]] const auto& [key, value] : Items(doc)) {
     }
 }
 
 TEST_F(FormatsJsonSpecificMemberAccess, IterateAndCheckValues) {
-    const auto arr = doc_["key4"];
+    const auto arr = doc["key4"];
 
     int i = 2;
     int val = 3;
@@ -82,26 +82,26 @@ TEST_F(FormatsJsonSpecificMemberAccess, IterateAndCheckValues) {
 }
 
 TEST_F(FormatsJsonSpecificMemberAccess, CheckPrimitiveTypeExceptions) {
-    EXPECT_THROW(doc_["key1"].rbegin(), TypeMismatchException);
-    EXPECT_THROW(doc_["key1"].rend(), TypeMismatchException);
+    EXPECT_THROW(doc["key1"].rbegin(), TypeMismatchException);
+    EXPECT_THROW(doc["key1"].rend(), TypeMismatchException);
 
-    EXPECT_THROW(doc_["key2"].rbegin(), TypeMismatchException);
-    EXPECT_THROW(doc_["key2"].rend(), TypeMismatchException);
+    EXPECT_THROW(doc["key2"].rbegin(), TypeMismatchException);
+    EXPECT_THROW(doc["key2"].rend(), TypeMismatchException);
 
-    EXPECT_THROW(doc_["key3"].rbegin(), TypeMismatchException);
-    EXPECT_THROW(doc_["key3"].rend(), TypeMismatchException);
+    EXPECT_THROW(doc["key3"].rbegin(), TypeMismatchException);
+    EXPECT_THROW(doc["key3"].rend(), TypeMismatchException);
 
-    EXPECT_THROW(doc_["key5"].rbegin(), TypeMismatchException);
-    EXPECT_THROW(doc_["key5"].rend(), TypeMismatchException);
+    EXPECT_THROW(doc["key5"].rbegin(), TypeMismatchException);
+    EXPECT_THROW(doc["key5"].rend(), TypeMismatchException);
 
-    EXPECT_THROW(doc_["key6"].rbegin(), TypeMismatchException);
-    EXPECT_THROW(doc_["key6"].rend(), TypeMismatchException);
+    EXPECT_THROW(doc["key6"].rbegin(), TypeMismatchException);
+    EXPECT_THROW(doc["key6"].rend(), TypeMismatchException);
 }
 
 TEST_F(FormatsJsonSpecificMemberAccess, TypeMismatchExceptionAccessToAttributes) {
-    EXPECT_THROW(doc_["key1"].As<std::string>(), TypeMismatchException);
+    EXPECT_THROW(doc["key1"].As<std::string>(), TypeMismatchException);
     try {
-        doc_["key1"].As<std::string>();
+        doc["key1"].As<std::string>();
     } catch (const TypeMismatchException& e) {
         EXPECT_EQ(e.GetActual(), "intValue");
         EXPECT_EQ(e.GetExpected(), "stringValue");
@@ -110,7 +110,7 @@ TEST_F(FormatsJsonSpecificMemberAccess, TypeMismatchExceptionAccessToAttributes)
 }
 
 TEST_F(FormatsJsonSpecificMemberAccess, OutOfBoundsExceptionAccessToAttributes) {
-    const auto arr = doc_["key4"];
+    const auto arr = doc["key4"];
     EXPECT_THROW(arr[4], OutOfBoundsException);
     try {
         arr[4];
diff --git a/universal/src/formats/json/member_modify_test.cpp b/universal/src/formats/json/member_modify_test.cpp
index e2156e46adb7..8d1e081dfa63 100644
--- a/universal/src/formats/json/member_modify_test.cpp
+++ b/universal/src/formats/json/member_modify_test.cpp
@@ -36,7 +36,7 @@ struct MemberModify<formats::json::ValueBuilder> : public ::testing::Test {
         "ValueBuilder iterators are assignable"
     );
 
-    MemberModify() : builder_(kDoc) {}
+    MemberModify() : builder(kDoc) {}
 
     static formats::json::Value GetValue(formats::json::ValueBuilder& bld) {
         auto v = bld.ExtractValue();
@@ -44,9 +44,9 @@ struct MemberModify<formats::json::ValueBuilder> : public ::testing::Test {
         return v;
     }
 
-    formats::json::Value GetBuiltValue() { return GetValue(builder_); }
+    formats::json::Value GetBuiltValue() { return GetValue(builder); }
 
-    formats::json::ValueBuilder builder_;
+    formats::json::ValueBuilder builder;
 
     using ValueBuilder = formats::json::ValueBuilder;
     using Value = formats::json::Value;
diff --git a/universal/src/formats/json/parser/parser_json.cpp b/universal/src/formats/json/parser/parser_json.cpp
index 16b43f9c0d1e..b348bd24606d 100644
--- a/universal/src/formats/json/parser/parser_json.cpp
+++ b/universal/src/formats/json/parser/parser_json.cpp
@@ -16,14 +16,14 @@ ::rapidjson::CrtAllocator g_allocator;
 }  // namespace
 
 struct JsonValueParser::Impl {
-    json::impl::Document raw_value_{&g_allocator};
-    size_t level_{0};
+    json::impl::Document raw_value{&g_allocator};
+    size_t level{0};
 
     ~Impl() {
         auto generator = [](const auto&) { return false; };
         // This forces GenericDocument to clean up its stack,
         // and doesn't do anything other than that.
-        raw_value_.Populate(generator);
+        raw_value.Populate(generator);
     }
 };
 
@@ -32,73 +32,73 @@ JsonValueParser::JsonValueParser() = default;
 JsonValueParser::~JsonValueParser() = default;
 
 void JsonValueParser::Null() {
-    if (!impl_->raw_value_.Null()) Throw(Expected());
+    if (!impl_->raw_value.Null()) Throw(Expected());
     MaybePopSelf();
 }
 
 void JsonValueParser::Bool(bool value) {
-    if (!impl_->raw_value_.Bool(value)) Throw(Expected());
+    if (!impl_->raw_value.Bool(value)) Throw(Expected());
     MaybePopSelf();
 }
 
 void JsonValueParser::Int64(int64_t value) {
-    if (!impl_->raw_value_.Int64(value)) Throw(Expected());
+    if (!impl_->raw_value.Int64(value)) Throw(Expected());
     MaybePopSelf();
 }
 
 void JsonValueParser::Uint64(uint64_t value) {
-    if (!impl_->raw_value_.Uint64(value)) Throw(Expected());
+    if (!impl_->raw_value.Uint64(value)) Throw(Expected());
     MaybePopSelf();
 }
 
 void JsonValueParser::Double(double value) {
-    if (!impl_->raw_value_.Double(value)) Throw(Expected());
+    if (!impl_->raw_value.Double(value)) Throw(Expected());
     MaybePopSelf();
 }
 
 void JsonValueParser::String(std::string_view sw) {
-    if (!impl_->raw_value_.String(sw.data(), sw.size(), true)) Throw(Expected());
+    if (!impl_->raw_value.String(sw.data(), sw.size(), true)) Throw(Expected());
     MaybePopSelf();
 }
 
 void JsonValueParser::StartObject() {
-    if (!impl_->raw_value_.StartObject()) Throw(Expected());
-    if (impl_->level_++ > kDepthParseLimit)
+    if (!impl_->raw_value.StartObject()) Throw(Expected());
+    if (impl_->level++ > kDepthParseLimit)
         throw InternalParseError("Exceeded maximum allowed JSON depth of: " + std::to_string(kDepthParseLimit));
 }
 
 void JsonValueParser::Key(std::string_view key) {
-    if (!impl_->raw_value_.Key(key.data(), key.size(), true)) Throw(Expected());
+    if (!impl_->raw_value.Key(key.data(), key.size(), true)) Throw(Expected());
 }
 
 void JsonValueParser::EndObject(size_t members) {
-    if (!impl_->raw_value_.EndObject(members)) Throw(Expected());
+    if (!impl_->raw_value.EndObject(members)) Throw(Expected());
 
-    impl_->level_--;
+    impl_->level--;
     MaybePopSelf();
 }
 
 void JsonValueParser::StartArray() {
-    if (!impl_->raw_value_.StartArray()) Throw(Expected());
-    if (impl_->level_++ > kDepthParseLimit)
+    if (!impl_->raw_value.StartArray()) Throw(Expected());
+    if (impl_->level++ > kDepthParseLimit)
         throw InternalParseError("Exceeded maximum allowed JSON depth of: " + std::to_string(kDepthParseLimit));
 }
 
 void JsonValueParser::EndArray(size_t members) {
-    if (!impl_->raw_value_.EndArray(members)) Throw(Expected());
+    if (!impl_->raw_value.EndArray(members)) Throw(Expected());
 
-    impl_->level_--;
+    impl_->level--;
     MaybePopSelf();
 }
 
 std::string JsonValueParser::Expected() const { return "anything"; }
 
 void JsonValueParser::MaybePopSelf() {
-    if (impl_->level_ == 0) {
+    if (impl_->level == 0) {
         auto generator = [](const auto&) { return true; };
-        impl_->raw_value_.Populate(generator);
+        impl_->raw_value.Populate(generator);
 
-        this->SetResult(Value{json::impl::VersionedValuePtr::Create(std::move(impl_->raw_value_))});
+        this->SetResult(Value{json::impl::VersionedValuePtr::Create(std::move(impl_->raw_value))});
     }
 }
 
diff --git a/universal/src/formats/json/value.cpp b/universal/src/formats/json/value.cpp
index abae8c7c0a8f..fd78c9a4657d 100644
--- a/universal/src/formats/json/value.cpp
+++ b/universal/src/formats/json/value.cpp
@@ -499,7 +499,7 @@ void PrintTo(const Value& json, std::ostream* out) { Serialize(json, *out); }
 
 namespace formats::literals {
 
-json::Value operator"" _json(const char* str, size_t len) { return json::FromString(std::string_view(str, len)); }
+json::Value operator""_json(const char* str, size_t len) { return json::FromString(std::string_view(str, len)); }
 
 }  // namespace formats::literals
 
diff --git a/universal/src/formats/yaml/iterator.cpp b/universal/src/formats/yaml/iterator.cpp
index 271230bf3fe2..61cb4bf9c37b 100644
--- a/universal/src/formats/yaml/iterator.cpp
+++ b/universal/src/formats/yaml/iterator.cpp
@@ -10,24 +10,20 @@ USERVER_NAMESPACE_BEGIN
 
 namespace formats::yaml {
 
-template <typename iter_traits>
-Iterator<iter_traits>::Iterator(
-    const typename iter_traits::native_iter& iter,
-    int index,
-    const formats::yaml::Path& path
-)
+template <typename IterTraits>
+Iterator<IterTraits>::Iterator(const typename IterTraits::native_iter& iter, int index, const formats::yaml::Path& path)
     : iter_pimpl_(iter), path_(path), index_(index) {}
 
-template <typename iter_traits>
-Iterator<iter_traits>::Iterator(const Iterator<iter_traits>& other)
+template <typename IterTraits>
+Iterator<IterTraits>::Iterator(const Iterator<IterTraits>& other)
     : iter_pimpl_(other.iter_pimpl_), path_(other.path_), index_(other.index_) {}
 
-template <typename iter_traits>
-Iterator<iter_traits>::Iterator(Iterator<iter_traits>&& other) noexcept
+template <typename IterTraits>
+Iterator<IterTraits>::Iterator(Iterator<IterTraits>&& other) noexcept
     : iter_pimpl_(std::move(other.iter_pimpl_)), path_(std::move(other.path_)), index_(other.index_) {}
 
-template <typename iter_traits>
-Iterator<iter_traits>& Iterator<iter_traits>::operator=(const Iterator<iter_traits>& other) {
+template <typename IterTraits>
+Iterator<IterTraits>& Iterator<IterTraits>::operator=(const Iterator<IterTraits>& other) {
     if (this == &other) return *this;
 
     iter_pimpl_ = other.iter_pimpl_;
@@ -37,8 +33,8 @@ Iterator<iter_traits>& Iterator<iter_traits>::operator=(const Iterator<iter_trai
     return *this;
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>& Iterator<iter_traits>::operator=(Iterator<iter_traits>&& other) noexcept {
+template <typename IterTraits>
+Iterator<IterTraits>& Iterator<IterTraits>::operator=(Iterator<IterTraits>&& other) noexcept {
     iter_pimpl_ = std::move(other.iter_pimpl_);
     path_ = std::move(other.path_);
     index_ = other.index_;
@@ -46,21 +42,21 @@ Iterator<iter_traits>& Iterator<iter_traits>::operator=(Iterator<iter_traits>&&
     return *this;
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>::~Iterator() = default;
+template <typename IterTraits>
+Iterator<IterTraits>::~Iterator() = default;
 
-template <typename iter_traits>
-Iterator<iter_traits> Iterator<iter_traits>::operator++(int) {
+template <typename IterTraits>
+Iterator<IterTraits> Iterator<IterTraits>::operator++(int) {
     current_.reset();
     const auto index_copy = index_;
     if (index_ != -1) {
         ++index_;
     }
-    return Iterator<iter_traits>((*iter_pimpl_)++, index_copy, path_);
+    return Iterator<IterTraits>((*iter_pimpl_)++, index_copy, path_);
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>& Iterator<iter_traits>::operator++() {
+template <typename IterTraits>
+Iterator<IterTraits>& Iterator<IterTraits>::operator++() {
     current_.reset();
     ++(*iter_pimpl_);
     if (index_ != -1) {
@@ -69,46 +65,46 @@ Iterator<iter_traits>& Iterator<iter_traits>::operator++() {
     return *this;
 }
 
-template <typename iter_traits>
-typename Iterator<iter_traits>::reference Iterator<iter_traits>::operator*() const {
+template <typename IterTraits>
+typename Iterator<IterTraits>::reference Iterator<IterTraits>::operator*() const {
     UpdateValue();
     return *current_;
 }
 
-template <typename iter_traits>
-typename Iterator<iter_traits>::pointer Iterator<iter_traits>::operator->() const {
+template <typename IterTraits>
+typename Iterator<IterTraits>::pointer Iterator<IterTraits>::operator->() const {
     UpdateValue();
     return &**this;
 }
 
-template <typename iter_traits>
-bool Iterator<iter_traits>::operator==(const Iterator<iter_traits>& other) const {
+template <typename IterTraits>
+bool Iterator<IterTraits>::operator==(const Iterator<IterTraits>& other) const {
     return *iter_pimpl_ == *other.iter_pimpl_;
 }
 
-template <typename iter_traits>
-bool Iterator<iter_traits>::operator!=(const Iterator<iter_traits>& other) const {
+template <typename IterTraits>
+bool Iterator<IterTraits>::operator!=(const Iterator<IterTraits>& other) const {
     return *iter_pimpl_ != *other.iter_pimpl_;
 }
 
-template <typename iter_traits>
-std::string Iterator<iter_traits>::GetName() const {
+template <typename IterTraits>
+std::string Iterator<IterTraits>::GetName() const {
     if (index_ != -1) {
         throw TypeMismatchException(Type::kArray, Type::kObject, path_.ToStringView());
     }
     return (*iter_pimpl_)->first.Scalar();
 }
 
-template <typename iter_traits>
-uint32_t Iterator<iter_traits>::GetIndex() const {
+template <typename IterTraits>
+uint32_t Iterator<IterTraits>::GetIndex() const {
     if (index_ == -1) {
         throw TypeMismatchException(Type::kObject, Type::kArray, path_.ToStringView());
     }
     return index_;
 }
 
-template <typename iter_traits>
-Type Iterator<iter_traits>::GetIteratorType() const {
+template <typename IterTraits>
+Type Iterator<IterTraits>::GetIteratorType() const {
     if (index_ == -1) {
         return Type::kObject;
     } else {
@@ -116,8 +112,8 @@ Type Iterator<iter_traits>::GetIteratorType() const {
     }
 }
 
-template <typename iter_traits>
-void Iterator<iter_traits>::UpdateValue() const {
+template <typename IterTraits>
+void Iterator<IterTraits>::UpdateValue() const {
     if (current_) return;
 
     if (index_ == -1) {
diff --git a/universal/src/formats/yaml/member_access_test.cpp b/universal/src/formats/yaml/member_access_test.cpp
index 596ba69e1fa1..ffa97b7cf82c 100644
--- a/universal/src/formats/yaml/member_access_test.cpp
+++ b/universal/src/formats/yaml/member_access_test.cpp
@@ -30,8 +30,8 @@ struct MemberAccess<formats::yaml::Value> : public ::testing::Test {
         "Value iterators are not assignable"
     );
 
-    inline MemberAccess() : doc_(formats::yaml::FromString(kDoc)) {}
-    formats::yaml::Value doc_;
+    inline MemberAccess() : doc(formats::yaml::FromString(kDoc)) {}
+    formats::yaml::Value doc;
 
     using ValueBuilder = formats::yaml::ValueBuilder;
     using Value = formats::yaml::Value;
@@ -54,13 +54,13 @@ TEST_F(FormatsYamlSpecificMemberAccess, CheckPrimitiveTypes) {
     //        negative numbers into unsigned types
     // EXPECT_FALSE(doc_["key3"]["sub"].IsUInt64());
 
-    EXPECT_NO_THROW(doc_["key1"].As<std::string>());
-    EXPECT_NO_THROW(doc_["key5"].As<std::string>());
-    EXPECT_NO_THROW(doc_["key6"].As<std::string>());
+    EXPECT_NO_THROW(doc["key1"].As<std::string>());
+    EXPECT_NO_THROW(doc["key5"].As<std::string>());
+    EXPECT_NO_THROW(doc["key6"].As<std::string>());
 }
 
 TEST_F(FormatsYamlSpecificMemberAccess, Items) {
-    for ([[maybe_unused]] const auto& [key, value] : Items(doc_)) {
+    for ([[maybe_unused]] const auto& [key, value] : Items(doc)) {
     }
 }
 
diff --git a/universal/src/formats/yaml/member_modify_test.cpp b/universal/src/formats/yaml/member_modify_test.cpp
index d825a412f1d8..5dae8953c796 100644
--- a/universal/src/formats/yaml/member_modify_test.cpp
+++ b/universal/src/formats/yaml/member_modify_test.cpp
@@ -29,7 +29,7 @@ struct MemberModify<formats::yaml::ValueBuilder> : public ::testing::Test {
         "ValueBuilder iterators are assignable"
     );
 
-    MemberModify() : builder_(formats::yaml::FromString(kDoc)) {}
+    MemberModify() : builder(formats::yaml::FromString(kDoc)) {}
 
     static formats::yaml::Value GetValue(formats::yaml::ValueBuilder& bld) {
         auto v = bld.ExtractValue();
@@ -37,9 +37,9 @@ struct MemberModify<formats::yaml::ValueBuilder> : public ::testing::Test {
         return v;
     }
 
-    formats::yaml::Value GetBuiltValue() { return GetValue(builder_); }
+    formats::yaml::Value GetBuiltValue() { return GetValue(builder); }
 
-    formats::yaml::ValueBuilder builder_;
+    formats::yaml::ValueBuilder builder;
 
     using ValueBuilder = formats::yaml::ValueBuilder;
     using Value = formats::yaml::Value;
diff --git a/universal/src/formats/yaml/string_view_support.hpp b/universal/src/formats/yaml/string_view_support.hpp
index 788b0dc72e0a..855856480e77 100644
--- a/universal/src/formats/yaml/string_view_support.hpp
+++ b/universal/src/formats/yaml/string_view_support.hpp
@@ -53,7 +53,7 @@ using StringViewOrSomeFake =
 
 USERVER_NAMESPACE_END
 
-namespace YAML {
+namespace YAML {  // NOLINT(readability-identifier-naming)
 
 // Makes YAML work with std::string_view as keys
 template <>
diff --git a/universal/src/formats/yaml/value.cpp b/universal/src/formats/yaml/value.cpp
index 1447ef0034ca..f5f439769ae2 100644
--- a/universal/src/formats/yaml/value.cpp
+++ b/universal/src/formats/yaml/value.cpp
@@ -297,7 +297,7 @@ void Value::CheckInBounds(std::size_t index) const {
 
 namespace formats::literals {
 
-yaml::Value operator"" _yaml(const char* str, size_t len) { return yaml::FromString(std::string(str, len)); }
+yaml::Value operator""_yaml(const char* str, size_t len) { return yaml::FromString(std::string(str, len)); }
 
 }  // namespace formats::literals
 
diff --git a/universal/src/fs/blocking/temp_file.cpp b/universal/src/fs/blocking/temp_file.cpp
index aef9e2fbee23..2fe5cfddad02 100644
--- a/universal/src/fs/blocking/temp_file.cpp
+++ b/universal/src/fs/blocking/temp_file.cpp
@@ -47,7 +47,7 @@ TempFile::~TempFile() {
     try {
         fs::blocking::RemoveSingleFile(path_);
     } catch (const std::exception& ex) {
-        LOG_ERROR() << ex;
+        LOG_ERROR() << "fs::blocking::~TempFile failed with exception: " << ex;
     }
 }
 
diff --git a/universal/src/fs/blocking/temp_file_test.cpp b/universal/src/fs/blocking/temp_file_test.cpp
index 8fc8df59ca28..fdc0ef8caf34 100644
--- a/universal/src/fs/blocking/temp_file_test.cpp
+++ b/universal/src/fs/blocking/temp_file_test.cpp
@@ -7,10 +7,13 @@
 
 #include <userver/fs/blocking/temp_directory.hpp>
 #include <userver/fs/blocking/write.hpp>
+#include <userver/logging/log.hpp>
+#include <userver/utest/log_capture_fixture.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace {
+using FsBlockingTempFileWithLog = utest::LogCaptureFixture<>;
 
 bool StartsWith(std::string_view hay, std::string_view needle) { return hay.substr(0, needle.size()) == needle; }
 
@@ -75,4 +78,59 @@ TEST(TempFile, CustomPath) {
     EXPECT_EQ(boost::filesystem::status(root + "/foo").permissions(), boost::filesystem::perms::owner_all);
 }
 
+TEST_F(FsBlockingTempFileWithLog, BlockingTempFileDestructorWithException) {
+    std::string parent_dir;
+    {
+        const auto parent = fs::blocking::TempDirectory::Create();
+        parent_dir = parent.GetPath();
+
+        {
+            // Create temp file in temporaty directory
+            const auto file = fs::blocking::TempFile::Create(parent_dir, "BlockingTempFileDestructorWithException");
+
+            const auto dir_status = boost::filesystem::status(parent_dir);
+            const auto original_perms = dir_status.permissions();
+
+            LOG_DEBUG() << "Original directory permissions: " << static_cast<int>(original_perms);
+
+            // Check that the directory has write permissions
+            ASSERT_TRUE((original_perms & boost::filesystem::perms::owner_write) != boost::filesystem::perms::no_perms);
+
+            // Change permissions for the directory
+            boost::filesystem::permissions(
+                parent_dir,
+                boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_exe |
+                    boost::filesystem::perms::group_read | boost::filesystem::perms::group_exe |
+                    boost::filesystem::perms::others_read | boost::filesystem::perms::others_exe
+            );
+            LOG_DEBUG() << "Changed directory permissions, write is now forbidden";
+
+            // Check that the file can not be removed
+            try {
+                boost::filesystem::remove(file.GetPath());
+                FAIL() << "Expected exception when removing file";
+            } catch (const std::exception& ex) {
+                LOG_DEBUG() << "Confirmed file cannot be removed";
+            }
+
+            // We don't expect that ~TempFile to throw an exception
+        }
+
+        // Check that log with error from ~TempFile exists
+        EXPECT_EQ(GetLogCapture().Filter("fs::blocking::~TempFile failed with exception:").size(), 1);
+
+        // Rollback directory permissions
+        boost::filesystem::permissions(
+            parent_dir,
+            boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_write |
+                boost::filesystem::perms::owner_exe | boost::filesystem::perms::group_read |
+                boost::filesystem::perms::group_write | boost::filesystem::perms::group_exe |
+                boost::filesystem::perms::others_read | boost::filesystem::perms::others_write |
+                boost::filesystem::perms::others_exe
+        );
+        LOG_DEBUG() << "Changed directory permissions, write is now available";
+    }
+    ASSERT_FALSE(boost::filesystem::exists(parent_dir));
+}
+
 USERVER_NAMESPACE_END
diff --git a/universal/src/http/header_map/danger.hpp b/universal/src/http/header_map/danger.hpp
index 6341451e94b6..f4b3b48a4398 100644
--- a/universal/src/http/header_map/danger.hpp
+++ b/universal/src/http/header_map/danger.hpp
@@ -14,10 +14,10 @@ class Danger final {
 
     inline std::size_t HashKey(const PredefinedHeader& header) const noexcept {
         if (!IsRed()) {
-            return header.hash;
+            return header.hash_;
         }
 
-        return SafeHash(header.name);
+        return SafeHash(header.name_);
     }
 
     inline bool IsYellow() const noexcept { return state_ == State::kYellow; }
diff --git a/universal/src/http/header_map/map.cpp b/universal/src/http/header_map/map.cpp
index c5700318736e..234a85ca5b42 100644
--- a/universal/src/http/header_map/map.cpp
+++ b/universal/src/http/header_map/map.cpp
@@ -355,13 +355,13 @@ Map::Iterator Map::Find(std::string_view key) noexcept {
 }
 
 Map::ConstIterator Map::Find(const PredefinedHeader& header) const noexcept {
-    const auto pos = DoFind(header.name, HashKey(header), header.header_index);
+    const auto pos = DoFind(header.name_, HashKey(header), header.header_index_);
 
     return pos.IsSome() ? ToReverseIterator(entries_.cbegin() + pos.entries_index) : End();
 }
 
 Map::Iterator Map::Find(const PredefinedHeader& header) noexcept {
-    const auto pos = DoFind(header.name, HashKey(header), header.header_index);
+    const auto pos = DoFind(header.name_, HashKey(header), header.header_index_);
 
     return pos.IsSome() ? ToReverseIterator(entries_.begin() + pos.entries_index) : End();
 }
@@ -516,7 +516,7 @@ Map::Iterator Map::DoInsertOrModify(
 
 Map::Iterator Map::Erase(std::string_view key) { return DoErase(key, HashKey(key)); }
 
-Map::Iterator Map::Erase(const PredefinedHeader& header) { return DoErase(header.name, HashKey(header)); }
+Map::Iterator Map::Erase(const PredefinedHeader& header) { return DoErase(header.name_, HashKey(header)); }
 
 Map::Iterator Map::DoErase(std::string_view key, Traits::HashValue hash) {
     const auto pos = DoFind(key, hash, 0);
diff --git a/universal/src/http/url.cpp b/universal/src/http/url.cpp
index 7937ddc7a61a..371264d3b9c0 100644
--- a/universal/src/http/url.cpp
+++ b/universal/src/http/url.cpp
@@ -154,6 +154,11 @@ MakeUrl(std::string_view path, std::initializer_list<std::pair<std::string_view,
     return MakeUrl(path, query_args.begin(), query_args.end());
 }
 
+std::string
+MakeUrl(std::string_view path, const std::vector<std::pair<std::string_view, std::string_view>>& query_args) {
+    return MakeUrl(path, query_args.begin(), query_args.end());
+}
+
 std::string MakeQuery(const Args& query_args) { return DoMakeQuery(query_args.begin(), query_args.end()); }
 
 std::string MakeQuery(const MultiArgs& query_args) { return DoMakeQuery(query_args.begin(), query_args.end()); }
diff --git a/universal/src/http/url_benchmark.cpp b/universal/src/http/url_benchmark.cpp
index 829e6bbbe72c..54576d8b1f0e 100644
--- a/universal/src/http/url_benchmark.cpp
+++ b/universal/src/http/url_benchmark.cpp
@@ -4,7 +4,7 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void make_url(benchmark::State& state, std::size_t size) {
+void MakeUrl(benchmark::State& state, std::size_t size) {
     const std::string path = "http://example.com/v1/something";
     std::string spaces(size, ' ');
     std::string latins(size, 'a');
@@ -15,16 +15,16 @@ void make_url(benchmark::State& state, std::size_t size) {
     }
 }
 
-void make_url_tiny(benchmark::State& state) { make_url(state, 5); }
-BENCHMARK(make_url_tiny);
+void MakeUrlTiny(benchmark::State& state) { MakeUrl(state, 5); }
+BENCHMARK(MakeUrlTiny);
 
-void make_url_small(benchmark::State& state) { make_url(state, 50); }
-BENCHMARK(make_url_small);
+void MakeUrlSmall(benchmark::State& state) { MakeUrl(state, 50); }
+BENCHMARK(MakeUrlSmall);
 
-void make_url_big(benchmark::State& state) { make_url(state, 5000); }
-BENCHMARK(make_url_big);
+void MakeUrlBig(benchmark::State& state) { MakeUrl(state, 5000); }
+BENCHMARK(MakeUrlBig);
 
-void make_query(benchmark::State& state) {
+void MakeQuery(benchmark::State& state) {
     http::Args query_args;
     const auto agrs_count = state.range(0);
     for (int i = 0; i < agrs_count; i++) {
@@ -36,9 +36,9 @@ void make_query(benchmark::State& state) {
         benchmark::DoNotOptimize(result);
     }
 }
-BENCHMARK(make_query)->RangeMultiplier(2)->Range(1, 256);
+BENCHMARK(MakeQuery)->RangeMultiplier(2)->Range(1, 256);
 
-void make_url_with_path_args_value_sizes(benchmark::State& state, std::size_t size) {
+void MakeUrlWithPathArgsValueSizes(benchmark::State& state, std::size_t size) {
     const std::string path_template = "http://example.com/v1/{resource}/{id}";
     std::string large_value(size, 'x');
 
@@ -51,16 +51,16 @@ void make_url_with_path_args_value_sizes(benchmark::State& state, std::size_t si
     }
 }
 
-void make_url_with_path_args_small_values(benchmark::State& state) { make_url_with_path_args_value_sizes(state, 50); }
-BENCHMARK(make_url_with_path_args_small_values);
+void MakeUrlWithPathArgsSmallValues(benchmark::State& state) { MakeUrlWithPathArgsValueSizes(state, 50); }
+BENCHMARK(MakeUrlWithPathArgsSmallValues);
 
-void make_url_with_path_args_medium_values(benchmark::State& state) { make_url_with_path_args_value_sizes(state, 500); }
-BENCHMARK(make_url_with_path_args_medium_values);
+void MakeUrlWithPathArgsMediumValues(benchmark::State& state) { MakeUrlWithPathArgsValueSizes(state, 500); }
+BENCHMARK(MakeUrlWithPathArgsMediumValues);
 
-void make_url_with_path_args_large_values(benchmark::State& state) { make_url_with_path_args_value_sizes(state, 5000); }
-BENCHMARK(make_url_with_path_args_large_values);
+void MakeUrlWithPathArgsLargeValues(benchmark::State& state) { MakeUrlWithPathArgsValueSizes(state, 5000); }
+BENCHMARK(MakeUrlWithPathArgsLargeValues);
 
-void make_url_with_path_args_template_complexity(benchmark::State& state) {
+void MakeUrlWithPathArgsTemplateComplexity(benchmark::State& state) {
     std::string path_template;
     http::PathArgs path_args;
 
@@ -78,6 +78,6 @@ void make_url_with_path_args_template_complexity(benchmark::State& state) {
         benchmark::DoNotOptimize(result);
     }
 }
-BENCHMARK(make_url_with_path_args_template_complexity)->Range(1, 256);
+BENCHMARK(MakeUrlWithPathArgsTemplateComplexity)->Range(1, 256);
 
 USERVER_NAMESPACE_END
diff --git a/universal/src/logging/impl/formatters/tskv.hpp b/universal/src/logging/impl/formatters/tskv.hpp
index e7fc3e078b3b..5621733878ef 100644
--- a/universal/src/logging/impl/formatters/tskv.hpp
+++ b/universal/src/logging/impl/formatters/tskv.hpp
@@ -25,6 +25,8 @@ class Tskv final : public Base {
         return item_;
     }
 
+    LoggerItemBase& GetLoggerItem() { return item_; }
+
 private:
     void DoAddTag(std::string_view key, std::string_view value, bool value_is_escaped);
 
diff --git a/universal/src/logging/impl/log_extra_tskv_formatter.cpp b/universal/src/logging/impl/log_extra_tskv_formatter.cpp
new file mode 100644
index 000000000000..eb7fe92c9a7e
--- /dev/null
+++ b/universal/src/logging/impl/log_extra_tskv_formatter.cpp
@@ -0,0 +1,77 @@
+#include <userver/logging/impl/log_extra_tskv_formatter.hpp>
+
+#include <iostream>
+#include <stdexcept>
+
+#include <boost/container/small_vector.hpp>
+#include <boost/exception/diagnostic_information.hpp>
+
+#include <userver/utils/assert.hpp>
+
+#include <logging/impl/formatters/tskv.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace logging::impl {
+
+namespace {
+
+TskvPtr CreateFormatter(Format format) {
+    switch (format) {
+        case Format::kRaw:
+        case Format::kLtsv:
+        case Format::kTskv:
+            return utils::Box<impl::formatters::Tskv>(Level::kDebug, format, utils::impl::SourceLocation::Current());
+
+        case Format::kJson:
+        case Format::kJsonYaDeploy:
+            throw std::runtime_error("Invalid LogExtraTskvFormatter format: kJson and kJsonYaDeploy are not supported");
+    }
+
+    throw std::runtime_error("Invalid LogExtraTskvFormatter format");
+}
+
+}  // namespace
+
+LogExtraTskvFormatter::LogExtraTskvFormatter(logging::Format format) : formatter_(CreateFormatter(format)) {}
+
+LogExtraTskvFormatter::LogExtraTskvFormatter(LogExtraTskvFormatter&&) noexcept = default;
+
+LogExtraTskvFormatter& LogExtraTskvFormatter::operator=(LogExtraTskvFormatter&&) noexcept = default;
+
+LogExtraTskvFormatter::~LogExtraTskvFormatter() = default;
+
+TextLogItem& LogExtraTskvFormatter::GetTextLogItem() {
+    auto& item = formatter_->GetLoggerItem();
+
+    UASSERT(dynamic_cast<logging::impl::TextLogItem*>(&item));
+
+    // Safe: Tskv formatter always creates TextLogItem, verified by dynamic_cast above.
+    // The approach is taken from lsp-logger.cpp.
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
+    return static_cast<logging::impl::TextLogItem&>(item);
+}
+
+TextLogItem& LogExtraTskvFormatter::ExtractTextLogItem() {
+    auto& item = formatter_->ExtractLoggerItem();
+
+    UASSERT(dynamic_cast<logging::impl::TextLogItem*>(&item));
+
+    // Safe: Tskv formatter always creates TextLogItem, verified by dynamic_cast above.
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
+    return static_cast<logging::impl::TextLogItem&>(item);
+}
+
+void LogExtraTskvFormatter::Append(const LogExtra& log_extra) {
+    if (log_extra.extra_->empty()) {
+        return;
+    }
+
+    for (const auto& [key, value] : *log_extra.extra_) {
+        formatter_->AddTag(key, value.GetValue());
+    }
+}
+
+}  // namespace logging::impl
+
+USERVER_NAMESPACE_END
diff --git a/universal/src/logging/impl/mem_logger.cpp b/universal/src/logging/impl/mem_logger.cpp
index b30669219f82..e0c3bf275f29 100644
--- a/universal/src/logging/impl/mem_logger.cpp
+++ b/universal/src/logging/impl/mem_logger.cpp
@@ -18,15 +18,15 @@ constexpr auto kMaxLogItems = 10000;
 }  // namespace
 
 struct MemLogger::Impl {
-    std::mutex mutex_;
-    std::vector<formatters::LogItem> data_;
-    LoggerBase* forward_logger_{nullptr};
+    std::mutex mutex;
+    std::vector<formatters::LogItem> data;
+    LoggerBase* forward_logger{nullptr};
 };
 
 MemLogger::MemLogger() noexcept { SetLevel(Level::kDebug); }
 
 MemLogger::~MemLogger() {
-    for (const auto& data : pimpl_->data_) {
+    for (const auto& data : pimpl_->data) {
         std::fputs(data.text.c_str(), stderr);
     }
 }
@@ -37,13 +37,13 @@ MemLogger& MemLogger::GetMemLogger() noexcept {
 }
 
 void MemLogger::DropLogs() {
-    const std::lock_guard lock(pimpl_->mutex_);
-    pimpl_->data_.clear();
+    const std::lock_guard lock(pimpl_->mutex);
+    pimpl_->data.clear();
 }
 
 size_t MemLogger::GetPendingLogsCount() {
-    const std::lock_guard lock(pimpl_->mutex_);
-    return pimpl_->data_.size();
+    const std::lock_guard lock(pimpl_->mutex);
+    return pimpl_->data.size();
 }
 
 void MemLogger::Log(Level level, formatters::LoggerItemRef msg) {
@@ -51,19 +51,19 @@ void MemLogger::Log(Level level, formatters::LoggerItemRef msg) {
     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-static-cast-downcast)
     auto& item = static_cast<formatters::LogItem&>(msg);
 
-    const std::lock_guard lock(pimpl_->mutex_);
-    if (pimpl_->forward_logger_) {
-        auto formatter = pimpl_->forward_logger_->MakeFormatter(level, item.log_class, item.location);
+    const std::lock_guard lock(pimpl_->mutex);
+    if (pimpl_->forward_logger) {
+        auto formatter = pimpl_->forward_logger->MakeFormatter(level, item.log_class, item.location);
         DispatchItem(item, *formatter);
 
         auto& li = formatter->ExtractLoggerItem();
-        pimpl_->forward_logger_->Log(level, li);
+        pimpl_->forward_logger->Log(level, li);
         return;
     }
 
-    if (pimpl_->data_.size() > kMaxLogItems) return;
+    if (pimpl_->data.size() > kMaxLogItems) return;
 
-    pimpl_->data_.push_back(std::move(item));
+    pimpl_->data.push_back(std::move(item));
 }
 
 formatters::BasePtr
@@ -72,18 +72,18 @@ MemLogger::MakeFormatter(Level level, LogClass log_class, const utils::impl::Sou
 }
 
 void MemLogger::ForwardTo(LoggerBase* logger_to) {
-    const std::lock_guard lock(pimpl_->mutex_);
+    const std::lock_guard lock(pimpl_->mutex);
     if (logger_to) {
-        for (auto& log : pimpl_->data_) {
+        for (auto& log : pimpl_->data) {
             auto formatter = logger_to->MakeFormatter(log.level, log.log_class, log.location);
             DispatchItem(log, *formatter);
 
             auto& li = formatter->ExtractLoggerItem();
             logger_to->Log(log.level, li);
         }
-        pimpl_->data_.clear();
+        pimpl_->data.clear();
     }
-    pimpl_->forward_logger_ = logger_to;
+    pimpl_->forward_logger = logger_to;
 }
 
 void MemLogger::DispatchItem(formatters::LogItem& msg, formatters::Base& formatter) {
diff --git a/universal/src/utils/assert.cpp b/universal/src/utils/assert.cpp
index 36b3737e81dc..ece811bbd13e 100644
--- a/universal/src/utils/assert.cpp
+++ b/universal/src/utils/assert.cpp
@@ -15,6 +15,7 @@ namespace utils {
 
 namespace impl {
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 void UASSERT_failed(
     std::string_view expr,
     const char* file,
@@ -72,11 +73,15 @@ USERVER_NAMESPACE_END
 
 // Function definitions for defined BOOST_ENABLE_ASSERT_HANDLER
 namespace boost {
+
+// NOLINTNEXTLINE(readability-identifier-naming)
 void assertion_failed(char const* expr, char const* function, char const* file, long line) {
     USERVER_NAMESPACE::utils::impl::UASSERT_failed(expr, file, line, function, {});
 }
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 void assertion_failed_msg(char const* expr, char const* msg, char const* function, char const* file, long line) {
     USERVER_NAMESPACE::utils::impl::UASSERT_failed(expr, file, line, function, msg);
 }
+
 }  // namespace boost
diff --git a/universal/src/utils/bytes_per_second_test.cpp b/universal/src/utils/bytes_per_second_test.cpp
index 7b86bf60e140..f894b4e722da 100644
--- a/universal/src/utils/bytes_per_second_test.cpp
+++ b/universal/src/utils/bytes_per_second_test.cpp
@@ -6,21 +6,21 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
-struct data_t {
+struct DataT {
     const char* const name;
     const char* const data;
     const unsigned long long ethalon;
 };
 
-inline std::string PrintToString(const data_t& d) { return d.name; }
+inline std::string PrintToString(const DataT& d) { return d.name; }
 
-using TestData = std::initializer_list<data_t>;
+using TestData = std::initializer_list<DataT>;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class StringToBytesPerSecond : public ::testing::TestWithParam<data_t> {};
+class StringToBytesPerSecond : public ::testing::TestWithParam<DataT> {};
 
 INSTANTIATE_TEST_SUITE_P(
     /*no prefix*/,
diff --git a/universal/src/utils/datetime/date.cpp b/universal/src/utils/datetime/date.cpp
index 4c6d87059d40..dd81c12be1af 100644
--- a/universal/src/utils/datetime/date.cpp
+++ b/universal/src/utils/datetime/date.cpp
@@ -15,7 +15,7 @@ const std::string kDateFormat = "%Y-%m-%d";
 const auto kUtcTz = cctz::utc_time_zone();
 
 // TODO: replace with C++20 std::chrono::days
-constexpr date::days to_days(int year, int month, int day) noexcept {
+constexpr date::days ToDays(int year, int month, int day) noexcept {
     const date::year_month_day ymd{
         date::year{year}, date::month{static_cast<unsigned>(month)}, date::day{static_cast<unsigned>(day)}};
 
@@ -24,7 +24,7 @@ constexpr date::days to_days(int year, int month, int day) noexcept {
 
 }  // namespace
 
-Date::Date(int year, int month, int day) : sys_days_{to_days(year, month, day)} {}
+Date::Date(int year, int month, int day) : sys_days_{ToDays(year, month, day)} {}
 
 Date DateFromRFC3339String(const std::string& date_string) {
     const auto time_point = FromStringSaturating(date_string, kDateFormat);
diff --git a/universal/src/utils/datetime/steady_coarse_clock_benchmark.cpp b/universal/src/utils/datetime/steady_coarse_clock_benchmark.cpp
index a00b9d74a904..005b8ff8e9ff 100644
--- a/universal/src/utils/datetime/steady_coarse_clock_benchmark.cpp
+++ b/universal/src/utils/datetime/steady_coarse_clock_benchmark.cpp
@@ -6,18 +6,18 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void steady_clock_benchmark(benchmark::State& state) {
+void SteadyClockBenchmark(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(std::chrono::steady_clock::now());
     }
 }
-BENCHMARK(steady_clock_benchmark);
+BENCHMARK(SteadyClockBenchmark);
 
-void steady_coarse_clock_benchmark(benchmark::State& state) {
+void SteadyCoarseClockBenchmark(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(utils::datetime::SteadyCoarseClock::now());
     }
 }
-BENCHMARK(steady_coarse_clock_benchmark);
+BENCHMARK(SteadyCoarseClockBenchmark);
 
 USERVER_NAMESPACE_END
diff --git a/universal/src/utils/datetime/wall_coarse_clock_benchmark.cpp b/universal/src/utils/datetime/wall_coarse_clock_benchmark.cpp
index be9137841b7a..9c6d8fc67e44 100644
--- a/universal/src/utils/datetime/wall_coarse_clock_benchmark.cpp
+++ b/universal/src/utils/datetime/wall_coarse_clock_benchmark.cpp
@@ -6,18 +6,18 @@
 
 USERVER_NAMESPACE_BEGIN
 
-void wall_clock_benchmark(benchmark::State& state) {
+void WallClockBenchmark(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(std::chrono::system_clock::now());
     }
 }
-BENCHMARK(wall_clock_benchmark);
+BENCHMARK(WallClockBenchmark);
 
-void wall_coarse_clock_benchmark(benchmark::State& state) {
+void WallCoarseClockBenchmark(benchmark::State& state) {
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(utils::datetime::WallCoarseClock::now());
     }
 }
-BENCHMARK(wall_coarse_clock_benchmark);
+BENCHMARK(WallCoarseClockBenchmark);
 
 USERVER_NAMESPACE_END
diff --git a/universal/src/utils/encoding/hex_benchmark.cpp b/universal/src/utils/encoding/hex_benchmark.cpp
index 5a73a0e28eec..6a8fd1e43a36 100644
--- a/universal/src/utils/encoding/hex_benchmark.cpp
+++ b/universal/src/utils/encoding/hex_benchmark.cpp
@@ -20,16 +20,16 @@ std::string GenerateSource(size_t size) {
 
 }  // namespace
 
-void to_hex_benchmark(benchmark::State& state) {
+void ToHexBenchmark(benchmark::State& state) {
     const auto source = GenerateSource(state.range(0));
 
     for ([[maybe_unused]] auto _ : state) {
         benchmark::DoNotOptimize(utils::encoding::ToHex(source));
     }
 }
-BENCHMARK(to_hex_benchmark)->RangeMultiplier(2)->Range(8, 512);
+BENCHMARK(ToHexBenchmark)->RangeMultiplier(2)->Range(8, 512);
 
-void to_hex_benchmark_no_alloc(benchmark::State& state) {
+void ToHexBenchmarkNoAlloc(benchmark::State& state) {
     const auto source = GenerateSource(state.range(0));
 
     std::string out;
@@ -40,6 +40,6 @@ void to_hex_benchmark_no_alloc(benchmark::State& state) {
         utils::encoding::ToHex(source, out);
     }
 }
-BENCHMARK(to_hex_benchmark_no_alloc)->RangeMultiplier(2)->Range(8, 512);
+BENCHMARK(ToHexBenchmarkNoAlloc)->RangeMultiplier(2)->Range(8, 512);
 
 USERVER_NAMESPACE_END
diff --git a/universal/src/utils/from_string.cpp b/universal/src/utils/from_string.cpp
index 4b3154bce3c5..5db10f6d13d9 100644
--- a/universal/src/utils/from_string.cpp
+++ b/universal/src/utils/from_string.cpp
@@ -13,12 +13,12 @@ namespace utils {
 namespace impl {
 
 [[noreturn]] void
-ThrowFromStringException(std::string_view message, std::string_view input, std::type_index resultType) {
+ThrowFromStringException(std::string_view message, std::string_view input, std::type_index result_type) {
     throw std::runtime_error(fmt::format(
         R"(utils::FromString error: "{}" while converting "{}" to {})",
         message,
         input,
-        compiler::GetTypeName(resultType)
+        compiler::GetTypeName(result_type)
     ));
 }
 
diff --git a/universal/src/utils/from_string_test.cpp b/universal/src/utils/from_string_test.cpp
index 5c447d767070..eed1520c8b5b 100644
--- a/universal/src/utils/from_string_test.cpp
+++ b/universal/src/utils/from_string_test.cpp
@@ -37,19 +37,19 @@ auto TestInvalid(const std::string& input) {
 }
 
 template <typename StringType, typename T>
-auto CheckConverts(StringType input, T expectedResult) {
+auto CheckConverts(StringType input, T expected_result) {
     T actualResult{};
     ASSERT_NO_THROW(actualResult = utils::FromString<T>(input))
         << "type = " << compiler::GetTypeName<T>() << ", input = \"" << input << "\"";
-    ASSERT_EQ(actualResult, expectedResult)
+    ASSERT_EQ(actualResult, expected_result)
         << "type = " << compiler::GetTypeName<T>() << ", input = \"" << input << "\"";
 }
 
 template <typename T>
-auto TestConverts(const std::string& input, T expectedResult) {
-    CheckConverts(input.c_str(), expectedResult);
-    CheckConverts(input, expectedResult);
-    CheckConverts(std::string_view{input}, expectedResult);
+auto TestConverts(const std::string& input, T expected_result) {
+    CheckConverts(input.c_str(), expected_result);
+    CheckConverts(input, expected_result);
+    CheckConverts(std::string_view{input}, expected_result);
 }
 
 template <typename T>
diff --git a/universal/src/utils/meta_test.cpp b/universal/src/utils/meta_test.cpp
index e2710b476636..4780c231a4f5 100644
--- a/universal/src/utils/meta_test.cpp
+++ b/universal/src/utils/meta_test.cpp
@@ -221,11 +221,11 @@ template <typename T>
 using DummyAlias = typename T::dummy_alias;
 
 TEST(Meta, Detection) {
-    static_assert(meta::kIsDetected<DummyAlias, Dummy>);
+    static_assert(meta::IsDetected<DummyAlias, Dummy>);
     static_assert(std::is_same_v<meta::DetectedType<DummyAlias, Dummy>, int>);
     static_assert(std::is_same_v<meta::DetectedOr<bool, DummyAlias, Dummy>, int>);
 
-    static_assert(!meta::kIsDetected<DummyAlias, std::string>);
+    static_assert(!meta::IsDetected<DummyAlias, std::string>);
     static_assert(std::is_same_v<meta::DetectedType<DummyAlias, std::string>, meta::NotDetected>);
     static_assert(std::is_same_v<meta::DetectedOr<bool, DummyAlias, std::string>, bool>);
 }
diff --git a/universal/src/utils/overloaded_test.cpp b/universal/src/utils/overloaded_test.cpp
index 83ada1d89a36..2b8201dfa5ba 100644
--- a/universal/src/utils/overloaded_test.cpp
+++ b/universal/src/utils/overloaded_test.cpp
@@ -80,12 +80,12 @@ TEST_P(OverloadedTestFixture, UtilsVisit) {
 
 TEST(OverloadedTest, ReturnReference) {
     struct Real {
-        double Value;
+        double value;
     };
 
     struct Complex {
-        double Real;
-        double Imag;
+        double real;
+        double imag;
     };
 
     std::variant<Real, Complex> var_real = Real{1.0};
@@ -93,45 +93,45 @@ TEST(OverloadedTest, ReturnReference) {
 
     std::visit(
         utils::Overloaded{
-            [](Real& real) -> double& { return real.Value; },
-            [](Complex& complex) -> double& { return complex.Real; },
+            [](Real& real) -> double& { return real.value; },
+            [](Complex& complex) -> double& { return complex.real; },
         },
         var_real
     ) = 2.0;
-    EXPECT_EQ(std::get<Real>(var_real).Value, 2.0);
+    EXPECT_EQ(std::get<Real>(var_real).value, 2.0);
 
     utils::Visit(
         var_real,
-        [](Real& realvalue) -> double& { return realvalue.Value; },
-        [](Complex& complex) -> double& { return complex.Real; }
+        [](Real& realvalue) -> double& { return realvalue.value; },
+        [](Complex& complex) -> double& { return complex.real; }
     ) = 3.0;
-    EXPECT_EQ(std::get<Real>(var_real).Value, 3.0);
+    EXPECT_EQ(std::get<Real>(var_real).value, 3.0);
 
     std::visit(
         utils::Overloaded{
-            [](Real& real) -> double& { return real.Value; },
-            [](Complex& complex) -> double& { return complex.Real; },
+            [](Real& real) -> double& { return real.value; },
+            [](Complex& complex) -> double& { return complex.real; },
         },
         var_complex
     ) = 4.0;
-    EXPECT_EQ(std::get<Complex>(var_complex).Real, 4.0);
+    EXPECT_EQ(std::get<Complex>(var_complex).real, 4.0);
 
     utils::Visit(
         var_complex,
-        [](Real& real) -> double& { return real.Value; },
-        [](Complex& complex) -> double& { return complex.Real; }
+        [](Real& real) -> double& { return real.value; },
+        [](Complex& complex) -> double& { return complex.real; }
     ) = 5.0;
-    EXPECT_EQ(std::get<Complex>(var_complex).Real, 5.0);
+    EXPECT_EQ(std::get<Complex>(var_complex).real, 5.0);
 }
 
 TEST(OverloadedTest, NoCopying) {
     struct Complex {
-        double Real;
-        double Imag;
+        double real;
+        double imag;
 
-        Complex() : Real{}, Imag{} {}
+        Complex() : real{}, imag{} {}
 
-        Complex(double r, double i) : Real{r}, Imag{i} {}
+        Complex(double r, double i) : real{r}, imag{i} {}
 
         Complex(const Complex&) = delete;
         Complex& operator=(const Complex&) = delete;
@@ -141,8 +141,8 @@ TEST(OverloadedTest, NoCopying) {
     var_complex.emplace<Complex>(2.0, 3.0);
 
     utils::Visit(std::move(var_complex), [](Complex&& complex) {
-        EXPECT_EQ(complex.Real, 2.0);
-        EXPECT_EQ(complex.Imag, 3.0);
+        EXPECT_EQ(complex.real, 2.0);
+        EXPECT_EQ(complex.imag, 3.0);
     });
 }
 
diff --git a/universal/src/utils/small_string_benchmark.cpp b/universal/src/utils/small_string_benchmark.cpp
index d886af58ef87..b9d52aa43bc8 100644
--- a/universal/src/utils/small_string_benchmark.cpp
+++ b/universal/src/utils/small_string_benchmark.cpp
@@ -19,25 +19,25 @@ std::string GenerateString(size_t size) {
     return Launder(std::move(result));
 }
 
-static void SmallString_Std(benchmark::State& state) {
+static void SmallStringStd(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
     for ([[maybe_unused]] auto _ : state) {
         std::string str{s};
         benchmark::DoNotOptimize(str);
     }
 }
-BENCHMARK(SmallString_Std)->Range(2, 2 << 10);
+BENCHMARK(SmallStringStd)->Range(2, 2 << 10);
 
-static void SmallString_Small(benchmark::State& state) {
+static void SmallStringSmall(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
     for ([[maybe_unused]] auto _ : state) {
         utils::SmallString<1000> str{s};
         benchmark::DoNotOptimize(str);
     }
 }
-BENCHMARK(SmallString_Small)->Range(2, 2 << 10);
+BENCHMARK(SmallStringSmall)->Range(2, 2 << 10);
 
-static void SmallString_Std_Copy(benchmark::State& state) {
+static void SmallStringStdCopy(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
     std::array<std::string, kArraySize> str;
     std::array<std::string, kArraySize> str2;
@@ -49,9 +49,9 @@ static void SmallString_Std_Copy(benchmark::State& state) {
         state.ResumeTiming();
     }
 }
-BENCHMARK(SmallString_Std_Copy)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
+BENCHMARK(SmallStringStdCopy)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
 
-static void SmallString_Small_Copy(benchmark::State& state) {
+static void SmallStringSmallCopy(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
     std::array<utils::SmallString<1000>, kArraySize> str;
     std::array<utils::SmallString<1000>, kArraySize> str2;
@@ -63,9 +63,9 @@ static void SmallString_Small_Copy(benchmark::State& state) {
         state.ResumeTiming();
     }
 }
-BENCHMARK(SmallString_Small_Copy)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
+BENCHMARK(SmallStringSmallCopy)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
 
-static void SmallString_Std_Move(benchmark::State& state) {
+static void SmallStringStdMove(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
     std::array<std::string, kArraySize> str;
     std::array<std::string, kArraySize> str2;
@@ -77,9 +77,9 @@ static void SmallString_Std_Move(benchmark::State& state) {
         state.ResumeTiming();
     }
 }
-BENCHMARK(SmallString_Std_Move)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
+BENCHMARK(SmallStringStdMove)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
 
-static void SmallString_Small_Move(benchmark::State& state) {
+static void SmallStringSmallMove(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
     std::array<utils::SmallString<1000>, kArraySize> str;
     std::array<utils::SmallString<1000>, kArraySize> str2;
@@ -91,7 +91,7 @@ static void SmallString_Small_Move(benchmark::State& state) {
         state.ResumeTiming();
     }
 }
-BENCHMARK(SmallString_Small_Move)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
+BENCHMARK(SmallStringSmallMove)->Range(2, 2 << 10)->Unit(benchmark::kMicrosecond);
 
 static void SmallStringResizeAndOverwrite(benchmark::State& state) {
     auto s = GenerateString(state.range(0));
@@ -100,8 +100,8 @@ static void SmallStringResizeAndOverwrite(benchmark::State& state) {
     for (auto& x : str) x = s;
     for ([[maybe_unused]] auto _ : state) {
         for (size_t i = 0; i < str.size(); i++)
-            str2[i].resize_and_overwrite(str[i].size(), [&](char* data_, size_t size) {
-                std::copy(str[i].data(), str[i].data() + str[i].size(), data_);
+            str2[i].resize_and_overwrite(str[i].size(), [&](char* data, size_t size) {
+                std::copy(str[i].data(), str[i].data() + str[i].size(), data);
                 return size;
             });
         state.PauseTiming();
diff --git a/universal/src/utils/strerror.cpp b/universal/src/utils/strerror.cpp
index 0b3d370dbab7..6e2af61d5ec6 100644
--- a/universal/src/utils/strerror.cpp
+++ b/universal/src/utils/strerror.cpp
@@ -15,12 +15,12 @@ namespace {
 
 // SFINAE on sigdescr_np
 template <class Int>
-auto try_sigdescr_np(Int signal_num) noexcept -> decltype(sigdescr_np(signal_num)) {
+auto TrySigdescrNp(Int signal_num) noexcept -> decltype(sigdescr_np(signal_num)) {
     return sigdescr_np(signal_num);
 }
 
 template <class... Args>
-const char* try_sigdescr_np(Args...) noexcept {
+const char* TrySigdescrNp(Args...) noexcept {
 #if ((__GLIBC__ * 100 + __GLIBC_MINOR__) >= 232)
     static_assert(
         sizeof...(Args) && false,
@@ -39,7 +39,7 @@ std::string strerror(int return_code) {
 }
 
 std::string strsignal(int signal_num) {
-    if (const auto* descr = utils::try_sigdescr_np(signal_num); descr) {
+    if (const auto* descr = utils::TrySigdescrNp(signal_num); descr) {
         return descr;
     }
 
diff --git a/universal/src/utils/string_to_duration.cpp b/universal/src/utils/string_to_duration.cpp
index 9f31510a4367..a5f39076da33 100644
--- a/universal/src/utils/string_to_duration.cpp
+++ b/universal/src/utils/string_to_duration.cpp
@@ -13,7 +13,7 @@ namespace utils {
 namespace {
 
 template <class Rep, class Period>
-std::chrono::milliseconds checked_convert(std::chrono::duration<Rep, Period> d, std::string_view data) {
+std::chrono::milliseconds CheckedConvert(std::chrono::duration<Rep, Period> d, std::string_view data) {
     const std::chrono::duration<long double, std::chrono::milliseconds::period> extended_duration{d};
     if (extended_duration > std::chrono::milliseconds::max()) {
         throw std::overflow_error(fmt::format("StringToDuration overflow while representing '{}' as ms", data));
@@ -43,16 +43,16 @@ std::chrono::milliseconds StringToDuration(std::string_view data) {
     const std::string_view remained{end, static_cast<std::size_t>(str_end - end)};
 
     if (remained.empty() || remained == "s") {
-        return checked_convert(std::chrono::seconds{new_to}, data);
+        return CheckedConvert(std::chrono::seconds{new_to}, data);
     } else if (remained == "ms") {
-        return checked_convert(std::chrono::milliseconds{new_to}, data);
+        return CheckedConvert(std::chrono::milliseconds{new_to}, data);
     } else if (remained == "m") {
-        return checked_convert(std::chrono::minutes{new_to}, data);
+        return CheckedConvert(std::chrono::minutes{new_to}, data);
     } else if (remained == "h") {
-        return checked_convert(std::chrono::hours{new_to}, data);
+        return CheckedConvert(std::chrono::hours{new_to}, data);
     } else if (remained == "d") {
         using Days = std::chrono::duration<int64_t, std::ratio<60 * 60 * 24>>;
-        return checked_convert(Days{new_to}, data);
+        return CheckedConvert(Days{new_to}, data);
     }
 
     throw std::logic_error(fmt::format("StringToDuration: unknown format specifier '{}' in string '{}'", remained, data)
diff --git a/universal/src/utils/string_to_duration_test.cpp b/universal/src/utils/string_to_duration_test.cpp
index f525da8e5275..f98c57844c46 100644
--- a/universal/src/utils/string_to_duration_test.cpp
+++ b/universal/src/utils/string_to_duration_test.cpp
@@ -6,21 +6,21 @@ USERVER_NAMESPACE_BEGIN
 
 namespace {
 
-struct data_t {
+struct DataT {
     const char* const name;
     const char* const data;
     const std::chrono::milliseconds ethalon;
 };
 
-inline std::string PrintToString(const data_t& d) { return d.name; }
+inline std::string PrintToString(const DataT& d) { return d.name; }
 
-using TestData = std::initializer_list<data_t>;
+using TestData = std::initializer_list<DataT>;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class StringToDuration : public ::testing::TestWithParam<data_t> {};
+class StringToDuration : public ::testing::TestWithParam<DataT> {};
 
 INSTANTIATE_TEST_SUITE_P(
     /*no prefix*/,
diff --git a/universal/src/utils/traceful_exception.cpp b/universal/src/utils/traceful_exception.cpp
index ecb61abb0fde..3d4064f52e88 100644
--- a/universal/src/utils/traceful_exception.cpp
+++ b/universal/src/utils/traceful_exception.cpp
@@ -22,10 +22,10 @@ boost::stacktrace::stacktrace CollectTrace(TracefulException::TraceMode trace_mo
 }  // namespace
 
 struct TracefulExceptionBase::Impl final {
-    explicit Impl(TraceMode trace_mode) : stacktrace_(CollectTrace(trace_mode)) {}
+    explicit Impl(TraceMode trace_mode) : stacktrace(CollectTrace(trace_mode)) {}
 
-    MemoryBuffer message_buffer_;
-    boost::stacktrace::stacktrace stacktrace_;
+    MemoryBuffer message_buffer;
+    boost::stacktrace::stacktrace stacktrace;
 };
 
 TracefulExceptionBase::TracefulExceptionBase(TracefulExceptionBase&& other) noexcept : impl_(std::move(other.impl_)) {
@@ -35,8 +35,8 @@ TracefulExceptionBase::TracefulExceptionBase(TracefulExceptionBase&& other) noex
 TracefulExceptionBase::~TracefulExceptionBase() = default;
 
 void TracefulExceptionBase::EnsureNullTerminated() {
-    impl_->message_buffer_.reserve(impl_->message_buffer_.size() + 1);
-    impl_->message_buffer_[impl_->message_buffer_.size()] = '\0';
+    impl_->message_buffer.reserve(impl_->message_buffer.size() + 1);
+    impl_->message_buffer[impl_->message_buffer.size()] = '\0';
 }
 
 const char* TracefulException::what() const noexcept {
@@ -44,21 +44,21 @@ const char* TracefulException::what() const noexcept {
 }
 
 const TracefulExceptionBase::MemoryBuffer& TracefulExceptionBase::MessageBuffer() const noexcept {
-    return impl_->message_buffer_;
+    return impl_->message_buffer;
 }
 
-const boost::stacktrace::stacktrace& TracefulExceptionBase::Trace() const noexcept { return impl_->stacktrace_; }
+const boost::stacktrace::stacktrace& TracefulExceptionBase::Trace() const noexcept { return impl_->stacktrace; }
 
 TracefulExceptionBase::TracefulExceptionBase() : TracefulExceptionBase(TraceMode::kAlways) {}
 
 TracefulExceptionBase::TracefulExceptionBase(std::string_view what) : TracefulExceptionBase(TraceMode::kAlways) {
-    fmt::format_to(std::back_inserter(impl_->message_buffer_), FMT_COMPILE("{}"), what);
+    fmt::format_to(std::back_inserter(impl_->message_buffer), FMT_COMPILE("{}"), what);
     EnsureNullTerminated();
 }
 
 TracefulExceptionBase::TracefulExceptionBase(TraceMode trace_mode) : impl_(trace_mode) {}
 
-TracefulExceptionBase::MemoryBuffer& TracefulExceptionBase::GetMessageBuffer() { return impl_->message_buffer_; }
+TracefulExceptionBase::MemoryBuffer& TracefulExceptionBase::GetMessageBuffer() { return impl_->message_buffer; }
 
 }  // namespace utils
 
diff --git a/universal/src/utils/widget_fast_pimpl_test.cpp b/universal/src/utils/widget_fast_pimpl_test.cpp
index ca013ccd3351..ad849a4d313d 100644
--- a/universal/src/utils/widget_fast_pimpl_test.cpp
+++ b/universal/src/utils/widget_fast_pimpl_test.cpp
@@ -8,7 +8,7 @@ namespace sample {
 struct Widget::Impl {  // Implementation to hide
     int Do(short param) const;
 
-    Ugly payload_;  // Something ugly from "third_party_ugly.hpp"
+    Ugly payload;  // Something ugly from "third_party_ugly.hpp"
 };
 
 Widget::Widget() : pimpl_(Impl{/*some initializers*/}) {}
diff --git a/universal/src/yaml_config/iterator.cpp b/universal/src/yaml_config/iterator.cpp
index 3fd4c79523f2..2580454c0cff 100644
--- a/universal/src/yaml_config/iterator.cpp
+++ b/universal/src/yaml_config/iterator.cpp
@@ -27,19 +27,19 @@ std::string_view RemoveInternalSuffix(std::string_view key) noexcept {
 
 }  // namespace
 
-template <typename iter_traits>
-Iterator<iter_traits>::Iterator(const Iterator<iter_traits>& other) : container_(other.container_), it_(other.it_) {
+template <typename IterTraits>
+Iterator<IterTraits>::Iterator(const Iterator<IterTraits>& other) : container_(other.container_), it_(other.it_) {
     current_.reset();
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>::Iterator(Iterator<iter_traits>&& other) noexcept
+template <typename IterTraits>
+Iterator<IterTraits>::Iterator(Iterator<IterTraits>&& other) noexcept
     : container_(std::exchange(other.container_, nullptr)), it_(std::move(other.it_)) {
     current_.reset();
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>& Iterator<iter_traits>::operator=(const Iterator<iter_traits>& other) {
+template <typename IterTraits>
+Iterator<IterTraits>& Iterator<IterTraits>::operator=(const Iterator<IterTraits>& other) {
     if (this == &other) return *this;
 
     it_ = other.it_;
@@ -49,8 +49,8 @@ Iterator<iter_traits>& Iterator<iter_traits>::operator=(const Iterator<iter_trai
     return *this;
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>& Iterator<iter_traits>::operator=(Iterator<iter_traits>&& other) noexcept {
+template <typename IterTraits>
+Iterator<IterTraits>& Iterator<IterTraits>::operator=(Iterator<IterTraits>&& other) noexcept {
     it_ = std::move(other.it_);
     container_ = std::exchange(other.container_, nullptr);
     current_.reset();
@@ -58,26 +58,26 @@ Iterator<iter_traits>& Iterator<iter_traits>::operator=(Iterator<iter_traits>&&
     return *this;
 }
 
-template <typename iter_traits>
-Iterator<iter_traits> Iterator<iter_traits>::operator++(int) {
+template <typename IterTraits>
+Iterator<IterTraits> Iterator<IterTraits>::operator++(int) {
     auto it_copy = it_;
     IncrementInternalIterator();
     return Iterator{*container_, std::move(it_copy)};
 }
 
-template <typename iter_traits>
-Iterator<iter_traits>& Iterator<iter_traits>::operator++() {
+template <typename IterTraits>
+Iterator<IterTraits>& Iterator<IterTraits>::operator++() {
     IncrementInternalIterator();
     return *this;
 }
 
-template <typename iter_traits>
-std::string Iterator<iter_traits>::GetName() const {
+template <typename IterTraits>
+std::string Iterator<IterTraits>::GetName() const {
     return std::string{yaml_config::RemoveInternalSuffix(it_.GetName())};
 }
 
-template <typename iter_traits>
-void Iterator<iter_traits>::UpdateValue() const {
+template <typename IterTraits>
+void Iterator<IterTraits>::UpdateValue() const {
     UASSERT(container_ != nullptr);
     if (current_) return;
 
@@ -89,8 +89,8 @@ void Iterator<iter_traits>::UpdateValue() const {
     }
 }
 
-template <typename iter_traits>
-void Iterator<iter_traits>::IncrementInternalIterator() {
+template <typename IterTraits>
+void Iterator<IterTraits>::IncrementInternalIterator() {
     current_.reset();
 
     if (it_.GetIteratorType() != formats::common::Type::kObject) {
diff --git a/universal/src/yaml_config/yaml_config.cpp b/universal/src/yaml_config/yaml_config.cpp
index 522b7202f580..1a6bb0bb0971 100644
--- a/universal/src/yaml_config/yaml_config.cpp
+++ b/universal/src/yaml_config/yaml_config.cpp
@@ -67,7 +67,8 @@ std::optional<formats::yaml::Value> GetFromEnvImpl(const formats::yaml::Value& e
     // NOLINTNEXTLINE(concurrency-mt-unsafe)
     const auto* env_value = std::getenv(env_name.As<std::string>().c_str());
     if (env_value) {
-        return formats::yaml::FromString(env_value);
+        formats::yaml::ValueBuilder builder{env_value};
+        return builder.ExtractValue();
     }
 
     return {};
diff --git a/universal/src/yaml_config/yaml_config_test.cpp b/universal/src/yaml_config/yaml_config_test.cpp
index ec13a202e6a7..6ef814238910 100644
--- a/universal/src/yaml_config/yaml_config_test.cpp
+++ b/universal/src/yaml_config/yaml_config_test.cpp
@@ -6,8 +6,10 @@
 #include <gtest/gtest.h>
 
 #include <formats/common/value_test.hpp>
+#include <userver/formats/common/utils.hpp>
 #include <userver/formats/json/serialize.hpp>
 #include <userver/formats/json/value.hpp>
+#include <userver/formats/json/value_builder.hpp>
 #include <userver/formats/yaml/serialize.hpp>
 #include <userver/formats/yaml/value.hpp>
 #include <userver/formats/yaml/value_builder.hpp>
@@ -66,14 +68,28 @@ TEST(YamlConfig, SampleEnv) {
     /// [sample env]
     auto node = formats::yaml::FromString(R"(
     some_element:
-        some#env: ENV_VARIABLE_NAME
+        int#env: INT_VARIABLE_NAME
+        valid_yaml#env: VALID_YAML_VARIABLE_NAME
+        invalid_yaml#env: INVALID_YAML_VARIABLE_NAME
+        empty#env: EMPTY_VARIABLE_NAME
+        missing#env: MISSING_VARIABLE_NAME
   )");
 
     // NOLINTNEXTLINE(concurrency-mt-unsafe)
-    ::setenv("ENV_VARIABLE_NAME", "100", 1);
+    ::setenv("INT_VARIABLE_NAME", "100", 1);
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
+    ::setenv("VALID_YAML_VARIABLE_NAME", "x: [5]", 1);
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
+    ::setenv("INVALID_YAML_VARIABLE_NAME", "[::]:1234", 1);
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
+    ::setenv("EMPTY_VARIABLE_NAME", "", 1);
 
     const yaml_config::YamlConfig yaml(std::move(node), {}, yaml_config::YamlConfig::Mode::kEnvAllowed);
-    EXPECT_EQ(yaml["some_element"]["some"].As<int>(), 100);
+    EXPECT_EQ(yaml["some_element"]["int"].As<std::string>(), "100");
+    EXPECT_EQ(yaml["some_element"]["valid_yaml"].As<std::string>(), "x: [5]");
+    EXPECT_EQ(yaml["some_element"]["invalid_yaml"].As<std::string>(), "[::]:1234");
+    EXPECT_EQ(yaml["some_element"]["empty"].As<std::string>(), "");
+    EXPECT_TRUE(yaml["some_element"]["missing"].IsMissing());
     /// [sample env]
 }
 
@@ -386,7 +402,7 @@ template <typename Accessor>
 class YamlConfigAccessor : public ::testing::Test {};
 
 struct SquareBracketAccessor {
-    explicit SquareBracketAccessor(const yaml_config::YamlConfig& value_) : value(value_) {}
+    explicit SquareBracketAccessor(const yaml_config::YamlConfig& value) : value(value) {}
 
     template <typename X>
     auto Access(X&& arg) const {
@@ -400,7 +416,7 @@ struct SquareBracketAccessor {
 };
 
 struct IteratorAccessor {
-    explicit IteratorAccessor(const yaml_config::YamlConfig& value_) : value(value_) {}
+    explicit IteratorAccessor(const yaml_config::YamlConfig& value) : value(value) {}
 
     auto Access(size_t index) const {
         auto it = value.begin();
@@ -869,4 +885,40 @@ bar: baz
     ::unsetenv("ANOTHER_ENV_VARIABLE");
 }
 
+template <typename Value>
+std::size_t CountDepth(const Value& value) {
+    std::size_t depth = 0;
+    auto value_ref = value;
+    while (value_ref.IsObject()) {
+        value_ref = value_ref["obj"];
+        ++depth;
+    }
+    return depth;
+}
+
+TEST(YamlConfig, DeepYamlToJson) {
+    constexpr std::size_t kDepth = 30;
+    std::vector<std::string> path(kDepth, "obj");
+    path.push_back("key");
+
+    formats::yaml::ValueBuilder yaml_builder;
+    formats::common::SetAtPath(yaml_builder, std::vector(path), formats::yaml::ValueBuilder("value").ExtractValue());
+    const auto node = yaml_builder.ExtractValue();
+
+    formats::json::ValueBuilder expected_json_builder;
+    formats::common::SetAtPath(
+        expected_json_builder, std::vector(path), formats::json::ValueBuilder("value").ExtractValue()
+    );
+    const auto expected_json = expected_json_builder.ExtractValue();
+
+    const yaml_config::YamlConfig yaml{node, {}};
+    const auto json = yaml.As<formats::json::Value>();
+
+    EXPECT_EQ(json, expected_json) << "Actual json value:\n"
+                                   << ToString(json) << "\n  actual json depth: " << CountDepth(json)
+                                   << "\n  expected json value:\n"
+                                   << ToString(expected_json)
+                                   << "\n  expected json depth: " << CountDepth(expected_json);
+}
+
 USERVER_NAMESPACE_END
diff --git a/universal/utest/include/userver/utest/literals.hpp b/universal/utest/include/userver/utest/literals.hpp
index 2f95b6389b4a..9d2b21846b64 100644
--- a/universal/utest/include/userver/utest/literals.hpp
+++ b/universal/utest/include/userver/utest/literals.hpp
@@ -1,4 +1,10 @@
 #pragma once
 
+USERVER_NAMESPACE_BEGIN
+
+namespace formats::literals {}
+
+USERVER_NAMESPACE_END
+
 // NOLINTNEXTLINE(google-build-using-namespace, google-global-names-in-headers)
 using namespace USERVER_NAMESPACE::formats::literals;
diff --git a/universal/utest/include/userver/utest/parameter_names.hpp b/universal/utest/include/userver/utest/parameter_names.hpp
index 3c4ab7cb93e8..f5afc72bda5c 100644
--- a/universal/utest/include/userver/utest/parameter_names.hpp
+++ b/universal/utest/include/userver/utest/parameter_names.hpp
@@ -22,7 +22,7 @@ using HasTestName = decltype(T::test_name);
 
 template <typename ParamType>
 std::string TestParamToString(const ParamType& param) {
-    if constexpr (meta::kIsDetected<HasTestName, ParamType>) {
+    if constexpr (meta::IsDetected<HasTestName, ParamType>) {
         static_assert(std::is_same_v<std::string, decltype(param.test_name)>, "Test name should be a string");
         return param.test_name;
     } else {
@@ -100,7 +100,7 @@ std::string TestTupleParamToString(const std::tuple<Args...>& params_tuple) {
 struct PrintTestName final {
     template <typename ParamType>
     std::string operator()(const testing::TestParamInfo<ParamType>& info) const {
-        if constexpr (meta::kIsDetected<impl::HasTupleSize, ParamType>) {
+        if constexpr (meta::IsDetected<impl::HasTupleSize, ParamType>) {
             return impl::TestTupleParamToString(info.param);
         } else {
             return impl::TestParamToString(info.param);
diff --git a/version.txt b/version.txt
new file mode 100644
index 000000000000..a80320a998e5
--- /dev/null
+++ b/version.txt
@@ -0,0 +1 @@
+2.13-rc
diff --git a/ydb/CMakeLists.txt b/ydb/CMakeLists.txt
index e21d95df2bc5..ee5d7cacd561 100644
--- a/ydb/CMakeLists.txt
+++ b/ydb/CMakeLists.txt
@@ -23,6 +23,7 @@ userver_module(
     INCLUDE_DIRS ${ydb-cpp-sdk_INCLUDE_DIRS}
     UTEST_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests"
     GENERATE_DYNAMIC_CONFIGS
+    DEPENDS core
 )
 
 # Enforce that userver-ydb requires C++20
diff --git a/ydb/include/userver/ydb/table.hpp b/ydb/include/userver/ydb/table.hpp
index 2a322c7d5284..bf7428013205 100644
--- a/ydb/include/userver/ydb/table.hpp
+++ b/ydb/include/userver/ydb/table.hpp
@@ -48,6 +48,13 @@ using DescribeTableSettings = NYdb::NTable::TDescribeTableSettings;
 using DropTableSettings = NYdb::NTable::TDropTableSettings;
 using ScanQuerySettings = NYdb::NTable::TStreamExecScanQuerySettings;
 
+/// @brief A dynamic transaction name for @see TableClient::Begin.
+///
+/// @warning Make sure that transaction name has low cardinality.
+/// If transaction name is unique for every call, per-transaction metrics will overflow metrics quota,
+/// and metrics will become unusable.
+using DynamicTransactionName = utils::StrongTypedef<struct DynamicTransactionNameTag, std::string>;
+
 class TableClient final {
 public:
     /// @cond
@@ -116,9 +123,14 @@ class TableClient final {
     /// @see ydb::Transaction
     ///
     /// @{
-    Transaction Begin(std::string transaction_name, OperationSettings settings = {});
+    Transaction Begin(utils::StringLiteral transaction_name, OperationSettings settings = {});
+
+    /// @warning Make sure that `transaction_name` has low cardinality.
+    /// If `transaction_name` is unique for every call, per-transaction metrics will overflow metrics quota,
+    /// and metrics will become unusable.
+    Transaction Begin(DynamicTransactionName transaction_name, OperationSettings settings = {});
 
-    Transaction Begin(std::string transaction_name, TransactionMode tx_mode);
+    Transaction Begin(utils::StringLiteral transaction_name, TransactionMode tx_mode);
     /// @}
 
     /// Builder for storing dynamic query params.
diff --git a/ydb/include/userver/ydb/transaction.hpp b/ydb/include/userver/ydb/transaction.hpp
index 1f8479083bd4..bdf103f924bc 100644
--- a/ydb/include/userver/ydb/transaction.hpp
+++ b/ydb/include/userver/ydb/transaction.hpp
@@ -3,6 +3,7 @@
 #include <string>
 
 #include <userver/tracing/span.hpp>
+#include <userver/utils/trx_tracker.hpp>
 
 #include <userver/ydb/builder.hpp>
 #include <userver/ydb/exceptions.hpp>
@@ -87,6 +88,7 @@ class Transaction final {
     NYdb::NTable::TTransaction ydb_tx_;
     OperationSettings rollback_settings_;
     bool is_active_{true};
+    utils::trx_tracker::TransactionLock trx_lock_;
 };
 
 template <typename... Args>
diff --git a/ydb/src/ydb/impl/request_context.cpp b/ydb/src/ydb/impl/request_context.cpp
index 636490643b28..4a95bc562b67 100644
--- a/ydb/src/ydb/impl/request_context.cpp
+++ b/ydb/src/ydb/impl/request_context.cpp
@@ -150,14 +150,14 @@ engine::Deadline GetDeadline(tracing::Span& span, const dynamic_config::Snapshot
 }  // namespace
 
 RequestContext::RequestContext(
-    TableClient& table_client_,
+    TableClient& l_table_client,
     const Query& query,
     OperationSettings&& settings,
     IsStreaming is_streaming,
     tracing::Span* custom_parent_span,
     const utils::impl::SourceLocation& location
 )
-    : table_client(table_client_),
+    : table_client(l_table_client),
       settings(std::move(settings)),
       initial_uncaught_exceptions(std::uncaught_exceptions()),
       stats_scope(*table_client.stats_, query),
@@ -176,7 +176,7 @@ void RequestContext::HandleError(const NYdb::TStatus& status) {
     UASSERT(!status.IsSuccess());
     // To protect against double handling of error in the 'HandleError` and in the
     // destructor we have to set the flag
-    is_error_ = true;
+    is_error = true;
     span.AddTag(tracing::kErrorFlag, true);
     if (status.IsTransportError()) {
         stats_scope.OnTransportError();
@@ -186,7 +186,7 @@ void RequestContext::HandleError(const NYdb::TStatus& status) {
 }
 
 RequestContext::~RequestContext() {
-    if (engine::current_task::ShouldCancel() && !is_error_) {
+    if (engine::current_task::ShouldCancel() && !is_error) {
         stats_scope.OnCancelled();
         span.AddTag("cancelled", true);
     }
diff --git a/ydb/src/ydb/impl/request_context.hpp b/ydb/src/ydb/impl/request_context.hpp
index dcf747f19230..1673d83ccc84 100644
--- a/ydb/src/ydb/impl/request_context.hpp
+++ b/ydb/src/ydb/impl/request_context.hpp
@@ -39,7 +39,7 @@ struct RequestContext final {
     dynamic_config::Snapshot config_snapshot;
     tracing::Span span;
     engine::Deadline deadline;
-    bool is_error_{false};
+    bool is_error{false};
 };
 
 }  // namespace ydb::impl
diff --git a/ydb/src/ydb/table.cpp b/ydb/src/ydb/table.cpp
index 013beaf6015f..8a3ec6f9df77 100644
--- a/ydb/src/ydb/table.cpp
+++ b/ydb/src/ydb/table.cpp
@@ -298,13 +298,17 @@ void TableClient::DropTable(std::string_view path, DropTableSettings query_setti
     );
 }
 
-Transaction TableClient::Begin(std::string transaction_name, TransactionMode tx_mode) {
+Transaction TableClient::Begin(utils::StringLiteral transaction_name, TransactionMode tx_mode) {
     OperationSettings settings{};
     settings.tx_mode = tx_mode;
-    return Begin(std::move(transaction_name), std::move(settings));
+    return Begin(transaction_name, std::move(settings));
 }
 
-Transaction TableClient::Begin(std::string transaction_name, OperationSettings settings) {
+Transaction TableClient::Begin(utils::StringLiteral transaction_name, OperationSettings settings) {
+    return Begin(DynamicTransactionName{transaction_name.data()}, std::move(settings));
+}
+
+Transaction TableClient::Begin(DynamicTransactionName transaction_name, OperationSettings settings) {
     const Query query{"", Query::Name{"Begin"}};
     impl::RequestContext context{*this, query, std::move(settings)};
     auto tx_settings = PrepareTxSettings(context.settings);
@@ -320,7 +324,7 @@ Transaction TableClient::Begin(std::string transaction_name, OperationSettings s
     );
 
     auto status = impl::GetFutureValueChecked(std::move(future), "BeginTransaction", context);
-    return Transaction(*this, status.GetTransaction(), std::move(transaction_name), std::move(settings));
+    return Transaction(*this, status.GetTransaction(), transaction_name.GetUnderlying(), std::move(settings));
 }
 
 void TableClient::ExecuteSchemeQuery(const std::string& query) {
diff --git a/ydb/src/ydb/transaction.cpp b/ydb/src/ydb/transaction.cpp
index 18b9b08f11a4..3278db9b7cbe 100644
--- a/ydb/src/ydb/transaction.cpp
+++ b/ydb/src/ydb/transaction.cpp
@@ -32,6 +32,7 @@ Transaction::Transaction(
       rollback_settings_(std::move(rollback_settings)) {
     span_.DetachFromCoroStack();
     span_.AddTag("transaction_name", name_);
+    trx_lock_.Lock();
 }
 
 Transaction::~Transaction() {
@@ -95,6 +96,7 @@ void Transaction::Commit(OperationSettings settings) {
 
     error_guard.Release();
     is_active_ = false;
+    trx_lock_.Unlock();
 }
 
 void Transaction::Rollback() {
@@ -113,6 +115,8 @@ void Transaction::Rollback() {
         ydb_tx_.Rollback(rollback_settings), "Rollback", table_client_.driver_->GetRetryBudget(), context
     );
 
+    trx_lock_.Unlock();
+
     // Successful rollback is still a transaction error for logs and stats.
 }
 
diff --git a/ydb/tests/parallel_data_query_test.cpp b/ydb/tests/parallel_data_query_test.cpp
index 477fdcdbe24e..eedb67201b36 100644
--- a/ydb/tests/parallel_data_query_test.cpp
+++ b/ydb/tests/parallel_data_query_test.cpp
@@ -15,10 +15,10 @@ namespace {
 
 class YdbExecuteParallelDataQuery : public YdbSmallTableTest {};
 
-void WaitSessionCountIsZero(const NYdb::NTable::TTableClient& table_client_) {
+void WaitSessionCountIsZero(const NYdb::NTable::TTableClient& table_client) {
     constexpr auto sleep = std::chrono::milliseconds{10};
     const auto deadline{engine::Deadline::FromDuration(utest::kMaxTestWaitTime)};
-    while (table_client_.GetActiveSessionCount() != 0) {
+    while (table_client.GetActiveSessionCount() != 0) {
         engine::SleepFor(sleep);
         if (deadline.IsReached()) {
             throw std::runtime_error{"Session count is not zero"};