import type { Memorize } from '../domain/Memorize';
import type { MemorizeOptions } from '../domain/MemorizeOptions';
export declare const MEMORIZE_CACHE: unique symbol;
export declare const MEMORIZE_MODULE_OPTIONS: unique symbol;
type MetadataTarget = object;
export interface MemorizeNestExecutionContext {
    getClass(): MetadataTarget;
    getHandler(): MetadataTarget;
    switchToHttp(): {
        getRequest(): MemorizeNestHttpRequest;
        getResponse(): MemorizeNestHttpResponse;
    };
}
export interface MemorizeNestCallHandler<T = unknown> {
    handle(): MemorizeNestObservable<T>;
}
export interface MemorizeNestObservable<T = unknown> {
    subscribe(observerOrNext?: Partial<ObserverLike<T>> | ((value: T) => void), error?: (error: unknown) => void, complete?: () => void): unknown;
}
interface ObserverLike<T = unknown> {
    next(value: T): void;
    error(error: unknown): void;
    complete(): void;
}
export interface MemorizeNestHttpRequest {
    method?: string;
    originalUrl?: string;
    url?: string;
}
export interface MemorizeNestHttpResponse {
    statusCode?: number;
    setHeader?: (name: string, value: string) => void;
    header?: (name: string, value: string) => void;
    headersSent?: boolean;
}
export interface MemorizeNestKeyContext {
    context: MemorizeNestExecutionContext;
    request: MemorizeNestHttpRequest;
}
export interface MemorizeNestOptions extends MemorizeOptions {
    /**
     * Custom request-based cache key generator. Defaults to
     * `request.originalUrl ?? request.url`.
     */
    key?: (ctx: MemorizeNestKeyContext) => string;
}
interface DynamicModuleLike {
    module: unknown;
    providers: unknown[];
    exports: unknown[];
    global?: boolean;
}
/**
 * Decorates a controller or handler with a fixed cache key.
 */
export declare function MemorizeCacheKey(key: string): MethodDecorator & ClassDecorator;
/**
 * Decorates a controller or handler with a TTL override in milliseconds.
 */
export declare function MemorizeTtl(ttl: number): MethodDecorator & ClassDecorator;
/**
 * Decorates a controller or handler so the interceptor bypasses cache reads and writes.
 */
export declare function MemorizeNoCache(): MethodDecorator & ClassDecorator;
/**
 * Decorates a controller or handler with invalidation tags attached to every
 * cached entry. See `deleteByTag`.
 */
export declare function MemorizeTags(...tags: string[]): MethodDecorator & ClassDecorator;
/**
 * NestJS interceptor backed by a shared {@link Memorize} cache instance.
 *
 * Register through {@link MemorizeModule.forRoot} for dependency injection, or
 * instantiate directly in tests and small applications.
 */
export declare class MemorizeInterceptor {
    private readonly cache;
    private readonly options;
    constructor(cache?: Memorize, options?: MemorizeNestOptions);
    intercept(context: MemorizeNestExecutionContext, next: MemorizeNestCallHandler): MemorizeNestObservable<unknown>;
}
/**
 * Dynamic Nest module that provides a shared cache and interceptor.
 */
export declare class MemorizeModule {
    static forRoot(options?: MemorizeNestOptions): DynamicModuleLike;
}
export {};
//# sourceMappingURL=nestjs.d.ts.map