import { CacheHandler, CacheISRConfig, CacheData, ISRHandlerConfig, CacheKeyGeneratorFn, InvalidateConfig, VariantRebuildItem, ServeFromCacheConfig, RenderConfig, IsrServiceInterface, IsrState } from '@rx-angular/isr/models';
import * as i0 from '@angular/core';
import { ModuleWithProviders, Provider, EnvironmentProviders } from '@angular/core';
import { IsrService } from '@rx-angular/isr/browser';
import { Request, Response, NextFunction } from 'express';
import * as _angular_common_http from '@angular/common/http';
import { HttpErrorResponse } from '@angular/common/http';

interface FileSystemCacheOptions {
    cacheFolderPath: string;
    prerenderedPagesPath?: string;
    addPrerenderedPagesToCache?: boolean;
}
interface FileSystemCacheData {
    htmlFilePath: string;
    options: CacheISRConfig;
    createdAt: number;
}
declare class FileSystemCacheHandler extends CacheHandler {
    options: FileSystemCacheOptions;
    protected cache: Map<string, FileSystemCacheData>;
    private get cacheFolderPath();
    constructor(options: FileSystemCacheOptions);
    add(cacheKey: string, html: string, config?: CacheISRConfig): Promise<void>;
    get(cacheKey: string): Promise<CacheData>;
    has(cacheKey: string): Promise<boolean>;
    delete(cacheKey: string): Promise<boolean>;
    getAll(): Promise<string[]>;
    private populateCacheFromFilesystem;
    clearCache(): Promise<boolean>;
    private addPrerenderedPagesToCache;
    private transferPrerenderedPagesToCacheFolder;
    private readFromFile;
}

declare class InMemoryCacheHandler extends CacheHandler {
    protected cache: Map<string, CacheData>;
    constructor();
    add(cacheKey: string, html: string, config?: CacheISRConfig): Promise<void>;
    get(cacheKey: string): Promise<CacheData>;
    getAll(): Promise<string[]>;
    has(cacheKey: string): Promise<boolean>;
    delete(cacheKey: string): Promise<boolean>;
    clearCache?(): Promise<boolean>;
}

declare class IsrModule {
    private isrService;
    private platformId;
    constructor(isrService: IsrService, platformId: object);
    static forRoot(): ModuleWithProviders<IsrModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsrModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IsrModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IsrModule>;
}

/**
 * Logger class for ISR package
 * @internal
 */
declare class ISRLogger {
    private showLogs;
    constructor(showLogs: boolean);
    /**
     * Log a message to the console
     * @param message The message to log
     * @param optionalParams Optional parameters to log
     * @internal
     */
    log(message?: string, ...optionalParams: unknown[]): void;
}

interface IGeneratedResult {
    html?: string;
    errors?: string[];
}
declare class CacheGeneration {
    isrConfig: ISRHandlerConfig;
    cache: CacheHandler;
    logger: ISRLogger;
    private urlsOnHold;
    constructor(isrConfig: ISRHandlerConfig, cache: CacheHandler, logger: ISRLogger);
    getCacheKey: CacheKeyGeneratorFn;
    generate(req: Request, res: Response, providers?: Provider[], mode?: 'regenerate' | 'generate'): Promise<IGeneratedResult | void>;
    generateWithCacheKey(req: Request, res: Response, cacheKey: string, providers?: Provider[], mode?: 'regenerate' | 'generate'): Promise<IGeneratedResult | void>;
}

declare class ISRHandler {
    protected isrConfig: ISRHandlerConfig;
    protected cache: CacheHandler;
    protected cacheGeneration: CacheGeneration;
    protected logger: ISRLogger;
    constructor(isrConfig: ISRHandlerConfig);
    invalidate(req: Request, res: Response, config?: InvalidateConfig): Promise<Response>;
    getVariantUrlsToInvalidate(urlsToInvalidate: string[]): VariantRebuildItem[];
    serveFromCache(req: Request, res: Response, next: NextFunction, config?: ServeFromCacheConfig): Promise<Response | void>;
    render(req: Request, res: Response, next: NextFunction, config?: RenderConfig): Promise<Response | void>;
}

declare class IsrServerService implements IsrServiceInterface {
    private readonly router;
    private state;
    getState(): IsrState;
    patchState(partialState: Partial<IsrState>): void;
    getExtra(): Record<string, unknown>;
    /**
     * Activate the service and listen to router events
     * @returns void
     */
    activate(): void;
    /**
     * Add error to the state
     * @param error HttpErrorResponse
     * @returns void
     * @example
     * ```typescript
     * this.isrService.addError(err);
     * ```
     */
    addError(error: HttpErrorResponse | Error): void;
    /**
     * Add extra data to the state
     * @param extra Record<string, any>
     * @returns void
     * @example
     * ```typescript
     * this.isrService.addExtra({ foo: 'bar' });
     * ```
     */
    addExtra(extra?: Record<string, unknown>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsrServerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IsrServerService>;
}

/**
 * @description
 * This function registers the providers needed for ISR to work.
 *
 * @returns {EnvironmentProviders} The providers for the application.
 *
 * @example
 * ```
 * import { provideISR } from '@rx-angular/isr/server';
 *
 * @NgModule({
 *  providers: [ provideISR() ]
 * })
 * export class AppServerModule {}
 * ```
 *
 * To configure ISR in a standalone application:
 * ```
 * const serverConfig: ApplicationConfig = {
 *   providers: [
 *     provideServerRendering()
 *     provideISR()
 *   ],
 * };
 * export const config = mergeApplicationConfig(appConfig, serverConfig);
 * ```
 */
declare const provideISR: () => EnvironmentProviders;
/**
 * @description
 * This function registers the providers needed for ISR to work.
 *
 * @usage
 * ```ts
 * import { isrHttpInterceptors } from '@rx-angular/isr/server';
 *
 * providers: [
 *   provideHttpClient(
 *     withInterceptors(isrHttpInterceptors)
 *   )
 * ]
 * ```
 */
declare const isrHttpInterceptors: _angular_common_http.HttpInterceptorFn[];

export { FileSystemCacheHandler, ISRHandler, InMemoryCacheHandler, IsrModule, IsrServerService, isrHttpInterceptors, provideISR };
export type { FileSystemCacheOptions };