import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
import { MatSnackBar } from '@angular/material/snack-bar';
import { Observable } from 'rxjs';
import { AppSetting } from '../../common/models/app-setting';
import * as i0 from "@angular/core";
/**
 * Pass untouched request through to the next request handler.
 */
export declare class BaseInterceptor implements HttpInterceptor {
    private appSetting;
    private snackBar;
    /**
     * Constructor
     */
    constructor(appSetting: AppSetting, snackBar: MatSnackBar);
    /**
     * Intercept an outgoing `HttpRequest` and optionally transform it or the
     * response.
     *
     * Typically an interceptor will transform the outgoing request before returning
     * `next.handle(transformedReq)`. An interceptor may choose to transform the
     * response event stream as well, by applying additional Rx operators on the stream
     * returned by `next.handle()`.
     *
     * More rarely, an interceptor may choose to completely handle the request itself,
     * and compose a new event stream instead of invoking `next.handle()`. This is
     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
     *
     * It is also rare but valid for an interceptor to return multiple responses on the
     * event stream for a single request.
     */
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    /**
     * Parses http response errors
     * @param error
     */
    protected parseErrors(error: Object): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseInterceptor>;
}