/**
 * @module @arcis/node/nestjs
 *
 * NestJS adapter for Arcis.
 *
 * Two ways to wire this up:
 *
 * 1. Global functional middleware (zero NestJS knowledge required):
 *    ```ts
 *    // main.ts
 *    import { NestFactory } from '@nestjs/core';
 *    import { arcis } from '@arcis/node';
 *    const app = await NestFactory.create(AppModule);
 *    app.use(arcis({ block: true }));
 *    ```
 *
 * 2. DI-aware module + class middleware (per-route control):
 *    ```ts
 *    // app.module.ts
 *    import { Module, MiddlewareConsumer, NestModule } from '@nestjs/common';
 *    import { ArcisModule, ArcisMiddleware } from '@arcis/node/nestjs';
 *
 *    @Module({ imports: [ArcisModule.forRoot({ block: true })] })
 *    export class AppModule implements NestModule {
 *      configure(consumer: MiddlewareConsumer) {
 *        consumer.apply(ArcisMiddleware).forRoutes('*');
 *      }
 *    }
 *    ```
 *
 * No runtime dependency on `@nestjs/common`: the only NestJS reference is a
 * type-only import erased at compile time. NestJS users already have
 * `@nestjs/common` installed; non-NestJS users pay nothing.
 */
import type { Request, Response, NextFunction } from 'express';
import type { DynamicModule } from '@nestjs/common';
import type { ArcisOptions } from '../core/types';
/** Injection token for `ArcisOptions` consumed by `ArcisMiddleware`'s factory. */
export declare const ARCIS_OPTIONS: unique symbol;
/**
 * NestJS-compatible class middleware. Implements the structural shape NestJS
 * expects (`.use(req, res, next)`) without importing `NestMiddleware` at
 * runtime. Internally builds the same handler stack as `arcis()` and walks it
 * sequentially, propagating errors and short-circuit responses correctly.
 */
export declare class ArcisMiddleware {
    private readonly handlers;
    constructor(options?: ArcisOptions);
    use(req: Request, res: Response, next: NextFunction): void;
    /** Release rate-limiter intervals etc. Call from `OnApplicationShutdown`. */
    close(): void;
}
/**
 * NestJS dynamic module. `ArcisModule.forRoot(options)` is the entry point.
 * Returns a plain `DynamicModule` literal so `@Module({})` is unnecessary on
 * `ArcisModule` itself; this keeps `@nestjs/common` purely a type-only import.
 */
export declare class ArcisModule {
    static forRoot(options?: ArcisOptions): DynamicModule;
}
export default ArcisModule;
//# sourceMappingURL=nestjs.d.ts.map