import { ChangeDetectorRef } from '@angular/core';
import { DoCheck } from '@angular/core';
import { ElementRef } from '@angular/core';
import * as i0 from '@angular/core';
import { ɵIMAGE_CONFIG as IMAGE_CONFIG } from '@angular/core';
import { ɵImageConfig as ImageConfig } from '@angular/core';
import { InjectionToken } from '@angular/core';
import { Injector } from '@angular/core';
import { IterableDiffers } from '@angular/core';
import { KeyValueDiffers } from '@angular/core';
import { NgIterable } from '@angular/core';
import { NgModuleFactory } from '@angular/core';
import { Observable } from 'rxjs';
import { OnChanges } from '@angular/core';
import { OnDestroy } from '@angular/core';
import { OnInit } from '@angular/core';
import { PipeTransform } from '@angular/core';
import { Provider } from '@angular/core';
import { Renderer2 } from '@angular/core';
import { SimpleChanges } from '@angular/core';
import { Subscribable } from 'rxjs';
import { SubscriptionLike } from 'rxjs';
import { TemplateRef } from '@angular/core';
import { TrackByFunction } from '@angular/core';
import { Type } from '@angular/core';
import { Version } from '@angular/core';
import { ViewContainerRef } from '@angular/core';

// @public
export const APP_BASE_HREF: InjectionToken<string>;

// @public
export class AsyncPipe implements OnDestroy, PipeTransform {
    constructor(ref: ChangeDetectorRef);
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    transform<T>(obj: Observable<T> | Subscribable<T> | Promise<T>): T | null;
    // (undocumented)
    transform<T>(obj: null | undefined): null;
    // (undocumented)
    transform<T>(obj: Observable<T> | Subscribable<T> | Promise<T> | null | undefined): T | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<AsyncPipe, "async", true>;
}

// @public
export class BrowserPlatformLocation extends PlatformLocation {
    constructor();
    // (undocumented)
    back(): void;
    // (undocumented)
    forward(): void;
    // (undocumented)
    getBaseHrefFromDOM(): string;
    // (undocumented)
    getState(): unknown;
    // (undocumented)
    get hash(): string;
    // (undocumented)
    historyGo(relativePosition?: number): void;
    // (undocumented)
    get hostname(): string;
    // (undocumented)
    get href(): string;
    // (undocumented)
    onHashChange(fn: LocationChangeListener): VoidFunction;
    // (undocumented)
    onPopState(fn: LocationChangeListener): VoidFunction;
    // (undocumented)
    get pathname(): string;
    set pathname(newPath: string);
    // (undocumented)
    get port(): string;
    // (undocumented)
    get protocol(): string;
    // (undocumented)
    pushState(state: any, title: string, url: string): void;
    // (undocumented)
    replaceState(state: any, title: string, url: string): void;
    // (undocumented)
    get search(): string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserPlatformLocation, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserPlatformLocation>;
}

// @public
export class CommonModule {
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<CommonModule, never>;
    // (undocumented)
    static ɵinj: i0.ɵɵInjectorDeclaration<CommonModule>;
    // (undocumented)
    static ɵmod: i0.ɵɵNgModuleDeclaration<CommonModule, never, [typeof i1.NgClass, typeof i2.NgComponentOutlet, typeof i3.NgForOf, typeof i4.NgIf, typeof i5.NgTemplateOutlet, typeof i6.NgStyle, typeof i7.NgSwitch, typeof i7.NgSwitchCase, typeof i7.NgSwitchDefault, typeof i8.NgPlural, typeof i8.NgPluralCase, typeof i9.AsyncPipe, typeof i10.UpperCasePipe, typeof i10.LowerCasePipe, typeof i11.JsonPipe, typeof i12.SlicePipe, typeof i13.DecimalPipe, typeof i13.PercentPipe, typeof i10.TitleCasePipe, typeof i13.CurrencyPipe, typeof i14.DatePipe, typeof i15.I18nPluralPipe, typeof i16.I18nSelectPipe, typeof i17.KeyValuePipe], [typeof i1.NgClass, typeof i2.NgComponentOutlet, typeof i3.NgForOf, typeof i4.NgIf, typeof i5.NgTemplateOutlet, typeof i6.NgStyle, typeof i7.NgSwitch, typeof i7.NgSwitchCase, typeof i7.NgSwitchDefault, typeof i8.NgPlural, typeof i8.NgPluralCase, typeof i9.AsyncPipe, typeof i10.UpperCasePipe, typeof i10.LowerCasePipe, typeof i11.JsonPipe, typeof i12.SlicePipe, typeof i13.DecimalPipe, typeof i13.PercentPipe, typeof i10.TitleCasePipe, typeof i13.CurrencyPipe, typeof i14.DatePipe, typeof i15.I18nPluralPipe, typeof i16.I18nSelectPipe, typeof i17.KeyValuePipe]>;
}

