import { HttpContextToken, HttpInterceptorFn, HttpContext, HttpRequest, HttpClient } from '@angular/common/http';
import * as i0 from '@angular/core';
import { InjectionToken } from '@angular/core';
import { Observable } from 'rxjs';
import { RepositoryConfig, PaginationParams, PagedResult, HttpPort, HttpOptions, CoreConfig } from '@acontplus/core';
import { BaseRepository, SearchableRepository } from '@acontplus/ng-config';

/**
 * Skip all toast notifications for a specific request.
 * Usage: new HttpContext().set(SKIP_NOTIFICATION, true)
 */
declare const SKIP_NOTIFICATION: HttpContextToken<boolean>;
/**
 * Force-show or force-hide notifications, overriding URL/method exclusion logic.
 * Usage: new HttpContext().set(SHOW_NOTIFICATIONS, true)
 */
declare const SHOW_NOTIFICATIONS: HttpContextToken<boolean | undefined>;
declare const apiInterceptor: HttpInterceptorFn;

declare function customUrl(): HttpContext;
declare function skipContextHeaders(): HttpContext;
declare function withCustomHeaders(headers: Record<string, string>): HttpContext;
interface HttpContextConfig {
    enableCorrelationTracking?: boolean;
    enableRequestLogging?: boolean;
    enableErrorLogging?: boolean;
    customHeaders?: Record<string, string | (() => string)>;
    clientVersion?: string;
    tenantIdHeader?: string;
    correlationIdHeader?: string;
    requestIdHeader?: string;
    timestampHeader?: string;
    /** URL substrings or regex patterns to exclude from header injection. */
    excludeUrls?: string[];
    /** URL substrings that should NOT receive an Authorization header. */
    skipAuthUrls?: string[];
    includeAuthToken?: boolean;
    baseUrlInjection?: boolean;
    /** Called when a 401 is received and a refresh token is available. */
    refreshTokenCallback?: () => Observable<{
        token: string;
        refreshToken?: string;
    }>;
    /** Called after a failed token refresh — should clear auth state. */
    logoutCallback?: () => void;
}
declare const HTTP_CONTEXT_CONFIG: InjectionToken<HttpContextConfig>;
declare const httpContextInterceptor: HttpInterceptorFn;
interface HttpRequestLog {
    method: string;
    url: string;
    originalUrl: string;
    requestId: string;
    correlationId: string;
    tenantId: string;
    timestamp: string;
    headers: string[];
    isCustomUrl: boolean;
}
interface HttpErrorLog extends HttpRequestLog {
    status: number;
    statusText: string;
    message: string;
    errorDetails: unknown;
    environment: string;
}
declare function createHttpContextConfig(overrides?: Partial<HttpContextConfig>): HttpContextConfig;
/**
 * Register the interceptor configuration in your app providers.
 *
 * @example
 * // app.config.ts
 * provideHttpClient(
 *   withInterceptors([
 *     httpContextInterceptor,  // 1st — adds headers, handles 401 refresh
 *     apiInterceptor,          // 2nd — normalises response, shows toasts
 *   ])
 * ),
 * ...provideHttpContext({ clientVersion: '2.0.0' }),
 */
declare function provideHttpContext(config?: Partial<HttpContextConfig>): {
    provide: InjectionToken<HttpContextConfig>;
    useValue: HttpContextConfig;
}[];

