# @hsuite/throttler-types - Rate Limiting Type Definitions

> ⚡ **Comprehensive TypeScript type definitions for HSuite Rate Limiting ecosystem with flexible storage backends**

Enterprise-grade type definitions and interfaces providing a robust foundation for implementing rate limiting functionality across NestJS applications with support for Redis, in-memory storage, and dynamic configuration patterns.

***

## 📚 Table of Contents

* [✨ Quick Start](#-quick-start)
* [🏗️ Architecture](#️-architecture)
* [🔧 API Reference](#-api-reference)
* [📖 Guides](#-guides)
* [🎯 Examples](#-examples)
* [🔗 Integration](#-integration)

***

## ✨ Quick Start

### Installation

```bash
npm install @hsuite/throttler-types
```

### Basic Setup

```typescript
import { IThrottler, Throttler } from '@hsuite/throttler-types';

// Interface-based type definitions
const options: IThrottler.IOptions = {
  enabled: true,
  settings: {
    ttl: 60,    // Time window in seconds
    limit: 100  // Maximum requests per window
  },
  storage: IThrottler.IStorage.REDIS,
  redis: {
    host: 'localhost',
    port: 6379
  }
};
```

### NestJS Integration

```typescript
import { ThrottlerModule } from '@hsuite/throttler';
import { IThrottler } from '@hsuite/throttler-types';

@Module({
  imports: [
    ThrottlerModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService): Promise<IThrottler.IOptions> => ({
        enabled: configService.get<boolean>('THROTTLE_ENABLED', true),
        settings: {
          ttl: configService.get<number>('THROTTLE_TTL', 60),
          limit: configService.get<number>('THROTTLE_LIMIT', 100)
        },
        storage: IThrottler.IStorage.REDIS,
        redis: {
          host: configService.get<string>('REDIS_HOST', 'localhost'),
          port: configService.get<number>('REDIS_PORT', 6379)
        }
      }),
      inject: [ConfigService]
    })
  ]
})
export class AppModule {}
```

***

## 🏗️ Architecture

### Core Component Areas

#### ⚡ **Rate Limiting Foundation**

* **Storage Backends** - Redis and in-memory storage options for scalability
* **Configuration Management** - Flexible settings for TTL, limits, and storage
* **Factory Patterns** - Dynamic configuration with dependency injection
* **Type Safety** - Comprehensive TypeScript interfaces and validation

#### 🏭 **Factory Pattern Integration**

* **Options Factory** - Interface for dynamic configuration creation
* **Async Configuration** - Support for runtime configuration loading
* **Dependency Injection** - Clean integration with NestJS DI system
* **Environment Flexibility** - Different configurations for various environments

#### 🔄 **Storage Backend Support**

* **Redis Storage** - Distributed storage for scalable rate limiting
* **In-Memory Storage** - Local storage for simple deployments
* **Configuration Options** - Complete Redis client configuration support
* **Fallback Mechanisms** - Graceful degradation and error handling

#### 🛡️ **Enterprise Features**

* **Multi-Tenant Support** - Tenant-specific rate limiting configurations
* **Tier-Based Limiting** - Different limits based on user tiers
* **Dynamic Adjustment** - Runtime configuration changes
* **Monitoring Integration** - Type-safe monitoring and metrics

### Module Structure

```
src/
├── index.ts                           # Main exports and documentation
├── interfaces/
│   └── throttler.namespace.ts         # Core interfaces and enums
└── models/
    └── throttler.namespace.ts         # Model types and utilities
```

***

## 🔧 API Reference

### Core Interface Types

#### Storage Backend Types

**`IThrottler.IStorage`**

* **Purpose**: Available storage options for persisting throttling data
* **Values**: REDIS, DEFAULT
* **Usage**: Storage backend selection for rate limiting data

#### Configuration Types

**`IThrottler.IOptions`**

* **Purpose**: Complete throttler configuration interface
* **Properties**: enabled, settings, storage, redis
* **Usage**: Main configuration object for throttler setup

**`IThrottler.IOptionsFactory`**

* **Purpose**: Factory interface for dynamic configuration
* **Methods**: createThrottlerOptions()
* **Usage**: Runtime configuration generation

#### Module Configuration Types

**`IThrottler.IModuleAsyncOptions`**

* **Purpose**: Async module configuration for throttler initialization
* **Properties**: useClass, useFactory, inject
* **Usage**: NestJS module async configuration

### Storage Selection Guidelines

| Storage Type | Use Case                     | Scalability | Performance | Complexity |
| ------------ | ---------------------------- | ----------- | ----------- | ---------- |
| **Redis**    | Production, Distributed      | High        | High        | Medium     |
| **Default**  | Development, Single Instance | Low         | Very High   | Low        |

### Configuration Parameters

| Parameter        | Type               | Description              | Default | Required |
| ---------------- | ------------------ | ------------------------ | ------- | -------- |
| `enabled`        | boolean            | Global throttling toggle | -       | Yes      |
| `settings.ttl`   | number             | Time window (seconds)    | -       | Yes      |
| `settings.limit` | number             | Max requests per window  | -       | Yes      |
| `storage`        | IStorage           | Storage backend type     | -       | Yes      |
| `redis`          | RedisClientOptions | Redis configuration      | -       | Yes      |

***

## 📖 Guides

### **Rate Limiting Setup Guide**

Complete guide to setting up rate limiting with different storage backends. Comprehensive setup instructions covering Redis and in-memory storage configuration, TTL and limit settings, environment-specific configurations, and performance optimization for enterprise-scale rate limiting systems.

### **Factory Pattern Guide**

Learn how to implement dynamic configuration with factory patterns. Advanced implementation guide covering factory pattern integration, dynamic configuration loading, environment-based config selection, tenant-specific overrides, and runtime configuration validation for flexible throttling systems.

### **Multi-Tenant Configuration Guide**

Set up tenant-specific and tier-based rate limiting configurations. Detailed guide for implementing multi-tenant rate limiting with tier-based limits, tenant isolation, configuration inheritance, custom Redis key prefixes, and enterprise-grade tenant management.

### **Production Deployment Guide**

Best practices for deploying rate limiting in production environments. Comprehensive deployment guide covering Redis clustering, performance monitoring, error handling, failover strategies, and production optimization for high-availability rate limiting systems.

***

## 🎯 Examples

### Storage Backend Configuration

```typescript
import { IThrottler } from '@hsuite/throttler-types';

@Injectable()
export class ThrottlerStorageService {
  
  // Redis storage configuration for production
  getRedisConfiguration(): IThrottler.IOptions {
    return {
      enabled: true,
      settings: { ttl: 60, limit: 100 },
      storage: IThrottler.IStorage.REDIS,
      redis: {
        host: process.env.REDIS_HOST || 'localhost',
        port: parseInt(process.env.REDIS_PORT || '6379'),
        password: process.env.REDIS_PASSWORD,
        username: process.env.REDIS_USERNAME,
        database: parseInt(process.env.REDIS_DATABASE || '0'),
        retryDelayOnFailover: 100,
        maxRetriesPerRequest: 3,
        connectTimeout: 20000,
        commandTimeout: 5000
      }
    };
  }

  // In-memory storage for development
  getMemoryConfiguration(): IThrottler.IOptions {
    return {
      enabled: true,
      settings: { ttl: 60, limit: 1000 },
      storage: IThrottler.IStorage.DEFAULT,
      redis: {} // Required but empty for in-memory
    };
  }

  // Environment-based configuration selection
  getEnvironmentConfiguration(): IThrottler.IOptions {
    const environment = process.env.NODE_ENV || 'development';
    
    const configs = {
      development: this.getMemoryConfiguration(),
      staging: {
        enabled: true,
        settings: { ttl: 60, limit: 500 },
        storage: IThrottler.IStorage.REDIS,
        redis: { host: 'staging-redis', port: 6379 }
      },
      production: this.getRedisConfiguration()
    };

    return configs[environment] || configs.development;
  }

  validateConfiguration(config: IThrottler.IOptions): boolean {
    return (
      typeof config.enabled === 'boolean' &&
      typeof config.settings.ttl === 'number' &&
      typeof config.settings.limit === 'number' &&
      config.settings.ttl > 0 &&
      config.settings.limit > 0 &&
      Object.values(IThrottler.IStorage).includes(config.storage)
    );
  }
}
```

### Factory Pattern Implementation

```typescript
import { IThrottler } from '@hsuite/throttler-types';
import { Injectable } from '@nestjs/common';

@Injectable()
export class DynamicThrottlerConfigFactory implements IThrottler.IOptionsFactory {
  constructor(
    private readonly configService: ConfigService,
    private readonly tenantService: TenantService
  ) {}

  async createThrottlerOptions(): Promise<IThrottler.IOptions> {
    try {
      // Load base configuration
      const baseConfig = await this.loadBaseConfiguration();
      
      // Apply tenant-specific overrides
      const tenantConfig = await this.loadTenantConfiguration();
      
      // Merge configurations
      const finalConfig = this.mergeConfigurations(baseConfig, tenantConfig);
      
      // Validate final configuration
      this.validateConfiguration(finalConfig);
      
      return finalConfig;
    } catch (error) {
      throw new Error(`Throttler configuration creation failed: ${error.message}`);
    }
  }

  private async loadBaseConfiguration(): Promise<IThrottler.IOptions> {
    const isProduction = process.env.NODE_ENV === 'production';
    
    return {
      enabled: this.configService.get<boolean>('THROTTLING_ENABLED', true),
      settings: {
        ttl: this.configService.get<number>('THROTTLE_TTL', 60),
        limit: this.configService.get<number>('THROTTLE_LIMIT', isProduction ? 100 : 1000)
      },
      storage: isProduction ? IThrottler.IStorage.REDIS : IThrottler.IStorage.DEFAULT,
      redis: {
        host: this.configService.get<string>('REDIS_HOST', 'localhost'),
        port: this.configService.get<number>('REDIS_PORT', 6379),
        password: this.configService.get<string>('REDIS_PASSWORD'),
        retryDelayOnFailover: 100,
        maxRetriesPerRequest: 3
      }
    };
  }

  private async loadTenantConfiguration(): Promise<Partial<IThrottler.IOptions>> {
    try {
      const tenant = await this.tenantService.getCurrentTenant();
      
      if (!tenant) {
        return {};
      }

      const tierLimits = {
        basic: { ttl: 60, limit: 100 },
        premium: { ttl: 60, limit: 500 },
        enterprise: { ttl: 60, limit: 2000 }
      };

      return {
        settings: tierLimits[tenant.tier] || tierLimits.basic,
        redis: {
          keyPrefix: `throttler:${tenant.id}:`
        }
      };
    } catch (error) {
      console.warn('Failed to load tenant configuration, using defaults:', error);
      return {};
    }
  }

  private mergeConfigurations(
    base: IThrottler.IOptions, 
    tenant: Partial<IThrottler.IOptions>
  ): IThrottler.IOptions {
    return {
      ...base,
      settings: {
        ...base.settings,
        ...tenant.settings
      },
      redis: {
        ...base.redis,
        ...tenant.redis
      }
    };
  }

  private validateConfiguration(config: IThrottler.IOptions): void {
    if (!config.enabled && typeof config.enabled !== 'boolean') {
      throw new Error('Configuration validation failed: enabled must be boolean');
    }

    if (config.settings.ttl <= 0) {
      throw new Error('Configuration validation failed: TTL must be positive');
    }

    if (config.settings.limit <= 0) {
      throw new Error('Configuration validation failed: limit must be positive');
    }

    if (!Object.values(IThrottler.IStorage).includes(config.storage)) {
      throw new Error('Configuration validation failed: invalid storage type');
    }
  }
}
```

### Multi-Tenant Rate Limiting

```typescript
import { IThrottler } from '@hsuite/throttler-types';

interface TenantThrottlerConfig extends IThrottler.IOptions {
  tenantId: string;
  tier: 'basic' | 'premium' | 'enterprise';
  customLimits?: {
    endpoint?: string;
    limit: number;
    ttl: number;
  }[];
}

@Injectable()
export class MultiTenantThrottlerService {
  
  async createTenantConfiguration(tenantId: string): Promise<IThrottler.IOptions> {
    try {
      const tenant = await this.getTenantInfo(tenantId);
      const tierConfig = this.getTierConfiguration(tenant.tier);
      const customLimits = await this.getCustomLimits(tenantId);

      const config: IThrottler.IOptions = {
        enabled: tenant.throttlingEnabled,
        settings: {
          ttl: tierConfig.ttl,
          limit: tierConfig.limit
        },
        storage: IThrottler.IStorage.REDIS,
        redis: {
          host: process.env.REDIS_HOST,
          port: parseInt(process.env.REDIS_PORT || '6379'),
          keyPrefix: `throttler:${tenantId}:`,
          password: process.env.REDIS_PASSWORD
        }
      };

      // Apply custom limits if available
      if (customLimits.length > 0) {
        config.redis.keyPrefix = `throttler:custom:${tenantId}:`;
      }

      return config;
    } catch (error) {
      throw new Error(`Tenant configuration creation failed: ${error.message}`);
    }
  }

  private getTierConfiguration(tier: string): { ttl: number; limit: number } {
    const tierConfigs = {
      basic: { ttl: 60, limit: 100 },
      premium: { ttl: 60, limit: 500 },
      enterprise: { ttl: 60, limit: 2000 }
    };

    return tierConfigs[tier] || tierConfigs.basic;
  }

  private async getTenantInfo(tenantId: string): Promise<any> {
    // Mock implementation - replace with actual tenant service
    return {
      id: tenantId,
      tier: 'premium',
      throttlingEnabled: true,
      customSettings: {}
    };
  }

  private async getCustomLimits(tenantId: string): Promise<any[]> {
    // Mock implementation - replace with actual custom limits service
    return [
      {
        endpoint: '/api/heavy-operation',
        limit: 10,
        ttl: 300
      }
    ];
  }

  async updateTenantLimits(tenantId: string, newLimits: { ttl: number; limit: number }): Promise<void> {
    try {
      // Validate new limits
      if (newLimits.ttl <= 0 || newLimits.limit <= 0) {
        throw new Error('TTL and limit must be positive values');
      }

      // Update tenant configuration
      await this.updateTenantConfig(tenantId, newLimits);

      // Notify rate limiter of configuration change
      await this.notifyConfigurationChange(tenantId);

      console.log(`Updated throttling limits for tenant ${tenantId}:`, newLimits);
    } catch (error) {
      throw new Error(`Failed to update tenant limits: ${error.message}`);
    }
  }

  private async updateTenantConfig(tenantId: string, limits: { ttl: number; limit: number }): Promise<void> {
    // Implementation for updating tenant configuration
  }

  private async notifyConfigurationChange(tenantId: string): Promise<void> {
    // Implementation for notifying rate limiter of configuration changes
  }
}
```

### Advanced Factory Patterns

```typescript
import { IThrottler } from '@hsuite/throttler-types';

@Injectable()
export class AdvancedConfigurationService {
  
  // Conditional factory based on feature flags
  createConditionalFactory(): IThrottler.IOptionsFactory {
    return {
      createThrottlerOptions: async (): Promise<IThrottler.IOptions> => {
        const featureFlags = await this.getFeatureFlags();
        
        if (featureFlags.advancedThrottling) {
          return this.getAdvancedConfiguration();
        }
        
        return this.getBasicConfiguration();
      }
    };
  }

  // Configuration with circuit breaker pattern
  createCircuitBreakerFactory(): IThrottler.IOptionsFactory {
    return {
      createThrottlerOptions: async (): Promise<IThrottler.IOptions> => {
        const healthStatus = await this.checkSystemHealth();
        
        const baseConfig = this.getBasicConfiguration();
        
        if (healthStatus.isUnderHighLoad) {
          // Reduce limits during high load
          baseConfig.settings.limit = Math.floor(baseConfig.settings.limit * 0.5);
          baseConfig.settings.ttl = baseConfig.settings.ttl * 2;
        }
        
        return baseConfig;
      }
    };
  }

  // Time-based configuration adjustments
  createTimeBasedFactory(): IThrottler.IOptionsFactory {
    return {
      createThrottlerOptions: (): IThrottler.IOptions => {
        const currentHour = new Date().getHours();
        const isBusinessHours = currentHour >= 9 && currentHour <= 17;
        
        return {
          enabled: true,
          settings: {
            ttl: 60,
            limit: isBusinessHours ? 50 : 200 // Stricter limits during business hours
          },
          storage: IThrottler.IStorage.REDIS,
          redis: {
            host: process.env.REDIS_HOST || 'localhost',
            port: parseInt(process.env.REDIS_PORT || '6379'),
            keyPrefix: `throttler:${isBusinessHours ? 'business' : 'off'}:`
          }
        };
      }
    };
  }

  // Gradual rollout configuration factory
  createGradualRolloutFactory(rolloutPercentage: number): IThrottler.IOptionsFactory {
    return {
      createThrottlerOptions: async (): Promise<IThrottler.IOptions> => {
        const baseConfig = this.getBasicConfiguration();
        
        // Determine if this instance should use new configuration
        const shouldUseNewConfig = Math.random() * 100 < rolloutPercentage;
        
        if (shouldUseNewConfig) {
          const newConfig = await this.getExperimentalConfiguration();
          return newConfig;
        }
        
        return baseConfig;
      }
    };
  }

  private getBasicConfiguration(): IThrottler.IOptions {
    return {
      enabled: true,
      settings: { ttl: 60, limit: 100 },
      storage: IThrottler.IStorage.REDIS,
      redis: {
        host: process.env.REDIS_HOST || 'localhost',
        port: parseInt(process.env.REDIS_PORT || '6379')
      }
    };
  }

  private getAdvancedConfiguration(): IThrottler.IOptions {
    return {
      enabled: true,
      settings: { ttl: 60, limit: 200 },
      storage: IThrottler.IStorage.REDIS,
      redis: {
        host: process.env.REDIS_HOST || 'localhost',
        port: parseInt(process.env.REDIS_PORT || '6379'),
        retryDelayOnFailover: 100,
        maxRetriesPerRequest: 3,
        connectTimeout: 20000
      }
    };
  }

  private async getExperimentalConfiguration(): Promise<IThrottler.IOptions> {
    return {
      enabled: true,
      settings: { ttl: 30, limit: 150 }, // Experimental settings
      storage: IThrottler.IStorage.REDIS,
      redis: {
        host: process.env.REDIS_HOST || 'localhost',
        port: parseInt(process.env.REDIS_PORT || '6379'),
        keyPrefix: 'throttler:experimental:'
      }
    };
  }

  private async getFeatureFlags(): Promise<{ advancedThrottling: boolean }> {
    // Mock implementation
    return { advancedThrottling: true };
  }

  private async checkSystemHealth(): Promise<{ isUnderHighLoad: boolean }> {
    // Mock implementation
    return { isUnderHighLoad: false };
  }
}
```

### Type-Safe Configuration Validation

```typescript
import { IThrottler } from '@hsuite/throttler-types';

@Injectable()
export class ConfigurationValidationService {
  
  validateConfiguration(config: IThrottler.IOptions): { isValid: boolean; errors: string[] } {
    const errors: string[] = [];

    // Validate enabled flag
    if (typeof config.enabled !== 'boolean') {
      errors.push('enabled must be a boolean value');
    }

    // Validate settings
    if (!config.settings) {
      errors.push('settings object is required');
    } else {
      if (typeof config.settings.ttl !== 'number' || config.settings.ttl <= 0) {
        errors.push('settings.ttl must be a positive number');
      }

      if (typeof config.settings.limit !== 'number' || config.settings.limit <= 0) {
        errors.push('settings.limit must be a positive number');
      }
    }

    // Validate storage type
    if (!Object.values(IThrottler.IStorage).includes(config.storage)) {
      errors.push(`storage must be one of: ${Object.values(IThrottler.IStorage).join(', ')}`);
    }

    // Validate Redis configuration
    if (config.storage === IThrottler.IStorage.REDIS) {
      if (!config.redis) {
        errors.push('redis configuration is required when using Redis storage');
      } else {
        if (!config.redis.host) {
          errors.push('redis.host is required');
        }

        if (typeof config.redis.port !== 'number' || config.redis.port <= 0) {
          errors.push('redis.port must be a positive number');
        }
      }
    }

    return {
      isValid: errors.length === 0,
      errors
    };
  }

  createValidatedFactory(baseFactory: IThrottler.IOptionsFactory): IThrottler.IOptionsFactory {
    return {
      createThrottlerOptions: async (): Promise<IThrottler.IOptions> => {
        const config = await baseFactory.createThrottlerOptions();
        const validation = this.validateConfiguration(config);

        if (!validation.isValid) {
          throw new Error(`Configuration validation failed: ${validation.errors.join(', ')}`);
        }

        return config;
      }
    };
  }

  sanitizeConfiguration(config: Partial<IThrottler.IOptions>): IThrottler.IOptions {
    return {
      enabled: config.enabled ?? true,
      settings: {
        ttl: Math.max(1, config.settings?.ttl ?? 60),
        limit: Math.max(1, config.settings?.limit ?? 100)
      },
      storage: config.storage ?? IThrottler.IStorage.DEFAULT,
      redis: {
        host: config.redis?.host ?? 'localhost',
        port: config.redis?.port ?? 6379,
        ...config.redis
      }
    };
  }
}
```

***

## 🔗 Integration

### Required Dependencies

```json
{
  "@nestjs/common": "^10.4.2",
  "@nestjs/core": "^10.4.2",
  "@compodoc/compodoc": "^1.1.23"
}
```

### Module Integration

```typescript
import { Module } from '@nestjs/common';
import { IThrottler } from '@hsuite/throttler-types';

@Module({
  providers: [
    ThrottlerStorageService,
    DynamicThrottlerConfigFactory,
    MultiTenantThrottlerService,
    ConfigurationValidationService
  ],
  exports: [
    ThrottlerStorageService,
    DynamicThrottlerConfigFactory,
    MultiTenantThrottlerService,
    ConfigurationValidationService
  ]
})
export class ThrottlerTypesModule {}
```

### Documentation Generation

```bash
# Generate comprehensive documentation
npm run compodoc

# Generate documentation with coverage report
npm run compodoc:coverage
```

### Integration with HSuite Ecosystem

```typescript
// Complete integration with other HSuite modules
import { IThrottler } from '@hsuite/throttler-types';
import { AuthModule } from '@hsuite/auth';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule,
    AuthModule,
    ThrottlerModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService): Promise<IThrottler.IOptions> => {
        return {
          enabled: configService.get<boolean>('THROTTLE_ENABLED', true),
          settings: {
            ttl: configService.get<number>('THROTTLE_TTL', 60),
            limit: configService.get<number>('THROTTLE_LIMIT', 100)
          },
          storage: configService.get<string>('NODE_ENV') === 'production' 
            ? IThrottler.IStorage.REDIS 
            : IThrottler.IStorage.DEFAULT,
          redis: {
            host: configService.get<string>('REDIS_HOST', 'localhost'),
            port: configService.get<number>('REDIS_PORT', 6379),
            password: configService.get<string>('REDIS_PASSWORD'),
            retryDelayOnFailover: 100,
            maxRetriesPerRequest: 3
          }
        };
      },
      inject: [ConfigService]
    })
  ]
})
export class ThrottlerEcosystemModule {}

@Injectable()
export class IntegratedThrottlerService {
  constructor(
    private configService: ConfigService,
    private authService: AuthService
  ) {}

  async createUserSpecificLimits(userId: string): Promise<IThrottler.IOptions> {
    // Get user tier from auth service
    const userTier = await this.authService.getUserTier(userId);
    
    const tierLimits = {
      basic: { ttl: 60, limit: 50 },
      premium: { ttl: 60, limit: 200 },
      enterprise: { ttl: 60, limit: 1000 }
    };

    return {
      enabled: true,
      settings: tierLimits[userTier] || tierLimits.basic,
      storage: IThrottler.IStorage.REDIS,
      redis: {
        host: this.configService.get<string>('REDIS_HOST'),
        port: this.configService.get<number>('REDIS_PORT'),
        keyPrefix: `throttler:user:${userId}:`
      }
    };
  }
}
```

## Use Cases

### 🌐 **API Rate Limiting**

* RESTful API endpoint protection
* GraphQL query rate limiting
* WebSocket connection throttling
* File upload rate control

### 🛡️ **DDoS Protection**

* Request flooding prevention
* IP-based rate limiting
* Burst request handling
* Adaptive rate limiting

### 🔧 **Resource Usage Control**

* Database connection throttling
* CPU-intensive operation limiting
* Memory usage protection
* Third-party API call limiting

### 🏢 **Multi-Tenant Applications**

* Tenant-specific rate limits
* Tier-based throttling
* Usage quota enforcement
* Fair resource distribution

***

**⚡ Enterprise Rate Limiting**: Comprehensive TypeScript definitions with flexible storage backends and dynamic configuration support.

**🏭 Factory Pattern Integration**: Clean dependency injection with async configuration capabilities for complex deployment scenarios.

**🔄 Multi-Storage Support**: Redis for distributed systems and in-memory for simple deployments with seamless switching.

***

<p align="center">Built with ❤️ by the HSuite Team<br>Copyright © 2025 HSuite. All rights reserved.</p>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hsuite.network/developers/libs/throttler-types.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.