// @public
export class CurrencyPipe implements PipeTransform {
    constructor(_locale: string, _defaultCurrencyCode?: string);
    // (undocumented)
    transform(value: number | string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): string | null;
    // (undocumented)
    transform(value: null | undefined, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): null;
    // (undocumented)
    transform(value: number | string | null | undefined, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<CurrencyPipe, "currency", true>;
}

// @public
export const DATE_PIPE_DEFAULT_OPTIONS: InjectionToken<DatePipeConfig>;

// @public @deprecated
export const DATE_PIPE_DEFAULT_TIMEZONE: InjectionToken<string>;

// @public
export class DatePipe implements PipeTransform {
    constructor(locale: string, defaultTimezone?: (string | null) | undefined, defaultOptions?: (DatePipeConfig | null) | undefined);
    // (undocumented)
    transform(value: Date | string | number, format?: string, timezone?: string, locale?: string): string | null;
    // (undocumented)
    transform(value: null | undefined, format?: string, timezone?: string, locale?: string): null;
    // (undocumented)
    transform(value: Date | string | number | null | undefined, format?: string, timezone?: string, locale?: string): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePipe, [null, { optional: true; }, { optional: true; }]>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<DatePipe, "date", true>;
}

// @public
export interface DatePipeConfig {
    // (undocumented)
    dateFormat?: string;
    // (undocumented)
    timezone?: string;
}

// @public
export class DecimalPipe implements PipeTransform {
    constructor(_locale: string);
    // (undocumented)
    transform(value: number | string, digitsInfo?: string, locale?: string): string | null;
    // (undocumented)
    transform(value: null | undefined, digitsInfo?: string, locale?: string): null;
    // (undocumented)
    transform(value: number | string | null | undefined, digitsInfo?: string, locale?: string): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<DecimalPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<DecimalPipe, "number", true>;
}

// @public
export const DOCUMENT: InjectionToken<Document>;

// @public
export function formatCurrency(value: number, locale: string, currency: string, currencyCode?: string, digitsInfo?: string): string;

// @public
export function formatDate(value: string | number | Date, format: string, locale: string, timezone?: string): string;

// @public
export function formatNumber(value: number, locale: string, digitsInfo?: string): string;

// @public
export function formatPercent(value: number, locale: string, digitsInfo?: string): string;

// @public @deprecated
export enum FormatWidth {
    Full = 3,
    Long = 2,
    Medium = 1,
    Short = 0
}

// @public @deprecated
export enum FormStyle {
    // (undocumented)
    Format = 0,
    // (undocumented)
    Standalone = 1
}

// @public @deprecated
export function getCurrencySymbol(code: string, format: 'wide' | 'narrow', locale?: string): string;

// @public @deprecated
export function getLocaleCurrencyCode(locale: string): string | null;

// @public @deprecated
export function getLocaleCurrencyName(locale: string): string | null;

// @public @deprecated
export function getLocaleCurrencySymbol(locale: string): string | null;

// @public @deprecated
export function getLocaleDateFormat(locale: string, width: FormatWidth): string;

// @public @deprecated
export function getLocaleDateTimeFormat(locale: string, width: FormatWidth): string;

// @public @deprecated
export function getLocaleDayNames(locale: string, formStyle: FormStyle, width: TranslationWidth): ReadonlyArray<string>;

// @public @deprecated
export function getLocaleDayPeriods(locale: string, formStyle: FormStyle, width: TranslationWidth): Readonly<[string, string]>;

// @public @deprecated
export function getLocaleDirection(locale: string): 'ltr' | 'rtl';

// @public @deprecated
export function getLocaleEraNames(locale: string, width: TranslationWidth): Readonly<[string, string]>;

// @public @deprecated
export function getLocaleExtraDayPeriodRules(locale: string): (Time | [Time, Time])[];

// @public @deprecated
export function getLocaleExtraDayPeriods(locale: string, formStyle: FormStyle, width: TranslationWidth): string[];

// @public @deprecated
export function getLocaleFirstDayOfWeek(locale: string): WeekDay;

// @public @deprecated
export function getLocaleId(locale: string): string;

// @public @deprecated
export function getLocaleMonthNames(locale: string, formStyle: FormStyle, width: TranslationWidth): ReadonlyArray<string>;

// @public @deprecated
export function getLocaleNumberFormat(locale: string, type: NumberFormatStyle): string;

// @public @deprecated
export function getLocaleNumberSymbol(locale: string, symbol: NumberSymbol): string;

// @public @deprecated (undocumented)
export const getLocalePluralCase: (locale: string) => (value: number) => Plural;

// @public @deprecated
export function getLocaleTimeFormat(locale: string, width: FormatWidth): string;

// @public @deprecated
export function getLocaleWeekEndRange(locale: string): [WeekDay, WeekDay];

// @public @deprecated
export function getNumberOfCurrencyDigits(code: string): number;

// @public
export class HashLocationStrategy extends LocationStrategy implements OnDestroy {
    constructor(_platformLocation: PlatformLocation, _baseHref?: string);
    // (undocumented)
    back(): void;
    // (undocumented)
    forward(): void;
    // (undocumented)
    getBaseHref(): string;
    // (undocumented)
    getState(): unknown;
    // (undocumented)
    historyGo(relativePosition?: number): void;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    onPopState(fn: LocationChangeListener): void;
    // (undocumented)
    path(includeHash?: boolean): string;
    // (undocumented)
    prepareExternalUrl(internal: string): string;
    // (undocumented)
    pushState(state: any, title: string, path: string, queryParams: string): void;
    // (undocumented)
    replaceState(state: any, title: string, path: string, queryParams: string): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<HashLocationStrategy, [null, { optional: true; }]>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<HashLocationStrategy>;
}

// @public
export class I18nPluralPipe implements PipeTransform {
    constructor(_localization: NgLocalization);
    // (undocumented)
    transform(value: number | null | undefined, pluralMap: {
        [count: string]: string;
    }, locale?: string): string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<I18nPluralPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<I18nPluralPipe, "i18nPlural", true>;
}

// @public
export class I18nSelectPipe implements PipeTransform {
    // (undocumented)
    transform(value: string | null | undefined, mapping: {
        [key: string]: string;
    }): string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<I18nSelectPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<I18nSelectPipe, "i18nSelect", true>;
}

export { IMAGE_CONFIG }

// @public
export const IMAGE_LOADER: InjectionToken<ImageLoader>;

export { ImageConfig }

// @public
export type ImageLoader = (config: ImageLoaderConfig) => string;

// @public
export interface ImageLoaderConfig {
    isPlaceholder?: boolean;
    loaderParams?: {
        [key: string]: any;
    };
    src: string;
    width?: number;
}

// @public
export interface ImagePlaceholderConfig {
    // (undocumented)
    blur?: boolean;
}

// @public
export function isPlatformBrowser(platformId: Object): boolean;

// @public
export function isPlatformServer(platformId: Object): boolean;

// @public
export class JsonPipe implements PipeTransform {
    // (undocumented)
    transform(value: any): string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<JsonPipe, "json", true>;
}

// @public
export interface KeyValue<K, V> {
    // (undocumented)
    key: K;
    // (undocumented)
    value: V;
}

// @public
export class KeyValuePipe implements PipeTransform {
    constructor(differs: KeyValueDiffers);
    // (undocumented)
    transform<K, V>(input: ReadonlyMap<K, V>, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>>;
    // (undocumented)
    transform<K extends number, V>(input: Record<K, V>, compareFn?: (a: KeyValue<string, V>, b: KeyValue<string, V>) => number): Array<KeyValue<string, V>>;
    // (undocumented)
    transform<K extends string, V>(input: Record<K, V> | ReadonlyMap<K, V>, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>>;
    // (undocumented)
    transform(input: null | undefined, compareFn?: (a: KeyValue<unknown, unknown>, b: KeyValue<unknown, unknown>) => number): null;
    // (undocumented)
    transform<K, V>(input: ReadonlyMap<K, V> | null | undefined, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>> | null;
    // (undocumented)
    transform<K extends number, V>(input: Record<K, V> | null | undefined, compareFn?: (a: KeyValue<string, V>, b: KeyValue<string, V>) => number): Array<KeyValue<string, V>> | null;
    // (undocumented)
    transform<K extends string, V>(input: Record<K, V> | ReadonlyMap<K, V> | null | undefined, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>> | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<KeyValuePipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<KeyValuePipe, "keyvalue", true>;
}

// @public
class Location_2 implements OnDestroy {
    constructor(locationStrategy: LocationStrategy);
    back(): void;
    forward(): void;
    getState(): unknown;
    go(path: string, query?: string, state?: any): void;
    historyGo(relativePosition?: number): void;
    isCurrentPathEqualTo(path: string, query?: string): boolean;
    static joinWithSlash: (start: string, end: string) => string;
    // (undocumented)
    ngOnDestroy(): void;
    normalize(url: string): string;
    static normalizeQueryParams: (params: string) => string;
    onUrlChange(fn: (url: string, state: unknown) => void): VoidFunction;
    path(includeHash?: boolean): string;
    prepareExternalUrl(url: string): string;
    replaceState(path: string, query?: string, state?: any): void;
    static stripTrailingSlash: (url: string) => string;
    subscribe(onNext: (value: PopStateEvent_2) => void, onThrow?: ((exception: any) => void) | null, onReturn?: (() => void) | null): SubscriptionLike;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<Location_2, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<Location_2>;
}
export { Location_2 as Location }

// @public
export const LOCATION_INITIALIZED: InjectionToken<Promise<any>>;

// @public
export interface LocationChangeEvent {
    // (undocumented)
    state: any;
    // (undocumented)
    type: string;
}

// @public (undocumented)
export interface LocationChangeListener {
    // (undocumented)
    (event: LocationChangeEvent): any;
}

// @public
export abstract class LocationStrategy {
    // (undocumented)
    abstract back(): void;
    // (undocumented)
    abstract forward(): void;
    // (undocumented)
    abstract getBaseHref(): string;
    // (undocumented)
    abstract getState(): unknown;
    // (undocumented)
    historyGo?(relativePosition: number): void;
    // (undocumented)
    abstract onPopState(fn: LocationChangeListener): void;
    // (undocumented)
    abstract path(includeHash?: boolean): string;
    // (undocumented)
    abstract prepareExternalUrl(internal: string): string;
    // (undocumented)
    abstract pushState(state: any, title: string, url: string, queryParams: string): void;
    // (undocumented)
    abstract replaceState(state: any, title: string, url: string, queryParams: string): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<LocationStrategy, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<LocationStrategy>;
}

// @public
export class LowerCasePipe implements PipeTransform {
    // (undocumented)
    transform(value: string): string;
    // (undocumented)
    transform(value: null | undefined): null;
    // (undocumented)
    transform(value: string | null | undefined): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<LowerCasePipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<LowerCasePipe, "lowercase", true>;
}

// @public
export class NgClass implements DoCheck {
    constructor(_ngEl: ElementRef, _renderer: Renderer2);
    // (undocumented)
    set klass(value: string);
    // (undocumented)
    set ngClass(value: string | string[] | Set<string> | {
        [klass: string]: any;
    } | null | undefined);
    // (undocumented)
    ngDoCheck(): void;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgClass, "[ngClass]", never, { "klass": { "alias": "class"; "required": false; }; "ngClass": { "alias": "ngClass"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgClass, never>;
}

// @public
export class NgComponentOutlet implements OnChanges, DoCheck, OnDestroy {
    constructor(_viewContainerRef: ViewContainerRef);
    // (undocumented)
    ngComponentOutlet: Type<any> | null;
    // (undocumented)
    ngComponentOutletContent?: any[][];
    // (undocumented)
    ngComponentOutletInjector?: Injector;
    // (undocumented)
    ngComponentOutletInputs?: Record<string, unknown>;
    // (undocumented)
    ngComponentOutletNgModule?: Type<any>;
    // @deprecated (undocumented)
    ngComponentOutletNgModuleFactory?: NgModuleFactory<any>;
    // (undocumented)
    ngDoCheck(): void;
    // (undocumented)
    ngOnChanges(changes: SimpleChanges): void;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgComponentOutlet, "[ngComponentOutlet]", never, { "ngComponentOutlet": { "alias": "ngComponentOutlet"; "required": false; }; "ngComponentOutletInputs": { "alias": "ngComponentOutletInputs"; "required": false; }; "ngComponentOutletInjector": { "alias": "ngComponentOutletInjector"; "required": false; }; "ngComponentOutletContent": { "alias": "ngComponentOutletContent"; "required": false; }; "ngComponentOutletNgModule": { "alias": "ngComponentOutletNgModule"; "required": false; }; "ngComponentOutletNgModuleFactory": { "alias": "ngComponentOutletNgModuleFactory"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgComponentOutlet, never>;
}

// @public
class NgForOf<T, U extends NgIterable<T> = NgIterable<T>> implements DoCheck {
    constructor(_viewContainer: ViewContainerRef, _template: TemplateRef<NgForOfContext<T, U>>, _differs: IterableDiffers);
    ngDoCheck(): void;
    set ngForOf(ngForOf: (U & NgIterable<T>) | undefined | null);
    set ngForTemplate(value: TemplateRef<NgForOfContext<T, U>>);
    set ngForTrackBy(fn: TrackByFunction<T>);
    // (undocumented)
    get ngForTrackBy(): TrackByFunction<T>;
    static ngTemplateContextGuard<T, U extends NgIterable<T>>(dir: NgForOf<T, U>, ctx: any): ctx is NgForOfContext<T, U>;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgForOf<any, any>, "[ngFor][ngForOf]", never, { "ngForOf": { "alias": "ngForOf"; "required": false; }; "ngForTrackBy": { "alias": "ngForTrackBy"; "required": false; }; "ngForTemplate": { "alias": "ngForTemplate"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgForOf<any, any>, never>;
}
export { NgForOf as NgFor }
export { NgForOf }

// @public (undocumented)
export class NgForOfContext<T, U extends NgIterable<T> = NgIterable<T>> {
    // (undocumented)
    $implicit: T;
    constructor($implicit: T, ngForOf: U, index: number, count: number);
    // (undocumented)
    count: number;
    // (undocumented)
    get even(): boolean;
    // (undocumented)
    get first(): boolean;
    // (undocumented)
    index: number;
    // (undocumented)
    get last(): boolean;
    // (undocumented)
    ngForOf: U;
    // (undocumented)
    get odd(): boolean;
}

// @public
export class NgIf<T = unknown> {
    constructor(_viewContainer: ViewContainerRef, templateRef: TemplateRef<NgIfContext<T>>);
    set ngIf(condition: T);
    set ngIfElse(templateRef: TemplateRef<NgIfContext<T>> | null);
    set ngIfThen(templateRef: TemplateRef<NgIfContext<T>> | null);
    static ngTemplateContextGuard<T>(dir: NgIf<T>, ctx: any): ctx is NgIfContext<Exclude<T, false | 0 | '' | null | undefined>>;
    static ngTemplateGuard_ngIf: 'binding';
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgIf<any>, "[ngIf]", never, { "ngIf": { "alias": "ngIf"; "required": false; }; "ngIfThen": { "alias": "ngIfThen"; "required": false; }; "ngIfElse": { "alias": "ngIfElse"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgIf<any>, never>;
}

// @public (undocumented)
export class NgIfContext<T = unknown> {
    // (undocumented)
    $implicit: T;
    // (undocumented)
    ngIf: T;
}

// @public
export class NgLocaleLocalization extends NgLocalization {
    constructor(locale: string);
    // (undocumented)
    getPluralCategory(value: any, locale?: string): string;
    // (undocumented)
    protected locale: string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgLocaleLocalization, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<NgLocaleLocalization>;
}

// @public (undocumented)
export abstract class NgLocalization {
    // (undocumented)
    abstract getPluralCategory(value: any, locale?: string): string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgLocalization, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<NgLocalization>;
}

// @public
export class NgOptimizedImage implements OnInit, OnChanges, OnDestroy {
    disableOptimizedSrcset: boolean;
    fill: boolean;
    height: number | undefined;
    loaderParams?: {
        [key: string]: any;
    };
    loading?: 'lazy' | 'eager' | 'auto';
    // (undocumented)
    static ngAcceptInputType_disableOptimizedSrcset: unknown;
    // (undocumented)
    static ngAcceptInputType_fill: unknown;
    // (undocumented)
    static ngAcceptInputType_height: unknown;
    // (undocumented)
    static ngAcceptInputType_ngSrc: string | i0.ɵSafeValue;
    // (undocumented)
    static ngAcceptInputType_placeholder: boolean | string;
    // (undocumented)
    static ngAcceptInputType_priority: unknown;
    // (undocumented)
    static ngAcceptInputType_width: unknown;
    // (undocumented)
    ngOnChanges(changes: SimpleChanges): void;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    ngOnInit(): void;
    ngSrc: string;
    ngSrcset: string;
    placeholder?: string | boolean;
    placeholderConfig?: ImagePlaceholderConfig;
    priority: boolean;
    sizes?: string;
    width: number | undefined;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgOptimizedImage, "img[ngSrc]", never, { "ngSrc": { "alias": "ngSrc"; "required": true; }; "ngSrcset": { "alias": "ngSrcset"; "required": false; }; "sizes": { "alias": "sizes"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "priority": { "alias": "priority"; "required": false; }; "loaderParams": { "alias": "loaderParams"; "required": false; }; "disableOptimizedSrcset": { "alias": "disableOptimizedSrcset"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderConfig": { "alias": "placeholderConfig"; "required": false; }; "src": { "alias": "src"; "required": false; }; "srcset": { "alias": "srcset"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgOptimizedImage, never>;
}

// @public
export class NgPlural {
    constructor(_localization: NgLocalization);
    // (undocumented)
    addCase(value: string, switchView: SwitchView): void;
    // (undocumented)
    set ngPlural(value: number);
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgPlural, "[ngPlural]", never, { "ngPlural": { "alias": "ngPlural"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgPlural, never>;
}

// @public
export class NgPluralCase {
    constructor(value: string, template: TemplateRef<Object>, viewContainer: ViewContainerRef, ngPlural: NgPlural);
    // (undocumented)
    value: string;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgPluralCase, "[ngPluralCase]", never, {}, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgPluralCase, [{ attribute: "ngPluralCase"; }, null, null, { host: true; }]>;
}

// @public
export class NgStyle implements DoCheck {
    constructor(_ngEl: ElementRef, _differs: KeyValueDiffers, _renderer: Renderer2);
    // (undocumented)
    ngDoCheck(): void;
    // (undocumented)
    set ngStyle(values: {
        [klass: string]: any;
    } | null | undefined);
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgStyle, "[ngStyle]", never, { "ngStyle": { "alias": "ngStyle"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgStyle, never>;
}

// @public
export class NgSwitch {
    // (undocumented)
    set ngSwitch(newValue: any);
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgSwitch, "[ngSwitch]", never, { "ngSwitch": { "alias": "ngSwitch"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgSwitch, never>;
}

// @public
export class NgSwitchCase implements DoCheck {
    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>, ngSwitch: NgSwitch);
    ngDoCheck(): void;
    ngSwitchCase: any;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgSwitchCase, "[ngSwitchCase]", never, { "ngSwitchCase": { "alias": "ngSwitchCase"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgSwitchCase, [null, null, { optional: true; host: true; }]>;
}

// @public
export class NgSwitchDefault {
    constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>, ngSwitch: NgSwitch);
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgSwitchDefault, "[ngSwitchDefault]", never, {}, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgSwitchDefault, [null, null, { optional: true; host: true; }]>;
}

// @public
export class NgTemplateOutlet<C = unknown> implements OnChanges {
    constructor(_viewContainerRef: ViewContainerRef);
    // (undocumented)
    ngOnChanges(changes: SimpleChanges): void;
    ngTemplateOutlet: TemplateRef<C> | null;
    ngTemplateOutletContext: C | null;
    ngTemplateOutletInjector: Injector | null;
    // (undocumented)
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgTemplateOutlet<any>, "[ngTemplateOutlet]", never, { "ngTemplateOutletContext": { "alias": "ngTemplateOutletContext"; "required": false; }; "ngTemplateOutlet": { "alias": "ngTemplateOutlet"; "required": false; }; "ngTemplateOutletInjector": { "alias": "ngTemplateOutletInjector"; "required": false; }; }, {}, never, never, true, never>;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<NgTemplateOutlet<any>, never>;
}

// @public @deprecated
export enum NumberFormatStyle {
    // (undocumented)
    Currency = 2,
    // (undocumented)
    Decimal = 0,
    // (undocumented)
    Percent = 1,
    // (undocumented)
    Scientific = 3
}

// @public @deprecated
export const NumberSymbol: {
    readonly Decimal: 0;
    readonly Group: 1;
    readonly List: 2;
    readonly PercentSign: 3;
    readonly PlusSign: 4;
    readonly MinusSign: 5;
    readonly Exponential: 6;
    readonly SuperscriptingExponent: 7;
    readonly PerMille: 8;
    readonly Infinity: 9;
    readonly NaN: 10;
    readonly TimeSeparator: 11;
    readonly CurrencyDecimal: 12;
    readonly CurrencyGroup: 13;
};

// @public (undocumented)
export type NumberSymbol = (typeof NumberSymbol)[keyof typeof NumberSymbol];

// @public
export class PathLocationStrategy extends LocationStrategy implements OnDestroy {
    constructor(_platformLocation: PlatformLocation, href?: string);
    // (undocumented)
    back(): void;
    // (undocumented)
    forward(): void;
    // (undocumented)
    getBaseHref(): string;
    // (undocumented)
    getState(): unknown;
    // (undocumented)
    historyGo(relativePosition?: number): void;
    // (undocumented)
    ngOnDestroy(): void;
    // (undocumented)
    onPopState(fn: LocationChangeListener): void;
    // (undocumented)
    path(includeHash?: boolean): string;
    // (undocumented)
    prepareExternalUrl(internal: string): string;
    // (undocumented)
    pushState(state: any, title: string, url: string, queryParams: string): void;
    // (undocumented)
    replaceState(state: any, title: string, url: string, queryParams: string): void;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<PathLocationStrategy, [null, { optional: true; }]>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<PathLocationStrategy>;
}

// @public
export class PercentPipe implements PipeTransform {
    constructor(_locale: string);
    // (undocumented)
    transform(value: number | string, digitsInfo?: string, locale?: string): string | null;
    // (undocumented)
    transform(value: null | undefined, digitsInfo?: string, locale?: string): null;
    // (undocumented)
    transform(value: number | string | null | undefined, digitsInfo?: string, locale?: string): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<PercentPipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<PercentPipe, "percent", true>;
}

// @public
export abstract class PlatformLocation {
    // (undocumented)
    abstract back(): void;
    // (undocumented)
    abstract forward(): void;
    // (undocumented)
    abstract getBaseHrefFromDOM(): string;
    // (undocumented)
    abstract getState(): unknown;
    // (undocumented)
    abstract get hash(): string;
    // (undocumented)
    historyGo?(relativePosition: number): void;
    // (undocumented)
    abstract get hostname(): string;
    // (undocumented)
    abstract get href(): string;
    abstract onHashChange(fn: LocationChangeListener): VoidFunction;
    abstract onPopState(fn: LocationChangeListener): VoidFunction;
    // (undocumented)
    abstract get pathname(): string;
    // (undocumented)
    abstract get port(): string;
    // (undocumented)
    abstract get protocol(): string;
    // (undocumented)
    abstract pushState(state: any, title: string, url: string): void;
    // (undocumented)
    abstract replaceState(state: any, title: string, url: string): void;
    // (undocumented)
    abstract get search(): string;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformLocation, never>;
    // (undocumented)
    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformLocation>;
}

// @public @deprecated
export enum Plural {
    // (undocumented)
    Few = 3,
    // (undocumented)
    Many = 4,
    // (undocumented)
    One = 1,
    // (undocumented)
    Other = 5,
    // (undocumented)
    Two = 2,
    // (undocumented)
    Zero = 0
}

// @public (undocumented)
interface PopStateEvent_2 {
    // (undocumented)
    pop?: boolean;
    // (undocumented)
    state?: any;
    // (undocumented)
    type?: string;
    // (undocumented)
    url?: string;
}
export { PopStateEvent_2 as PopStateEvent }

// @public
export const PRECONNECT_CHECK_BLOCKLIST: InjectionToken<(string | string[])[]>;

// @public
export const provideCloudflareLoader: (path: string) => Provider[];

// @public
export const provideCloudinaryLoader: (path: string) => Provider[];

// @public
export const provideImageKitLoader: (path: string) => Provider[];

// @public
export const provideImgixLoader: (path: string) => Provider[];

// @public
export function provideNetlifyLoader(path?: string): Provider[];

// @public
export function registerLocaleData(data: any, localeId?: string | any, extraData?: any): void;

// @public
export class SlicePipe implements PipeTransform {
    // (undocumented)
    transform<T>(value: ReadonlyArray<T>, start: number, end?: number): Array<T>;
    // (undocumented)
    transform(value: null | undefined, start: number, end?: number): null;
    // (undocumented)
    transform<T>(value: ReadonlyArray<T> | null | undefined, start: number, end?: number): Array<T> | null;
    // (undocumented)
    transform(value: string, start: number, end?: number): string;
    // (undocumented)
    transform(value: string | null | undefined, start: number, end?: number): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<SlicePipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<SlicePipe, "slice", true>;
}

// @public @deprecated
export type Time = {
    hours: number;
    minutes: number;
};

// @public
export class TitleCasePipe implements PipeTransform {
    // (undocumented)
    transform(value: string): string;
    // (undocumented)
    transform(value: null | undefined): null;
    // (undocumented)
    transform(value: string | null | undefined): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleCasePipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<TitleCasePipe, "titlecase", true>;
}

// @public @deprecated
export enum TranslationWidth {
    Abbreviated = 1,
    Narrow = 0,
    Short = 3,
    Wide = 2
}

// @public
export class UpperCasePipe implements PipeTransform {
    // (undocumented)
    transform(value: string): string;
    // (undocumented)
    transform(value: null | undefined): null;
    // (undocumented)
    transform(value: string | null | undefined): string | null;
    // (undocumented)
    static ɵfac: i0.ɵɵFactoryDeclaration<UpperCasePipe, never>;
    // (undocumented)
    static ɵpipe: i0.ɵɵPipeDeclaration<UpperCasePipe, "uppercase", true>;
}

// @public (undocumented)
export const VERSION: Version;

// @public
export abstract class ViewportScroller {
    abstract getScrollPosition(): [number, number];
    abstract scrollToAnchor(anchor: string): void;
    abstract scrollToPosition(position: [number, number]): void;
    abstract setHistoryScrollRestoration(scrollRestoration: 'auto' | 'manual'): void;
    abstract setOffset(offset: [number, number] | (() => [number, number])): void;
    // (undocumented)
    static ɵprov: unknown;
}

// @public @deprecated
export enum WeekDay {
    // (undocumented)
    Friday = 5,
    // (undocumented)
    Monday = 1,
    // (undocumented)
    Saturday = 6,
    // (undocumented)
    Sunday = 0,
    // (undocumented)
    Thursday = 4,
    // (undocumented)
    Tuesday = 2,
    // (undocumented)
    Wednesday = 3
}

// @public
export abstract class XhrFactory {
    // (undocumented)
    abstract build(): XMLHttpRequest;
}

// (No @packageDocumentation comment for this package)