@acorex/core 19.15.0-next.9 → 20.0.1

package/file/index.d.ts

@@ -1,3 +1,42 @@
-export * from './lib/file-size-formatter';
-export * from './lib/file.module';
-export * from './lib/file.service';
+import * as i1 from '@acorex/core/format';
+import { AXFormatOptions, AXFormatter } from '@acorex/core/format';
+import * as i0 from '@angular/core';
+
+interface AXFileSizeFormatterOptions extends AXFormatOptions {
+    format: string;
+}
+declare module '@acorex/core/format' {
+    interface AXFormatOptionsMap {
+        filesize: AXFileSizeFormatterOptions;
+    }
+}
+declare class AXFileSizeFormatter implements AXFormatter {
+    get name(): string;
+    format(value: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFileSizeFormatter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXFileSizeFormatter>;
+}
+
+declare class AXFileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXFileModule, never, [typeof i1.AXFormatModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXFileModule>;
+}
+
+declare class AXFileService {
+    private document;
+    private platformID;
+    choose(options?: {
+        accept?: string;
+        multiple?: boolean;
+    }): Promise<File[]>;
+    blobToBase64: (blob: Blob) => Promise<string>;
+    getSize(file: File | Blob | string): number | false;
+    isBase64(base64: string): boolean;
+    getBase64Size(base64: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXFileService>;
+}
+
+export { AXFileModule, AXFileService, AXFileSizeFormatter };
+export type { AXFileSizeFormatterOptions };

package/format/index.d.ts

@@ -1,8 +1,122 @@
-export * from './lib/format.config';
-export * from './lib/format.directive';
-export * from './lib/format.module';
-export * from './lib/format.pipe';
-export * from './lib/format.service';
-export * from './lib/format.types';
-export * from './lib/formatters/number.formatter';
-export * from './lib/formatters/string.formatter';
+import * as i0 from '@angular/core';
+import { OnInit, PipeTransform, ModuleWithProviders } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+
+interface AXFormatOptions {
+}
+interface AXFormatOptionsMap {
+}
+
+declare abstract class AXFormatter {
+    abstract get name(): string;
+    abstract format(value: unknown, options?: AXFormatOptions | string): string;
+}
+
+declare class AXFormatterDirective implements OnInit {
+    private templateRef;
+    private viewContainer;
+    private formatService;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFormatterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXFormatterDirective, "[formatter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXFormatPipe implements PipeTransform {
+    private formatService;
+    private eventService;
+    private triggers;
+    transform(value: unknown, name: string, options?: AXFormatOptions | string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AXFormatPipe, "format", true>;
+}
+
+interface AXFormatModuleConfigs {
+    formatters: (new () => AXFormatter)[];
+}
+declare class AXFormatModule {
+    static forRoot(configs?: AXFormatModuleConfigs): ModuleWithProviders<AXFormatModule>;
+    static forChild(configs?: AXFormatModuleConfigs): ModuleWithProviders<AXFormatModule>;
+    /**
+     * @ignore
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFormatModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXFormatModule, never, [typeof AXFormatterDirective, typeof AXFormatPipe], [typeof AXFormatterDirective, typeof AXFormatPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXFormatModule>;
+}
+
+declare class AXFormatterRegistryService {
+    private plugins;
+    private injector;
+    register(...plugins: (new () => AXFormatter)[]): void;
+    get formatters(): AXFormatter[];
+    /**
+     * Resolves a formatter by its name.
+     * @param name The name of the formatter.
+     * @returns The formatter if found, otherwise throws an error.
+     */
+    get(name: string): AXFormatter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFormatterRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXFormatterRegistryService>;
+}
+declare class AXFormatService {
+    private pluginRegistry;
+    private renderSubject;
+    onRender: rxjs.Observable<void>;
+    render(): void;
+    format(value: unknown, formatter: string, options?: any): string;
+    format(value: unknown): AXFormatFluent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXFormatService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXFormatService>;
+}
+declare class AXFormatFluent {
+    private formatService;
+    private pluginRegistry;
+    private initialValue;
+    constructor(formatService: AXFormatService, pluginRegistry: AXFormatterRegistryService, initialValue: unknown);
+    /**
+     * Formats the value using the specified formatter and options.
+     * @param formatter The name of the formatter to use.
+     * @param options The options to pass to the formatter.
+     * @returns The formatted string.
+     */
+    to<K extends keyof AXFormatOptionsMap>(formatter: K, options?: AXFormatOptionsMap[K]): string;
+}
+
+interface AXNumberFormatterOptions extends AXFormatOptions {
+    decimalPlaces?: number;
+    thousandSeparator?: string;
+    decimalSeparator?: string;
+    zeroPadLength?: number;
+    locale?: string;
+}
+declare module '../format.types' {
+    interface AXFormatOptionsMap {
+        number: AXNumberFormatterOptions;
+    }
+}
+declare class AXNumberFormatter implements AXFormatter {
+    private separatorsCache;
+    get name(): string;
+    format(value: number, options: AXNumberFormatterOptions): string;
+    private getLocaleSeparators;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXNumberFormatter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXNumberFormatter>;
+}
+
+interface AXStringFormatterOptions extends AXFormatOptions {
+    [key: string]: any;
+}
+declare module '../format.types' {
+    interface AXFormatOptionsMap {
+        string: AXStringFormatterOptions;
+    }
+}
+declare class AXStringFormatter implements AXFormatter {
+    get name(): string;
+    format(value: unknown, options: AXStringFormatterOptions): string;
+}
+
+export { AXFormatModule, AXFormatPipe, AXFormatService, AXFormatter, AXFormatterDirective, AXFormatterRegistryService, AXNumberFormatter, AXStringFormatter };
+export type { AXFormatModuleConfigs, AXFormatOptions, AXFormatOptionsMap, AXNumberFormatterOptions, AXStringFormatterOptions };

package/icon/README.md

@@ -0,0 +1,3 @@
+# @acorex/core/components
+
+Secondary entry point of `@acorex/core`. It can be used by importing from `@acorex/core/components`.

package/icon/index.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+declare class AXIconResolverService {
+    private resolvers;
+    private cache;
+    resolve(icon: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXIconResolverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXIconResolverService>;
+}
+
+declare abstract class AXIconResolver {
+    abstract resolve(icon: string): Promise<string | null>;
+}
+declare const AXP_ICON_RESOLVER: InjectionToken<AXIconResolver | AXIconResolver[]>;
+declare class AXIconResolverDefault extends AXIconResolver {
+    resolve(icon: string): Promise<string | null>;
+}
+
+export { AXIconResolver, AXIconResolverDefault, AXIconResolverService, AXP_ICON_RESOLVER };

package/image/index.d.ts

@@ -1 +1,16 @@
-export * from './lib/image.service';
+import * as i0 from '@angular/core';
+
+declare class AXImageService {
+    private document;
+    private platformID;
+    resize(options: {
+        maxSize: number;
+        source: HTMLImageElement | File;
+        type?: 'image/png' | 'image/jpeg' | 'image/webp';
+        quality?: number;
+    }): Promise<Blob>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXImageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXImageService>;
+}
+
+export { AXImageService };

package/index.d.ts

@@ -1 +1,3 @@
-export declare const AX_CORE = "ACOREX_CORE";
+declare const AX_CORE = "ACOREX_CORE";
+
+export { AX_CORE };

package/locale/index.d.ts

@@ -1,8 +1,135 @@
-export * from './lib/formatters/currency.formatter';
-export * from './lib/locale-profile-provider.service';
-export * from './lib/locale.config';
-export * from './lib/locale.module';
-export * from './lib/locale.service';
-export * from './lib/locale.types';
-export * from './lib/profiles/en-US.profile';
-export * from './lib/profiles/fa-IR.profile';
+import * as i1 from '@acorex/core/format';
+import { AXFormatOptions } from '@acorex/core/format';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as rxjs from 'rxjs';
+
+interface AXCurrencyFormatterOptions extends AXFormatOptions {
+    locale?: string;
+    currency?: string;
+}
+declare module '@acorex/core/format' {
+    interface AXFormatOptionsMap {
+        currency: AXCurrencyFormatterOptions;
+    }
+}
+
+interface AXLocaleProfile {
+    localeInfo: {
+        code: string;
+        language: string;
+        region: string;
+        timezone: string;
+    };
+    calendar: {
+        system: 'gregorian' | 'solar-hijri' | string;
+        week: {
+            startsOn: number;
+            weekends: number[];
+        };
+        clock: {
+            format24Hour: boolean;
+        };
+    };
+    formats: {
+        date: FormatPattern;
+        time: FormatPattern;
+        datetime: FormatPattern;
+        numbers: {
+            decimalPattern: string;
+            currency: {
+                code: string;
+            };
+        };
+        contacts: {
+            phone: string;
+            postalCode: string;
+        };
+    };
+    units: {
+        temperature: 'celsius' | 'fahrenheit';
+        distance: 'kilometers' | 'miles';
+        weight: 'kilograms' | 'pounds';
+        volume: 'liters' | 'gallons';
+        speed: 'kmh' | 'mph';
+        area: 'square-meters' | 'square-feet';
+        custom?: Record<string, string>;
+    };
+    i18nMeta: {
+        fallbackLocales?: string[];
+        supportedLanguages?: string[];
+        rtl: boolean;
+    };
+}
+interface FormatPattern {
+    short: string;
+    medium: string;
+    long: string;
+    full: string;
+}
+declare enum AXLocaleEvents {
+    AXLocaleChanged = "AX_LOCALE_CHANGED",
+    AXLocaleLoaded = "AX_LOCALE_LOADED",
+    AXCalendarChanged = "AX_CALENDAR_CHANGED",
+    AXLanguageChanged = "AX_LANGUAGE_CHANGED",
+    AXLanguageLoaded = "AX_LANGUAGE_LOADED"
+}
+
+type AXLocaleProfileProviderResult = Record<string, () => Promise<AXLocaleProfile> | AXLocaleProfile>;
+interface AXLocaleProfileProvider {
+    provide(): Promise<AXLocaleProfileProviderResult>;
+}
+declare const AX_LOCALE_PROFILE_PROVIDERS: InjectionToken<AXLocaleProfileProvider[]>;
+declare class AXLocaleProfileProviderDefault implements AXLocaleProfileProvider {
+    provide(): Promise<AXLocaleProfileProviderResult>;
+}
+declare class AXLocaleProfileProviderService {
+    private providers;
+    private registry;
+    private resolvedCache;
+    private isInitialized;
+    private init;
+    getList(): Promise<AXLocaleProfile[]>;
+    getByLocale(localeCode: string): Promise<AXLocaleProfile | undefined>;
+    reload(): Promise<void>;
+    has(localeCode: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLocaleProfileProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLocaleProfileProviderService>;
+}
+
+interface AXLocaleConfig {
+    default: string;
+}
+declare const AX_LOCALE_CONFIG: InjectionToken<AXLocaleConfig>;
+
+declare class AXLocaleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLocaleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXLocaleModule, never, [typeof i1.AXFormatModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXLocaleModule>;
+}
+
+declare class AXLocaleService {
+    private provider;
+    private config;
+    private _activeProfile;
+    activeProfile: i0.Signal<AXLocaleProfile>;
+    profileChanged$: rxjs.Observable<AXLocaleProfile>;
+    private originalProfile;
+    setProfile(localeCode: string): Promise<void>;
+    /**
+     *
+     */
+    constructor();
+    apply(profile: Partial<AXLocaleProfile>): void;
+    apply(path: string, value: any): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLocaleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLocaleService>;
+}
+
+declare const AXUSLocaleProfile: AXLocaleProfile;
+
+declare const AXIRLocaleProfile: AXLocaleProfile;
+
+export { AXIRLocaleProfile, AXLocaleEvents, AXLocaleModule, AXLocaleProfileProviderDefault, AXLocaleProfileProviderService, AXLocaleService, AXUSLocaleProfile, AX_LOCALE_CONFIG, AX_LOCALE_PROFILE_PROVIDERS };
+export type { AXCurrencyFormatterOptions, AXLocaleConfig, AXLocaleProfile, AXLocaleProfileProvider, AXLocaleProfileProviderResult };

package/memoize/index.d.ts

@@ -1 +1,3 @@
-export * from './lib/memoize.decorator';
+declare function Memoize(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+export { Memoize };

package/network/index.d.ts

@@ -1,4 +1,69 @@
-export * from './lib/download-task';
-export * from './lib/network.service';
-export * from './lib/network.types';
-export * from './lib/upload-task';
+import { HttpEvent, HttpClient, HttpRequest } from '@angular/common/http';
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as i0 from '@angular/core';
+
+declare enum AXUploadStatus {
+    Uploading = "Uploading...",
+    UploadComplete = "Upload complete",
+    StartingUpload = "Starting upload",
+    UploadFailed = "Upload failed",
+    UploadCanceled = "Upload Canceled"
+}
+type AXUploadResponse<T> = {
+    progress: number;
+    bytesTransferred: number;
+    totalBytes: number;
+    status: AXUploadStatus;
+    result?: T;
+    message?: string;
+};
+declare enum AXDownloadStatus {
+    Downloading = "Downloading...",
+    DownloadComplete = "Download complete",
+    StartingDownload = "Starting download",
+    DownloadFailed = "Download failed"
+}
+type AXDownloadResponse = {
+    progress: number;
+    bytesReceived: number;
+    totalBytes: number;
+    status: AXDownloadStatus;
+    data?: Blob;
+};
+
+declare class AXDownloadTask {
+    private observable;
+    private cancelSignal;
+    constructor(observable: Observable<HttpEvent<any>>);
+    get events(): Observable<AXDownloadResponse>;
+    private handleEvent;
+    cancel(): void;
+}
+
+declare class AXUploadTask<T> {
+    private http;
+    private request;
+    private totalFileSize;
+    private cancelSignal;
+    events: BehaviorSubject<AXUploadResponse<T>>;
+    constructor(http: HttpClient, request: HttpRequest<T>, totalFileSize: number);
+    private handleEvent;
+    cancel(): void;
+    start(): void;
+}
+
+declare class AXNetworkService {
+    private http;
+    private _status;
+    readonly status: i0.Signal<boolean>;
+    constructor();
+    upload<T>(url: string, formData: FormData): AXUploadTask<T>;
+    upload<T>(request: HttpRequest<any>): AXUploadTask<T>;
+    download(url: string): AXDownloadTask;
+    download(request: HttpRequest<Blob>): AXDownloadTask;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXNetworkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXNetworkService>;
+}
+
+export { AXDownloadStatus, AXDownloadTask, AXNetworkService, AXUploadStatus, AXUploadTask };
+export type { AXDownloadResponse, AXUploadResponse };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@acorex/core",
-  "version": "19.15.0-next.9",
+  "version": "20.0.1",
   "peerDependencies": {
-    "@angular/common": ">=19.0.0",
-    "@angular/core": ">=19.0.0",
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
     "lodash-es": ">=4.17.21",
     "memoizee": ">=0.4.15",
     "crypto-es": ">=2.1.0",
@@ -28,34 +28,38 @@
       "types": "./components/index.d.ts",
       "default": "./fesm2022/acorex-core-components.mjs"
     },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "default": "./fesm2022/acorex-core-config.mjs"
+    },
+    "./constants": {
+      "types": "./constants/index.d.ts",
+      "default": "./fesm2022/acorex-core-constants.mjs"
+    },
     "./date-time": {
       "types": "./date-time/index.d.ts",
       "default": "./fesm2022/acorex-core-date-time.mjs"
     },
-    "./file": {
-      "types": "./file/index.d.ts",
-      "default": "./fesm2022/acorex-core-file.mjs"
-    },
     "./events": {
       "types": "./events/index.d.ts",
       "default": "./fesm2022/acorex-core-events.mjs"
     },
+    "./file": {
+      "types": "./file/index.d.ts",
+      "default": "./fesm2022/acorex-core-file.mjs"
+    },
     "./format": {
       "types": "./format/index.d.ts",
       "default": "./fesm2022/acorex-core-format.mjs"
     },
-    "./constants": {
-      "types": "./constants/index.d.ts",
-      "default": "./fesm2022/acorex-core-constants.mjs"
+    "./icon": {
+      "types": "./icon/index.d.ts",
+      "default": "./fesm2022/acorex-core-icon.mjs"
     },
     "./image": {
       "types": "./image/index.d.ts",
       "default": "./fesm2022/acorex-core-image.mjs"
     },
-    "./config": {
-      "types": "./config/index.d.ts",
-      "default": "./fesm2022/acorex-core-config.mjs"
-    },
     "./locale": {
       "types": "./locale/index.d.ts",
       "default": "./fesm2022/acorex-core-locale.mjs"
@@ -68,14 +72,14 @@
       "types": "./network/index.d.ts",
       "default": "./fesm2022/acorex-core-network.mjs"
     },
-    "./platform": {
-      "types": "./platform/index.d.ts",
-      "default": "./fesm2022/acorex-core-platform.mjs"
-    },
     "./pipes": {
       "types": "./pipes/index.d.ts",
       "default": "./fesm2022/acorex-core-pipes.mjs"
     },
+    "./platform": {
+      "types": "./platform/index.d.ts",
+      "default": "./fesm2022/acorex-core-platform.mjs"
+    },
     "./storage": {
       "types": "./storage/index.d.ts",
       "default": "./fesm2022/acorex-core-storage.mjs"

package/pipes/index.d.ts

@@ -1 +1,12 @@
-export * from './lib/safe/safe.pipe';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml, SafeStyle, SafeScript, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+
+declare class AXSafePipe implements PipeTransform {
+    protected sanitizer: DomSanitizer;
+    transform(value: any, type: string): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXSafePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AXSafePipe, "safe", true>;
+}
+
+export { AXSafePipe };

package/platform/index.d.ts

@@ -1 +1,82 @@
-export * from './lib/platform.service';
+import * as i0 from '@angular/core';
+import { Subject, BehaviorSubject } from 'rxjs';
+
+type AXThemeMode = 'light' | 'dark' | 'system' | 'system-dark' | 'system-light';
+type AXPlatforms = 'Android' | 'Desktop' | 'iOS' | 'Mobile';
+type AXBrowsers = 'Chrome' | 'Safari' | 'Edge' | 'Firefox' | 'Opera' | 'MSIE';
+type AXTechnologies = 'PWA' | 'Hybrid' | 'Electron';
+type AXScreenSizes = 'SM' | 'MD' | 'LG' | 'XL' | '2XL' | '3XL' | '4XL' | '5XL';
+declare const isChrome: (win: Window) => boolean;
+declare const isFirefox: (win: Window) => boolean;
+declare const isEdge: (win: Window) => boolean;
+declare const isSafari: (win: Window) => boolean;
+declare const isOpera: (win: Window) => boolean;
+declare const isMSIE: (win: Window) => boolean;
+declare const isMobileWeb: (win: Window) => boolean;
+declare const isIpad: (win: Window) => boolean;
+declare const isIphone: (win: Window) => boolean;
+declare const isIOS: (win: Window) => boolean;
+declare const isAndroid: (win: Window) => boolean;
+declare const isAndroidTablet: (win: Window) => boolean;
+declare const isPhablet: (win: Window) => boolean;
+declare const isTablet: (win: Window) => boolean;
+declare const isMobile: (win: Window) => boolean;
+declare const isTouch: (win: Window) => boolean;
+declare const isDesktop: (win: Window) => boolean;
+declare const isHybrid: (win: Window) => boolean;
+declare const isCordova: (win: any) => boolean;
+declare const isCapacitorNative: (win: any) => boolean;
+declare const isElectron: (win: Window) => boolean;
+declare const isPWA: (win: Window) => boolean;
+declare const testUserAgent: (win: Window, expr: RegExp) => boolean;
+declare const isBrowser: Function;
+declare const isServer: Function;
+declare const matchMedia: (win: Window, query: string) => boolean;
+declare const isSMScreen: (win: Window) => boolean;
+declare const isMDScreen: (win: Window) => boolean;
+declare const isLGScreen: (win: Window) => boolean;
+declare const isXLScreen: (win: Window) => boolean;
+declare const is2XLScreen: (win: Window) => boolean;
+declare const is3XLScreen: (win: Window) => boolean;
+declare const is4XLScreen: (win: Window) => boolean;
+declare const PLATFORMS_MAP: any;
+declare class AXPlatformEvent<T extends Event = Event> {
+    nativeEvent: T;
+    source: AXPlatform;
+    data?: any;
+}
+declare class AXPlatform {
+    #private;
+    resize: Subject<AXPlatformEvent>;
+    directionChange: Subject<AXPlatformEvent>;
+    click: Subject<AXPlatformEvent>;
+    scroll: Subject<AXPlatformEvent>;
+    themeMode$: BehaviorSubject<AXThemeMode>;
+    themeMode: i0.WritableSignal<AXThemeMode>;
+    private document;
+    private platformID;
+    isDark(): boolean;
+    isRtl(): boolean;
+    isLandscape(): boolean;
+    isPortrate(): boolean;
+    is(name: AXPlatforms | AXBrowsers | AXTechnologies | AXScreenSizes): boolean;
+    get screenSize(): AXScreenSizes;
+    switchLightMode(): string;
+    switchDarkMode(): string;
+    switchSystemMode(): void;
+    autoDetectThemeMode(): "light" | "dark" | "system";
+    setThemeMode(mode: AXThemeMode): void;
+    private setFullHeightRatio;
+    private autoSystemModeDetection;
+    constructor();
+    private detectDarkMode;
+    private detectOnResize;
+    private detectClickEvent;
+    private detectScrollEvent;
+    private detectDocumentDirectionChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPlatform, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPlatform>;
+}
+
+export { AXPlatform, AXPlatformEvent, PLATFORMS_MAP, is2XLScreen, is3XLScreen, is4XLScreen, isAndroid, isAndroidTablet, isBrowser, isCapacitorNative, isChrome, isCordova, isDesktop, isEdge, isElectron, isFirefox, isHybrid, isIOS, isIpad, isIphone, isLGScreen, isMDScreen, isMSIE, isMobile, isMobileWeb, isOpera, isPWA, isPhablet, isSMScreen, isSafari, isServer, isTablet, isTouch, isXLScreen, matchMedia, testUserAgent };
+export type { AXBrowsers, AXPlatforms, AXScreenSizes, AXTechnologies, AXThemeMode };