@adonisjs/limiter/build/src/define_config.d.ts

Rate limiting package for AdonisJS framework

import type { ConfigProvider } from '@adonisjs/core/types';
import type { RedisConnections } from '@adonisjs/redis/types';
import type { LimiterRedisStoreConfig, LimiterMemoryStoreConfig, LimiterManagerStoreFactory, LimiterDatabaseStoreConfig, LimiterConsumptionOptions } from './types.ts';
/**
 * Defines the limiter configuration for your AdonisJS application.
 * This function returns a config provider that resolves store configurations lazily.
 *
 * To access the resolved config at runtime, use the `limiterManager.config` property.
 *
 * @param config - Configuration object with default store and stores collection
 *
 * @example
 * ```ts
 * export default defineConfig({
 *   default: 'redis',
 *   stores: {
 *     redis: stores.redis({}),
 *     memory: stores.memory({})
 *   }
 * })
 * ```
 */
export declare function defineConfig<KnownStores extends Record<string, LimiterManagerStoreFactory | ConfigProvider<LimiterManagerStoreFactory>>>(config: {
    default: keyof KnownStores;
    stores: KnownStores;
}): ConfigProvider<{
    default: keyof KnownStores;
    stores: {
        [K in keyof KnownStores]: KnownStores[K] extends ConfigProvider<infer A> ? A : KnownStores[K];
    };
}>;
/**
 * Store configuration helpers to instantiate limiter stores in your AdonisJS application.
 * Each helper returns a factory function that creates store instances with consumption options.
 *
 * @example
 * ```ts
 * export default defineConfig({
 *   default: 'redis',
 *   stores: {
 *     redis: stores.redis({ connectionName: 'main' }),
 *     database: stores.database({ tableName: 'rate_limits' }),
 *     memory: stores.memory({})
 *   }
 * })
 * ```
 */
export declare const stores: {
    /**
     * Configures a Redis-backed limiter store.
     *
     * @param config - Redis store configuration
     *
     * @example
     * ```ts
     * stores.redis({
     *   connectionName: 'main',
     *   keyPrefix: 'limiter'
     * })
     * ```
     */
    redis: (config: Omit<LimiterRedisStoreConfig, keyof LimiterConsumptionOptions> & {
        connectionName?: keyof RedisConnections;
    }) => ConfigProvider<LimiterManagerStoreFactory>;
    /**
     * Configures a database-backed limiter store. Supports PostgreSQL, MySQL, and SQLite.
     *
     * @param config - Database store configuration
     *
     * @example
     * ```ts
     * stores.database({
     *   tableName: 'rate_limits',
     *   connectionName: 'postgres'
     * })
     * ```
     */
    database: (config: Omit<LimiterDatabaseStoreConfig, keyof LimiterConsumptionOptions> & {
        connectionName?: string;
    }) => ConfigProvider<LimiterManagerStoreFactory>;
    /**
     * Configures an in-memory limiter store. Useful for testing or single-instance applications.
     *
     * @param config - Memory store configuration
     *
     * @example
     * ```ts
     * stores.memory({
     *   keyPrefix: 'limiter'
     * })
     * ```
     */
    memory: (config: Omit<LimiterMemoryStoreConfig, keyof LimiterConsumptionOptions>) => LimiterManagerStoreFactory;
};