import * as i0 from '@angular/core';
import { OnDestroy, InjectionToken, EnvironmentProviders } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, BehaviorSubject } from 'rxjs';
import { AbstractControl, ValidatorFn } from '@angular/forms';

declare class ImageConverter {
    private readonly _exif;
    private readonly _platform;
    private readonly _fileLoader;
    private readonly _types;
    toDataUri(contents: string | File | HTMLImageElement, options?: {
        width: number;
        height: number;
    } | null): Promise<string>;
    fileToImage(file: File, types?: string[]): Promise<HTMLImageElement>;
    stringToImage(src: string): Promise<HTMLImageElement>;
    private getImage;
    private calculateOffsetAndDimensions;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageConverter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ImageConverter>;
}

declare class FileLoader {
    fromDataUrl(value: string, name?: string): File;
    asDataUrl(file: File | Blob): Promise<string>;
    asArrayBuffer(file: File | Blob): Promise<ArrayBuffer>;
    private read;
    private isFile;
    private isBlob;
    private createFile;
    private blobToFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileLoader, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FileLoader>;
}

declare class Files {
    private readonly _platform;
    private readonly _renderer;
    private readonly _window;
    download(file: File, name?: string): void;
    download(blob: Blob, name: string): void;
    fromDataUri(dataUri: string, name: string): File;
    create(blob: Blob, name: string): File;
    private createAnchorElement;
    private revokeUrlAndPressAnchor;
    private pressAnchor;
    static ɵfac: i0.ɵɵFactoryDeclaration<Files, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Files>;
}

declare class Languages {
    private readonly _acceptLanguage;
    private readonly _data;
    constructor();
    get all(): {
        code: string;
        script?: string;
        region?: string;
        quality: number;
    }[];
    private initialize;
    static ɵfac: i0.ɵɵFactoryDeclaration<Languages, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Languages>;
}

declare class Network {
    private readonly _platform;
    private readonly _window?;
    private readonly _navigator?;
    private _online$;
    constructor();
    online(): Observable<boolean>;
    private getOnlineObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<Network, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Network>;
}

declare class Patch implements OnDestroy {
    private readonly _platform;
    private readonly _window?;
    private readonly _document?;
    private _hasPatchedMobileVerticalHeight;
    private _subscription;
    mobileVerticalHeight(): void;
    ngOnDestroy(): void;
    private periodicallySetDocumentVerticalProperty;
    static ɵfac: i0.ɵɵFactoryDeclaration<Patch, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Patch>;
}

declare class Exif {
    private readonly _platform;
    private readonly _fileLoader;
    strip(file: File, quality?: number): Promise<File>;
    private createImageElement;
    private transformImage;
    private getSupportedCanvasType;
    private getOrientation;
    static ɵfac: i0.ɵɵFactoryDeclaration<Exif, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Exif>;
}

declare const ACCEPT_LANGUAGE: InjectionToken<string>;

declare const COOKIE: InjectionToken<string>;

declare const WINDOW: InjectionToken<Window>;

declare const NAVIGATOR: InjectionToken<Navigator>;

declare const LOCATION: InjectionToken<Location>;

type FocusMode = 'only-desktop' | 'all';
declare const GLOBAL_FOCUS_MODE: InjectionToken<FocusMode>;
declare function provideGlobalFocusMode(mode: FocusMode): EnvironmentProviders;

declare const BbRegex: {
    email: RegExp;
    fullNumber: RegExp;
    url: RegExp;
};

declare class BbValidator {
    static email(control: AbstractControl): {
        email: boolean;
    };
    static fullNumber(control: AbstractControl): {
        fullNumber: boolean;
    };
    static maxFileSize(bytes: number): ValidatorFn;
    static confirm(fieldName: string, error?: string): ValidatorFn;
    static maxDate(date: Date, error?: string): ValidatorFn;
    static minDate(date: Date, error?: string): ValidatorFn;
}

declare function observableAttribute(value: unknown): Observable<any>;

declare function hexToHsv(hex: string): {
    hue: number;
    saturation: number;
    value: number;
    alpha: number;
};
declare function hexToRgb(hex: string): {
    red: number;
    green: number;
    blue: number;
    alpha: number;
};
declare function hexToHsl(hex: string): {
    hue: number;
    saturation: number;
    lightness: number;
    alpha: number;
};

declare function hslToHsv(hue: number, saturation: number, lightness: number, alpha?: number): {
    hue: number;
    saturation: number;
    value: number;
    alpha: number;
};
declare function hslToHex(hue: number, saturation: number, lightness: number, alpha?: number): string;

declare function hsvToHex(hue: number, saturation: number, value: number, alpha?: number): string;
declare function hsvToRgb(hue: number, saturation: number, value: number, alpha?: number): {
    red: number;
    green: number;
    blue: number;
    alpha: number;
};
declare function hsvToHsl(hue: number, saturation: number, value: number, alpha?: number): {
    hue: number;
    saturation: number;
    lightness: number;
    alpha: number;
};

declare function rgbToHex(red: number, green: number, blue: number, alpha?: number): string;
declare function rgbToHsv(red: number, green: number, blue: number, alpha?: number): {
    hue: number;
    saturation: number;
    value: number;
    alpha: number;
};

declare function clamp(value: number, min: number, max: number): number;

declare function parseDate(value: string | number | Date): Date | null;
declare function createDate(date: Date): Date;
declare function isValidDate(date: unknown): boolean;
declare function isDate(value: unknown): value is Date;

declare function generatePassword(length?: number): string;

declare function arrayToMap<T extends object, K extends keyof T>(items: T[], field: K): Readonly<Record<string, T>>;

declare function isFileLike(input: unknown): boolean;
declare function isValidFileType(file: File, accept: string | null | undefined): boolean;
declare function isValidFileSize(file: File, max: number): boolean;

declare function formatFileSize(value: number, decimals?: number): string;

declare class RouteCache<T> {
    protected readonly value$: BehaviorSubject<T | null>;
    constructor(initialValue?: T);
    asObservable(): rxjs.Observable<T>;
    get(): T;
    set(value: T): void;
}
declare function provideRouteCache<T>(token: InjectionToken<RouteCache<T>>, value: RouteCache<T>): i0.EnvironmentProviders;

declare function injectRouteParam<T = string>(key: string, format?: (rawValue: string | null) => T | null): i0.Signal<T>;
declare function injectRouteParamId(key: string): i0.Signal<number>;
declare function injectRouteQueryParam<T = string>(key: string, format?: (rawValue: string | null) => T | null): i0.Signal<T>;
declare function injectRouterInfo<T>(key: string): i0.Signal<T>;
declare function injectLinkedRouteData<T>(key: string): i0.WritableSignal<T>;
declare function injectAttribute(key: string, defaultValue?: string | null): i0.Signal<string>;

export { ACCEPT_LANGUAGE, BbRegex, BbValidator, COOKIE, Exif, FileLoader, Files, GLOBAL_FOCUS_MODE, ImageConverter, LOCATION, Languages, NAVIGATOR, Network, Patch, RouteCache, WINDOW, arrayToMap, clamp, createDate, formatFileSize, generatePassword, hexToHsl, hexToHsv, hexToRgb, hslToHex, hslToHsv, hsvToHex, hsvToHsl, hsvToRgb, injectAttribute, injectLinkedRouteData, injectRouteParam, injectRouteParamId, injectRouteQueryParam, injectRouterInfo, isDate, isFileLike, isValidDate, isValidFileSize, isValidFileType, observableAttribute, parseDate, provideGlobalFocusMode, provideRouteCache, rgbToHex, rgbToHsv };
export type { FocusMode };