declare const SHOW_SPINNER: HttpContextToken<boolean>;
declare function withoutSpinner(): HttpContext;
declare class ActiveRequestsTracker {
    private readonly requests;
    get count(): number;
    /** Retorna true si se pasa de 0 → 1 (primera request activa). */
    add(request: HttpRequest<unknown>): boolean;
    /** Retorna true si se pasa de 1 → 0 (última request completada). */
    remove(request: HttpRequest<unknown>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActiveRequestsTracker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActiveRequestsTracker>;
}
declare const spinnerInterceptor: HttpInterceptorFn;

declare abstract class BaseHttpRepository {
    protected http: HttpClient;
    protected abstract config: RepositoryConfig;
    protected buildUrl(path?: string): string;
    protected get<T>(path?: string, params?: Record<string, string | number | boolean>): Observable<T>;
    protected post<T>(path: string | undefined, body: unknown): Observable<T>;
    protected put<T>(path: string | undefined, body: unknown): Observable<T>;
    protected patch<T>(path?: string, body?: unknown): Observable<T>;
    protected delete<T>(path?: string): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttpRepository, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseHttpRepository>;
}

declare const REPOSITORY_CONFIG: InjectionToken<RepositoryConfig>;
declare class GenericRepository<TEntity = any, TId extends string | number = number> extends BaseHttpRepository implements BaseRepository<TEntity, TId> {
    protected config: RepositoryConfig;
    constructor();
    getById(id: TId): Observable<TEntity>;
    getAll(pagination?: PaginationParams): Observable<PagedResult<TEntity>>;
    create(entity: Partial<TEntity>): Observable<TEntity>;
    update(id: TId, entity: Partial<TEntity>): Observable<TEntity>;
    remove(id: TId): Observable<void>;
    protected buildParams(pagination?: PaginationParams, filters?: Record<string, any>): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GenericRepository<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GenericRepository<any, any>>;
}
declare class SearchableGenericRepository<TEntity = any, TId extends string | number = number> extends GenericRepository<TEntity, TId> implements SearchableRepository<TEntity, TId> {
    search(query: string, pagination: PaginationParams): Observable<PagedResult<TEntity>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchableGenericRepository<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchableGenericRepository<any, any>>;
}

declare class RepositoryFactory {
    private http;
    create<TEntity, TId extends string | number = number>(config: RepositoryConfig): BaseRepository<TEntity, TId>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RepositoryFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RepositoryFactory>;
}

declare class AngularHttpAdapter implements HttpPort {
    private readonly http;
    private readonly baseURL?;
    constructor(http: HttpClient, baseURL?: string | undefined);
    private buildOptions;
    private request;
    /** GET */
    get<T>(url: string, options?: HttpOptions): Promise<T>;
    /** POST */
    post<T>(url: string, data?: unknown, options?: HttpOptions): Promise<T>;
    /** PUT */
    put<T>(url: string, data?: unknown, options?: HttpOptions): Promise<T>;
    /** DELETE */
    delete<T>(url: string, options?: HttpOptions): Promise<T>;
}

declare class CoreConfigService {
    private config;
    private environment;
    constructor();
    /**
     * Initialize configuration with defaults and environment overrides
     */
    private initializeConfig;
    /**
     * Get the current configuration
     */
    getConfig(): Required<CoreConfig>;
    /**
     * Update configuration at runtime
     */
    updateConfig(updates: Partial<CoreConfig>): void;
    /**
     * Get a specific configuration value
     */
    get<K extends keyof CoreConfig>(key: K): CoreConfig[K];
    /**
     * Check if a feature is enabled
     */
    isFeatureEnabled(feature: keyof CoreConfig): boolean;
    /**
     * Get API URL for a specific entity
     */
    getApiUrl(entityName?: string): string;
    /**
     * Check if a URL should be excluded from processing
     */
    shouldExcludeUrl(url: string): boolean;
    /**
     * Check if a method should be excluded from processing
     */
    shouldExcludeMethod(method: string): boolean;
    /**
     * Get custom headers with dynamic values resolved
     */
    getCustomHeaders(): Record<string, string>;
    /**
     * Reset configuration to defaults
     */
    resetConfig(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CoreConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CoreConfigService>;
}
declare function provideCoreConfig(config?: Partial<CoreConfig>): {
    provide: i0.InjectionToken<CoreConfig>;
    useValue: Partial<CoreConfig>;
}[];
declare function createCoreConfig(overrides?: Partial<CoreConfig>): CoreConfig;

declare class CorrelationInfo {
    private correlationId;
    private readonly CORRELATION_KEY;
    readonly currentCorrelationId: i0.Signal<string | null>;
    getOrCreateCorrelationId(): string;
    setCorrelationId(correlationId: string): void;
    resetCorrelationId(): void;
    getId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CorrelationInfo, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CorrelationInfo>;
}

declare class LoggingService {
    private environment;
    log(level: 'info' | 'warn' | 'error', message: string, context?: unknown): void;
    info(message: string, context?: unknown): void;
    warn(message: string, context?: unknown): void;
    error(message: string, context?: unknown): void;
    logHttpRequest(log: HttpRequestLog): void;
    logHttpError(error: HttpErrorLog): void;
    logNetworkError(correlationId: string): void;
    logRateLimitError(correlationId: string, url: string): void;
    private logToExternalService;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoggingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoggingService>;
}

interface UseCase<TRequest = void, TResponse = void> {
    execute(request: TRequest): Observable<TResponse>;
}
declare abstract class BaseUseCase<TRequest = void, TResponse = void> implements UseCase<TRequest, TResponse> {
    abstract execute(request: TRequest): Observable<TResponse>;
}

declare abstract class Command<TRequest, TResponse = void> extends BaseUseCase<TRequest, TResponse> {
    protected validate(_request: TRequest): string[];
    execute(request: TRequest): Observable<TResponse>;
    protected abstract executeInternal(request: TRequest): Observable<TResponse>;
}

declare abstract class Query<TRequest, TResponse> extends BaseUseCase<TRequest, TResponse> {
    execute(request: TRequest): Observable<TResponse>;
    protected abstract executeInternal(request: TRequest): Observable<TResponse>;
}

export { ActiveRequestsTracker, AngularHttpAdapter, BaseHttpRepository, BaseUseCase, Command, CoreConfigService, CorrelationInfo, GenericRepository, HTTP_CONTEXT_CONFIG, LoggingService, Query, REPOSITORY_CONFIG, RepositoryFactory, SHOW_NOTIFICATIONS, SHOW_SPINNER, SKIP_NOTIFICATION, SearchableGenericRepository, apiInterceptor, createCoreConfig, createHttpContextConfig, customUrl, httpContextInterceptor, provideCoreConfig, provideHttpContext, skipContextHeaders, spinnerInterceptor, withCustomHeaders, withoutSpinner };
export type { HttpContextConfig, HttpErrorLog, HttpRequestLog, UseCase };