@stemy/ngx-utils 13.6.17 → 17.0.0

package/ngx-utils/services/events.service.d.ts

@@ -1,14 +1,14 @@
-import { EventEmitter } from "@angular/core";
-import * as i0 from "@angular/core";
-export declare class EventsService {
-    readonly eventForwarded: EventEmitter<Event>;
-    readonly stickyUpdated: EventEmitter<boolean>;
-    readonly languageChanged: EventEmitter<string>;
-    private sticky;
-    get isSticky(): boolean;
-    constructor();
-    event(e: Event): void;
-    updateSticky(sticky: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EventsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EventsService>;
-}
+import { EventEmitter } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class EventsService {
+    readonly eventForwarded: EventEmitter<Event>;
+    readonly stickyUpdated: EventEmitter<boolean>;
+    readonly languageChanged: EventEmitter<string>;
+    private sticky;
+    get isSticky(): boolean;
+    constructor();
+    event(e: Event): void;
+    updateSticky(sticky: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventsService>;
+}

package/ngx-utils/services/formatter.service.d.ts

@@ -1,15 +1,15 @@
-import { ILanguageService } from "../common-types";
-import * as i0 from "@angular/core";
-export declare class FormatterService {
-    language: ILanguageService;
-    get defaultPrecision(): number;
-    get defaultNumberFormat(): string;
-    get defaultDivider(): number;
-    constructor(language: ILanguageService);
-    roundNumber(value: number, precision?: number, divider?: number): number;
-    formatNumber(value: number | string, format?: string, precision?: number, divider?: number, minDigits?: number): string;
-    formatMillimeter(value: number, precision?: number, divider?: number): string;
-    protected getPrecision(precision: number): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormatterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FormatterService>;
-}
+import { ILanguageService } from "../common-types";
+import * as i0 from "@angular/core";
+export declare class FormatterService {
+    language: ILanguageService;
+    get defaultPrecision(): number;
+    get defaultNumberFormat(): string;
+    get defaultDivider(): number;
+    constructor(language: ILanguageService);
+    roundNumber(value: number, precision?: number, divider?: number): number;
+    formatNumber(value: number | string, format?: string, precision?: number, divider?: number, minDigits?: number): string;
+    formatMillimeter(value: number, precision?: number, divider?: number): string;
+    protected getPrecision(precision: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormatterService>;
+}

package/ngx-utils/services/global-template.service.d.ts

@@ -1,19 +1,19 @@
-import { EventEmitter, TemplateRef } from "@angular/core";
-import { GlobalComponentModifier, IGlobalTemplates } from "../common-types";
-import * as i0 from "@angular/core";
-export declare class GlobalTemplateService implements IGlobalTemplates {
-    readonly templatesUpdated: EventEmitter<void>;
-    protected globalTemplates: {
-        [id: string]: TemplateRef<any>;
-    };
-    protected componentModifiers: {
-        [id: string]: GlobalComponentModifier;
-    };
-    constructor();
-    get(id: string, component?: any): TemplateRef<any>;
-    add(id: string, template: TemplateRef<any>): void;
-    remove(id: string): void;
-    addComponentModifier(id: string, modifier: GlobalComponentModifier): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalTemplateService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalTemplateService>;
-}
+import { EventEmitter, TemplateRef } from "@angular/core";
+import { GlobalComponentModifier, IGlobalTemplates } from "../common-types";
+import * as i0 from "@angular/core";
+export declare class GlobalTemplateService implements IGlobalTemplates {
+    readonly templatesUpdated: EventEmitter<void>;
+    protected globalTemplates: {
+        [id: string]: TemplateRef<any>;
+    };
+    protected componentModifiers: {
+        [id: string]: GlobalComponentModifier;
+    };
+    constructor();
+    get(id: string, component?: any): TemplateRef<any>;
+    add(id: string, template: TemplateRef<any>): void;
+    remove(id: string): void;
+    addComponentModifier(id: string, modifier: GlobalComponentModifier): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalTemplateService>;
+}

package/ngx-utils/services/icon.service.d.ts

@@ -1,13 +1,13 @@
-import { EventEmitter } from "@angular/core";
-import { IIconService } from "../common-types";
-import * as i0 from "@angular/core";
-export declare class IconService implements IIconService {
-    get isDisabled(): boolean;
-    set isDisabled(value: boolean);
-    readonly iconsLoaded: EventEmitter<any>;
-    protected disabled: boolean;
-    constructor();
-    getIcon(icon: string, activeIcon: string, active: boolean): Promise<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<IconService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<IconService>;
-}
+import { EventEmitter } from "@angular/core";
+import { IIconService } from "../common-types";
+import * as i0 from "@angular/core";
+export declare class IconService implements IIconService {
+    get isDisabled(): boolean;
+    set isDisabled(value: boolean);
+    readonly iconsLoaded: EventEmitter<any>;
+    protected disabled: boolean;
+    constructor();
+    getIcon(icon: string, activeIcon: string, active: boolean): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconService>;
+}

package/ngx-utils/services/language.service.d.ts

@@ -1,21 +1,21 @@
-import { BehaviorSubject, Observable } from "rxjs";
-import { ILanguageSetting, ILanguageSettings, ITranslations } from "../common-types";
-import { StaticLanguageService } from "./static-language.service";
-import * as i0 from "@angular/core";
-export declare class LanguageService extends StaticLanguageService {
-    protected translationRequests: ITranslations;
-    protected settingsPromise: Promise<ILanguageSettings>;
-    protected languageSettings: BehaviorSubject<ILanguageSettings>;
-    get currentLanguage(): string;
-    set currentLanguage(lang: string);
-    get settings(): ILanguageSetting;
-    get $settings(): Observable<ILanguageSetting>;
-    protected initService(): void;
-    initFromSettings(): Promise<any>;
-    getTranslation(key: string, params?: any): Promise<string>;
-    protected useLanguage(lang: string): Promise<ITranslations>;
-    protected loadDictionary(): Promise<any>;
-    protected loadSettings(): Promise<ILanguageSettings>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageService>;
-}
+import { BehaviorSubject, Observable } from "rxjs";
+import { ILanguageSetting, ILanguageSettings, ITranslations } from "../common-types";
+import { StaticLanguageService } from "./static-language.service";
+import * as i0 from "@angular/core";
+export declare class LanguageService extends StaticLanguageService {
+    protected translationRequests: ITranslations;
+    protected settingsPromise: Promise<ILanguageSettings>;
+    protected languageSettings: BehaviorSubject<ILanguageSettings>;
+    get currentLanguage(): string;
+    set currentLanguage(lang: string);
+    get settings(): ILanguageSetting;
+    get $settings(): Observable<ILanguageSetting>;
+    protected initService(): void;
+    initFromSettings(): Promise<any>;
+    getTranslation(key: string, params?: any): Promise<string>;
+    protected useLanguage(lang: string): Promise<ITranslations>;
+    protected loadDictionary(): Promise<any>;
+    protected loadSettings(): Promise<ILanguageSettings>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageService>;
+}

package/ngx-utils/services/local-http.service.d.ts

@@ -1,14 +1,14 @@
-import { IRequestOptions } from "../common-types";
-import { BaseHttpService } from "./base-http.service";
-import * as i0 from "@angular/core";
-export declare class LocalHttpService extends BaseHttpService {
-    private images;
-    get name(): string;
-    protected get withCredentials(): boolean;
-    protected initService(): void;
-    url(url: string): string;
-    get(url: string, options?: IRequestOptions): Promise<any>;
-    getImage(url: string): Promise<HTMLImageElement>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LocalHttpService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LocalHttpService>;
-}
+import { IRequestOptions } from "../common-types";
+import { BaseHttpService } from "./base-http.service";
+import * as i0 from "@angular/core";
+export declare class LocalHttpService extends BaseHttpService {
+    private images;
+    get name(): string;
+    protected get withCredentials(): boolean;
+    protected initService(): void;
+    url(url: string): string;
+    get(url: string, options?: IRequestOptions): Promise<any>;
+    getImage(url: string): Promise<HTMLImageElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalHttpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalHttpService>;
+}

package/ngx-utils/services/open-api.service.d.ts

@@ -1,11 +1,11 @@
-import { IApiService, IOpenApiSchema, IOpenApiSchemas } from "../common-types";
-import * as i0 from "@angular/core";
-export declare class OpenApiService {
-    readonly api: IApiService;
-    private schemasPromise;
-    constructor(api: IApiService);
-    getSchemas(): Promise<IOpenApiSchemas>;
-    getSchema(name: string): Promise<IOpenApiSchema>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<OpenApiService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<OpenApiService>;
-}
+import { IApiService, IOpenApiSchema, IOpenApiSchemas } from "../common-types";
+import * as i0 from "@angular/core";
+export declare class OpenApiService {
+    readonly api: IApiService;
+    private schemasPromise;
+    constructor(api: IApiService);
+    getSchemas(): Promise<IOpenApiSchemas>;
+    getSchema(name: string): Promise<IOpenApiSchema>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenApiService>;
+}

package/ngx-utils/services/promise.service.d.ts

@@ -1,19 +1,19 @@
-import { EventEmitter, NgZone } from "@angular/core";
-import { IPromiseService } from "../common-types";
-import * as i0 from "@angular/core";
-export declare class PromiseService implements IPromiseService {
-    readonly zone: NgZone;
-    get count(): number;
-    get onChanged(): EventEmitter<number>;
-    protected promiseCount: number;
-    protected readonly promiseChanged: EventEmitter<number>;
-    constructor(zone: NgZone);
-    create<T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
-    all(promises: Promise<any>[]): Promise<any>;
-    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
-    reject<T>(value: T | PromiseLike<T>): Promise<T>;
-    protected promiseFinished(): void;
-    protected add<T>(promise: Promise<T>): Promise<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PromiseService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<PromiseService>;
-}
+import { EventEmitter, NgZone } from "@angular/core";
+import { IPromiseService } from "../common-types";
+import * as i0 from "@angular/core";
+export declare class PromiseService implements IPromiseService {
+    readonly zone: NgZone;
+    get count(): number;
+    get onChanged(): EventEmitter<number>;
+    protected promiseCount: number;
+    protected readonly promiseChanged: EventEmitter<number>;
+    constructor(zone: NgZone);
+    create<T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+    all(promises: Promise<any>[]): Promise<any>;
+    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+    reject<T>(value: T | PromiseLike<T>): Promise<T>;
+    protected promiseFinished(): void;
+    protected add<T>(promise: Promise<T>): Promise<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PromiseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PromiseService>;
+}

package/ngx-utils/services/state.service.d.ts

@@ -1,49 +1,49 @@
-import { Injector, NgZone } from "@angular/core";
-import { ActivatedRouteSnapshot, Data, Event, NavigationExtras, Params, Route, Router, UrlSegment, UrlTree } from "@angular/router";
-import { BehaviorSubject, Subscription } from "rxjs";
-import { IRoute, NavigationUrlParam } from "../common-types";
-import { UniversalService } from "./universal.service";
-import * as i0 from "@angular/core";
-export declare const emptySnapshot: ActivatedRouteSnapshot;
-export declare const emptyData: Data;
-export declare const emptyParams: Params;
-export declare const emptySegments: UrlSegment[];
-export declare const emptyComponents: any[];
-export interface IStateInfo {
-    url: string;
-    segments: UrlSegment[];
-    components: any[];
-}
-export declare class StateService extends BehaviorSubject<any> {
-    readonly injector: Injector;
-    readonly zone: NgZone;
-    readonly universal: UniversalService;
-    readonly router: Router;
-    readonly globalExtras: NavigationExtras;
-    private shot;
-    private comp;
-    private stateInfo;
-    private contexts;
-    static toPath(route: Route, params: any): string;
-    get component(): any;
-    get snapshot(): ActivatedRouteSnapshot;
-    get route(): IRoute;
-    get data(): Data;
-    get params(): Params;
-    get queryParams(): Params;
-    get url(): string;
-    get urlSegments(): UrlSegment[];
-    get components(): any[];
-    get routerConfig(): IRoute[];
-    constructor(injector: Injector, zone: NgZone, universal: UniversalService, router?: Router);
-    reload(): Promise<any>;
-    navigateByUrl(url: string | UrlTree, navigationExtras?: NavigationExtras): Promise<boolean>;
-    navigate(url: NavigationUrlParam, navigationExtras?: NavigationExtras): Promise<boolean>;
-    open(url: NavigationUrlParam, target?: string, navigationExtras?: NavigationExtras): Promise<boolean>;
-    subscribeImmediately(next?: (value: ActivatedRouteSnapshot) => void, error?: (error: any) => void, complete?: () => void): Subscription;
-    protected openInNewWindow(tree: UrlTree, target: string): boolean;
-    protected createUrlTree(url: NavigationUrlParam, extras?: NavigationExtras): [UrlTree, NavigationExtras];
-    protected handleRouterEvent: (event: Event) => void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StateService, [null, null, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StateService>;
-}
+import { Injector, NgZone } from "@angular/core";
+import { ActivatedRouteSnapshot, ChildrenOutletContexts, Data, Event, NavigationExtras, Params, Route, Router, UrlSegment, UrlTree } from "@angular/router";
+import { BehaviorSubject, Subscription } from "rxjs";
+import { IRoute, NavigationUrlParam } from "../common-types";
+import { UniversalService } from "./universal.service";
+import * as i0 from "@angular/core";
+export declare const emptySnapshot: ActivatedRouteSnapshot;
+export declare const emptyData: Data;
+export declare const emptyParams: Params;
+export declare const emptySegments: UrlSegment[];
+export declare const emptyComponents: any[];
+export interface IStateInfo {
+    url: string;
+    segments: UrlSegment[];
+    components: any[];
+}
+export declare class StateService extends BehaviorSubject<any> {
+    readonly injector: Injector;
+    readonly zone: NgZone;
+    readonly universal: UniversalService;
+    readonly router: Router;
+    readonly contexts: ChildrenOutletContexts;
+    readonly globalExtras: NavigationExtras;
+    private shot;
+    private comp;
+    private stateInfo;
+    static toPath(route: Route, params: any): string;
+    get component(): any;
+    get snapshot(): ActivatedRouteSnapshot;
+    get route(): IRoute;
+    get data(): Data;
+    get params(): Params;
+    get queryParams(): Params;
+    get url(): string;
+    get urlSegments(): UrlSegment[];
+    get components(): any[];
+    get routerConfig(): IRoute[];
+    constructor(injector: Injector, zone: NgZone, universal: UniversalService, router?: Router, contexts?: ChildrenOutletContexts);
+    reload(): Promise<any>;
+    navigateByUrl(url: string | UrlTree, navigationExtras?: NavigationExtras): Promise<boolean>;
+    navigate(url: NavigationUrlParam, navigationExtras?: NavigationExtras): Promise<boolean>;
+    open(url: NavigationUrlParam, target?: string, navigationExtras?: NavigationExtras): Promise<boolean>;
+    subscribeImmediately(next?: (value: ActivatedRouteSnapshot) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+    protected openInNewWindow(tree: UrlTree, target: string): boolean;
+    protected createUrlTree(url: NavigationUrlParam, extras?: NavigationExtras): [UrlTree, NavigationExtras];
+    protected handleRouterEvent: (event: Event) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateService, [null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateService>;
+}

package/ngx-utils/services/static-language.service.d.ts

@@ -1,46 +1,46 @@
-import { IConfigService, IConfiguration, ILanguageService, IPromiseService, ITranslation, ITranslations } from "../common-types";
-import { EventsService } from "./events.service";
-import { StorageService } from "./storage.service";
-import { UniversalService } from "./universal.service";
-import { BaseHttpClient } from "./base-http.client";
-import { HttpClient } from "@angular/common/http";
-import * as i0 from "@angular/core";
-export declare class StaticLanguageService implements ILanguageService {
-    readonly events: EventsService;
-    readonly storage: StorageService;
-    readonly configs: IConfigService;
-    protected promises: IPromiseService;
-    protected client: BaseHttpClient;
-    get defaultLanguage(): string;
-    get dictionary(): ITranslations;
-    set dictionary(value: ITranslations);
-    get languages(): ReadonlyArray<string>;
-    get currentLanguage(): string;
-    set currentLanguage(lang: string);
-    get editLanguage(): string;
-    set editLanguage(lang: string);
-    get disableTranslations(): boolean;
-    set disableTranslations(value: boolean);
-    get httpClient(): HttpClient;
-    get config(): IConfiguration;
-    get universal(): UniversalService;
-    protected editLang: string;
-    protected currentLang: string;
-    protected disableTrans: boolean;
-    protected languageList: string[];
-    protected readonly translations: ITranslations;
-    constructor(events: EventsService, storage: StorageService, configs: IConfigService, promises: IPromiseService, client: BaseHttpClient);
-    protected initService(): void;
-    replaceLanguages(languages: string[]): void;
-    addLanguages(languages: string[]): void;
-    getTranslationSync(key: string, params?: any): string;
-    getTranslation(key: string, params?: any): Promise<string>;
-    getTranslations(...keys: string[]): Promise<ITranslations>;
-    getTranslationFromObject(translations: ITranslations, params?: any, lang?: string): string;
-    getTranslationFromArray(translations: ITranslation[], params?: any, lang?: string): string;
-    protected interpolate(expr: string | Function, params?: any): string;
-    protected interpolateString(expr: string, params?: any): string;
-    protected getDefaultLanguage(): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StaticLanguageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StaticLanguageService>;
-}
+import { IConfigService, IConfiguration, ILanguageService, IPromiseService, ITranslation, ITranslations } from "../common-types";
+import { EventsService } from "./events.service";
+import { StorageService } from "./storage.service";
+import { UniversalService } from "./universal.service";
+import { BaseHttpClient } from "./base-http.client";
+import { HttpClient } from "@angular/common/http";
+import * as i0 from "@angular/core";
+export declare class StaticLanguageService implements ILanguageService {
+    readonly events: EventsService;
+    readonly storage: StorageService;
+    readonly configs: IConfigService;
+    protected promises: IPromiseService;
+    protected client: BaseHttpClient;
+    get defaultLanguage(): string;
+    get dictionary(): ITranslations;
+    set dictionary(value: ITranslations);
+    get languages(): ReadonlyArray<string>;
+    get currentLanguage(): string;
+    set currentLanguage(lang: string);
+    get editLanguage(): string;
+    set editLanguage(lang: string);
+    get disableTranslations(): boolean;
+    set disableTranslations(value: boolean);
+    get httpClient(): HttpClient;
+    get config(): IConfiguration;
+    get universal(): UniversalService;
+    protected editLang: string;
+    protected currentLang: string;
+    protected disableTrans: boolean;
+    protected languageList: string[];
+    protected readonly translations: ITranslations;
+    constructor(events: EventsService, storage: StorageService, configs: IConfigService, promises: IPromiseService, client: BaseHttpClient);
+    protected initService(): void;
+    replaceLanguages(languages: string[]): void;
+    addLanguages(languages: string[]): void;
+    getTranslationSync(key: string, params?: any): string;
+    getTranslation(key: string, params?: any): Promise<string>;
+    getTranslations(...keys: string[]): Promise<ITranslations>;
+    getTranslationFromObject(translations: ITranslations, params?: any, lang?: string): string;
+    getTranslationFromArray(translations: ITranslation[], params?: any, lang?: string): string;
+    protected interpolate(expr: string | Function, params?: any): string;
+    protected interpolateString(expr: string, params?: any): string;
+    protected getDefaultLanguage(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StaticLanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StaticLanguageService>;
+}

package/ngx-utils/services/storage.service.d.ts

@@ -1,15 +1,15 @@
-import { StorageMode } from "../common-types";
-import { UniversalService } from "./universal.service";
-import * as i0 from "@angular/core";
-/**
- * Use this service instead of Storage to avoid Angular Universal breaks on server environment
- */
-export declare class StorageService {
-    readonly universal: UniversalService;
-    constructor(universal: UniversalService);
-    get(key: string, defaultValue?: any, mode?: StorageMode): any;
-    set(key: string, value: any, mode?: StorageMode): void;
-    remove(key: string, mode?: StorageMode): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
-}
+import { StorageMode } from "../common-types";
+import { UniversalService } from "./universal.service";
+import * as i0 from "@angular/core";
+/**
+ * Use this service instead of Storage to avoid Angular Universal breaks on server environment
+ */
+export declare class StorageService {
+    readonly universal: UniversalService;
+    constructor(universal: UniversalService);
+    get(key: string, defaultValue?: any, mode?: StorageMode): any;
+    set(key: string, value: any, mode?: StorageMode): void;
+    remove(key: string, mode?: StorageMode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StorageService>;
+}

package/ngx-utils/services/toaster.service.d.ts

@@ -1,13 +1,13 @@
-import { ILanguageService, IToasterService } from "../common-types";
-import * as i0 from "@angular/core";
-export declare class ConsoleToasterService implements IToasterService {
-    private language;
-    constructor(language: ILanguageService);
-    error(message: string, params?: any, title?: string): void;
-    info(message: string, params?: any, title?: string): void;
-    success(message: string, params?: any, title?: string): void;
-    warning(message: string, params?: any, title?: string): void;
-    private translateMessage;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleToasterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConsoleToasterService>;
-}
+import { ILanguageService, IToasterService } from "../common-types";
+import * as i0 from "@angular/core";
+export declare class ConsoleToasterService implements IToasterService {
+    private language;
+    constructor(language: ILanguageService);
+    error(message: string, params?: any, title?: string): void;
+    info(message: string, params?: any, title?: string): void;
+    success(message: string, params?: any, title?: string): void;
+    warning(message: string, params?: any, title?: string): void;
+    private translateMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleToasterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConsoleToasterService>;
+}

package/ngx-utils/services/translated-url.serializer.d.ts

@@ -1,19 +1,19 @@
-import { DefaultUrlSerializer, UrlSegment, UrlSegmentGroup, UrlTree } from "@angular/router";
-import { ILanguageService } from "../common-types";
-import * as i0 from "@angular/core";
-export interface IUrlDictionary {
-    [key: string]: string;
-}
-export declare class TranslatedUrlSerializer extends DefaultUrlSerializer {
-    readonly language: ILanguageService;
-    protected cache: {
-        [lang: string]: IUrlDictionary;
-    };
-    constructor(language: ILanguageService);
-    serialize(tree: UrlTree): string;
-    parse(url: string): UrlTree;
-    getDictionary(serialize: boolean): IUrlDictionary;
-    modifyTreeRecursive(segmentGroup: UrlSegmentGroup, cb: (segment: UrlSegment) => void): UrlSegmentGroup;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatedUrlSerializer, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TranslatedUrlSerializer>;
-}
+import { DefaultUrlSerializer, UrlSegment, UrlSegmentGroup, UrlTree } from "@angular/router";
+import { ILanguageService } from "../common-types";
+import * as i0 from "@angular/core";
+export interface IUrlDictionary {
+    [key: string]: string;
+}
+export declare class TranslatedUrlSerializer extends DefaultUrlSerializer {
+    readonly language: ILanguageService;
+    protected cache: {
+        [lang: string]: IUrlDictionary;
+    };
+    constructor(language: ILanguageService);
+    serialize(tree: UrlTree): string;
+    parse(url: string): UrlTree;
+    getDictionary(serialize: boolean): IUrlDictionary;
+    modifyTreeRecursive(segmentGroup: UrlSegmentGroup, cb: (segment: UrlSegment) => void): UrlSegmentGroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatedUrlSerializer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslatedUrlSerializer>;
+}

package/ngx-utils/services/universal.service.d.ts

@@ -1,28 +1,28 @@
-import { DeviceDetectorService, DeviceInfo } from "ngx-device-detector";
-import * as i0 from "@angular/core";
-/**
- * Use this service to determine which is the current environment
- */
-export declare class UniversalService {
-    readonly platformId: string;
-    readonly dds: DeviceDetectorService;
-    get isBrowser(): boolean;
-    get isServer(): boolean;
-    get deviceInfo(): DeviceInfo;
-    get browserName(): string;
-    get browserVersion(): string;
-    get isExplorer(): boolean;
-    get isEdge(): boolean;
-    get isChrome(): boolean;
-    get isFirefox(): boolean;
-    get isSafari(): boolean;
-    get isTablet(): boolean;
-    get isMobile(): boolean;
-    get isDesktop(): boolean;
-    get isCrawler(): boolean;
-    private readonly crawler;
-    constructor(platformId: string, dds: DeviceDetectorService);
-    protected checkBrowser(name: string): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UniversalService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<UniversalService>;
-}
+import { DeviceDetectorService, DeviceInfo } from "ngx-device-detector";
+import * as i0 from "@angular/core";
+/**
+ * Use this service to determine which is the current environment
+ */
+export declare class UniversalService {
+    readonly platformId: string;
+    readonly dds: DeviceDetectorService;
+    get isBrowser(): boolean;
+    get isServer(): boolean;
+    get deviceInfo(): DeviceInfo;
+    get browserName(): string;
+    get browserVersion(): string;
+    get isExplorer(): boolean;
+    get isEdge(): boolean;
+    get isChrome(): boolean;
+    get isFirefox(): boolean;
+    get isSafari(): boolean;
+    get isTablet(): boolean;
+    get isMobile(): boolean;
+    get isDesktop(): boolean;
+    get isCrawler(): boolean;
+    private readonly crawler;
+    constructor(platformId: string, dds: DeviceDetectorService);
+    protected checkBrowser(name: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UniversalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UniversalService>;
+}