@acorex/core 19.15.0-next.9 → 20.0.1

package/storage/index.d.ts

@@ -1,4 +1,145 @@
-export * from './cookie-storage.service';
-export * from './local-storage.service';
-export * from './session-storage.service';
-export * from './storage.interface';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+interface AXStorage {
+    get<T = unknown>(key: string): T;
+    set<T = unknown>(key: string, value: T): void;
+    removeItem(key: string): any;
+    clear(): void;
+}
+type AXSameSite = 'Lax' | 'None' | 'Strict';
+interface AXCookieOptions {
+    expires?: number | Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: AXSameSite;
+}
+
+declare class AXCookieStorageService {
+    private readonly documentIsAccessible;
+    private document;
+    private platformId;
+    constructor();
+    /**
+     * Get cookie Regular Expression
+     *
+     * @param name Cookie name
+     * @returns property RegExp
+     *
+     */
+    private static getCookieRegExp;
+    /**
+     * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+     *
+     * @param encodedURIComponent A value representing an encoded URI component.
+     *
+     * @returns The unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+     *
+     */
+    private static safeDecodeURIComponent;
+    /**
+     * Return `true` if {@link Document} is accessible, otherwise return `false`
+     *
+     * @param name Cookie name
+     * @returns boolean - whether cookie with specified name exists
+     *
+     */
+    check(name: string): boolean;
+    /**
+     * Get cookies by name
+     *
+     * @param name Cookie name
+     * @returns property value
+     *
+     */
+    get(name: string): string;
+    /**
+     * Get all cookies in JSON format
+     *
+     * @returns all the cookies in json
+     *
+     */
+    getAll(): {
+        [key: string]: string;
+    };
+    /**
+     * Set cookie based on provided information
+     *
+     * @param name     Cookie name
+     * @param value    Cookie value
+     * @param expires  Number of days until the cookies expires or an actual `Date`
+     * @param path     Cookie path
+     * @param domain   Cookie domain
+     * @param secure   Secure flag
+     * @param sameSite OWASP samesite token `Lax`, `None`, or `Strict`. Defaults to `Lax`
+     *
+     */
+    set(name: string, value: string, expires?: AXCookieOptions['expires'], path?: AXCookieOptions['path'], domain?: AXCookieOptions['domain'], secure?: AXCookieOptions['secure'], sameSite?: AXSameSite): void;
+    /**
+     * Set cookie based on provided information
+     *
+     * Cookie's parameters:
+     * <pre>
+     * expires  Number of days until the cookies expires or an actual `Date`
+     * path     Cookie path
+     * domain   Cookie domain
+     * secure   Secure flag
+     * sameSite OWASP samesite token `Lax`, `None`, or `Strict`. Defaults to `Lax`
+     * </pre>
+     *
+     * @param name     Cookie name
+     * @param value    Cookie value
+     * @param options  Body with cookie's params
+     *
+     */
+    set(name: string, value: string, options?: AXCookieOptions): void;
+    /**
+     * Delete cookie by name
+     *
+     * @param name   Cookie name
+     * @param path   Cookie path
+     * @param domain Cookie domain
+     * @param secure Cookie secure flag
+     * @param sameSite Cookie sameSite flag - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
+     *
+     */
+    delete(name: string, path?: AXCookieOptions['path'], domain?: AXCookieOptions['domain'], secure?: AXCookieOptions['secure'], sameSite?: AXSameSite): void;
+    /**
+     * Delete all cookies
+     *
+     * @param path   Cookie path
+     * @param domain Cookie domain
+     * @param secure Is the Cookie secure
+     * @param sameSite Is the cookie same site
+     *
+     */
+    deleteAll(path?: AXCookieOptions['path'], domain?: AXCookieOptions['domain'], secure?: AXCookieOptions['secure'], sameSite?: AXSameSite): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCookieStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXCookieStorageService>;
+}
+
+declare const AX_LOCALSTORAGE_SECRET_KEY: InjectionToken<string>;
+declare class AXLocalStorageService implements AXStorage {
+    private secret_key;
+    get<T = unknown>(key: string): T;
+    set<T = unknown>(key: string, value: T): void;
+    clear(): void;
+    removeItem(key: string): void;
+    setWithEncryption<T = unknown>(key: string, value: T): void;
+    getWithEncription<T = unknown>(key: string): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLocalStorageService>;
+}
+
+declare class AXSessionStorageService implements AXStorage {
+    get<T = unknown>(key: string): T;
+    set<T = unknown>(key: string, value: T): void;
+    clear(): void;
+    removeItem(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXSessionStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXSessionStorageService>;
+}
+
+export { AXCookieStorageService, AXLocalStorageService, AXSessionStorageService, AX_LOCALSTORAGE_SECRET_KEY };
+export type { AXCookieOptions, AXSameSite, AXStorage };

package/translation/index.d.ts

@@ -1,8 +1,109 @@
-export * from './lib/translation-scope.resolver';
-export * from './lib/translation.config';
-export * from './lib/translation.loader';
-export * from './lib/translation.module';
-export * from './lib/translation.service';
-export * from './lib/translation.types';
-export * from './lib/translator.directive';
-export * from './lib/translator.pipe';
+import { ResolveFn } from '@angular/router';
+import * as i0 from '@angular/core';
+import { InjectionToken, PipeTransform, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare const loadTranslationScope: ResolveFn<unknown>;
+
+type AXTranslateHashMap<T = unknown> = Record<string, T>;
+type AXTranslateLang = string;
+type AXTranslateScope = string;
+type AXTranslateParams<T = unknown> = Record<string, T>;
+type AXTranslation = Record<string, string>;
+interface AXTranslateOptions {
+    lang?: AXTranslateLang;
+    scope?: AXTranslateScope;
+    params?: AXTranslateParams;
+}
+interface AXParsedToken {
+    key: string;
+    scope?: AXTranslateScope;
+    lang?: AXTranslateLang;
+    fullMatch: string;
+}
+
+interface AXTranslationConfig {
+    defaults: {
+        lang: AXTranslateLang;
+        scope: AXTranslateScope;
+    };
+    preload?: {
+        langs: AXTranslateLang[];
+        scopes: AXTranslateScope[];
+    };
+    fallbacks?: {
+        langs?: Record<AXTranslateLang, AXTranslateLang[]>;
+        scopes?: Record<AXTranslateScope, AXTranslateScope[]>;
+    };
+    available?: {
+        langs?: AXTranslateLang[];
+        scopes?: AXTranslateScope[];
+    };
+    resolver?: {
+        scopeKey: string;
+    };
+}
+declare const AX_TRANSLATION_CONFIG: InjectionToken<AXTranslationConfig>;
+declare const AXTranslationDefaultConfig: AXTranslationConfig;
+type AXPartialTranslationConfig = Partial<AXTranslationConfig>;
+declare function translationConfig(config?: AXPartialTranslationConfig): AXTranslationConfig;
+
+interface AXTranslationLoaderOptions {
+    lang: AXTranslateLang;
+    scope?: AXTranslateScope;
+}
+interface AXTranslationLoader {
+    load(options: AXTranslationLoaderOptions): Observable<AXTranslation>;
+}
+declare class AXTranslationLoaderDefault implements AXTranslationLoader {
+    load(options: AXTranslationLoaderOptions): Observable<AXTranslation>;
+}
+declare const AX_TRANSLATION_LOADER: InjectionToken<AXTranslationLoader>;
+
+declare class AXTranslatorPipe implements PipeTransform {
+    private service;
+    transform(key: string, options?: AXTranslateOptions): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXTranslatorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AXTranslatorPipe, "translate", true>;
+}
+
+declare class AXTranslatorDirective implements OnInit {
+    private templateRef;
+    private vc;
+    private translationService;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXTranslatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXTranslatorDirective, "[translate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXTranslationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXTranslationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXTranslationModule, never, [typeof AXTranslatorPipe, typeof AXTranslatorDirective], [typeof AXTranslatorPipe, typeof AXTranslatorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXTranslationModule>;
+}
+
+declare function translateSync(key: string, options?: AXTranslateOptions): string;
+declare class AXTranslationService {
+    private localeService;
+    private config;
+    private loader;
+    private parser;
+    private resolver;
+    private activeLang;
+    readonly langChanges$: Observable<string>;
+    constructor();
+    setActiveLang(lang: AXTranslateLang): void;
+    getActiveLang(): AXTranslateLang;
+    getDefaultLang(): AXTranslateLang;
+    translate$(text: string, options?: AXTranslateOptions): Observable<string>;
+    translateAsync(text: string, options?: AXTranslateOptions): Promise<string>;
+    translateSync(text: string, options?: AXTranslateOptions & {
+        waitForLoad?: boolean;
+        timeoutMs?: number;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXTranslationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXTranslationService>;
+}
+
+export { AXTranslationDefaultConfig, AXTranslationLoaderDefault, AXTranslationModule, AXTranslationService, AXTranslatorDirective, AXTranslatorPipe, AX_TRANSLATION_CONFIG, AX_TRANSLATION_LOADER, loadTranslationScope, translateSync, translationConfig };
+export type { AXParsedToken, AXPartialTranslationConfig, AXTranslateHashMap, AXTranslateLang, AXTranslateOptions, AXTranslateParams, AXTranslateScope, AXTranslation, AXTranslationConfig, AXTranslationLoader, AXTranslationLoaderOptions };

package/utils/index.d.ts

@@ -1,6 +1,118 @@
-export * from './lib/color.utils';
-export * from './lib/drawing.utils';
-export * from './lib/execution.utils';
-export * from './lib/html-utils';
-export * from './lib/lifecycle-helpers.utils';
-export * from './lib/string.utils';
+import tinycolor, { ColorInput } from 'tinycolor2';
+import { Instance } from 'tinygradient-es';
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+
+type AXColorMode = 'rgba' | 'hex' | 'hsla' | 'hsva' | null;
+
+type AXColorFormat = ColorInput;
+declare class AXColorUtil {
+    static to(color: AXColorFormat, mode: AXColorMode): AXColorFormat;
+    static toString(color: AXColorFormat, mode?: AXColorMode): string;
+    static isValid(color: AXColorFormat): boolean;
+    static mix(baseColor: AXColorFormat, hex: AXColorFormat, percentage: number): string;
+    static multiply(color1: AXColorFormat, color2: AXColorFormat): string;
+    static contrastToWhite(color: AXColorFormat): number;
+    static lighten(hex: AXColorFormat, percentage?: number): tinycolor.Instance;
+    static darken(hex: AXColorFormat, percentage?: number): tinycolor.Instance;
+    static brighten(hex: AXColorFormat, percentage?: number): tinycolor.Instance;
+    static saturate(hex: AXColorFormat, percentage?: number): tinycolor.Instance;
+    static desaturate(hex: AXColorFormat): number;
+    static equal(color1: AXColorFormat, color2: AXColorFormat): boolean;
+    static gradient(values: unknown[] | {
+        color: unknown;
+        pos: number;
+    }[]): Instance;
+    static getLuminance(hex: AXColorFormat): number;
+    static xyToRgb(vX: any, vY: any): string;
+    static colorStringToHex(color: any): any;
+    static getRandomColor(): string;
+}
+
+interface AXPoint {
+    x: number;
+    y: number;
+}
+interface AXBoundingClientRect {
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+    bottom?: number;
+    right?: number;
+}
+declare class AXDrawingUtil {
+    static collision(a: HTMLElement, b: HTMLElement): boolean;
+    static isInElementBound(pos: AXPoint, element: HTMLElement): boolean;
+    static isInRecPoint(pos: AXPoint, rec: AXBoundingClientRect | any): boolean;
+    static convertRemToPixels(rem: number): number;
+}
+
+/**
+ * Blocks until a condition returns a value or the timeout is reached.
+ * Useful for simulating sync behavior with cached async results.
+ */
+declare function waitFor<T>(peekFn: () => T | null | undefined, loadFn: () => void, timeoutMs?: number): T | null;
+/**
+ * Delays for a specific amount of time.
+ */
+declare function delay(ms: number): Promise<void>;
+/**
+ * Retries an async function until it succeeds or a max attempt count is reached.
+ */
+declare function retryUntil<T>(fn: () => Promise<T>, attempts?: number, delayMs?: number): Promise<T>;
+/**
+ * Continuously polls a condition until it returns true or a timeout is reached.
+ */
+declare function pollUntil(condition: () => boolean, intervalMs?: number, timeoutMs?: number): Promise<boolean>;
+/**
+ * Throttles an async function to ensure only one instance runs at a time.
+ */
+declare function throttleAsync<T extends (...args: any[]) => Promise<any>>(fn: T): T;
+/**
+ * Polls a condition with cancel support via AbortSignal.
+ */
+declare function pollUntilAbortable(condition: () => boolean, intervalMs?: number, timeoutMs?: number, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Debounces an async function to run only after no calls are made within the wait window.
+ */
+declare function debounceAsync<T extends (...args: any[]) => Promise<any>>(fn: T, waitMs: number): T;
+/**
+ * Runs a list of fallback functions until one resolves without throwing.
+ */
+declare function fallbackChain<T>(tasks: Array<() => Promise<T>>): Promise<T>;
+
+declare class AXHtmlUtil {
+    static focusElement(element: HTMLElement): HTMLElement;
+    static blurElement(element: HTMLElement): HTMLElement;
+    static hasFocus(element: HTMLElement): boolean;
+    static isRtl(element?: HTMLElement): boolean;
+    static hasDark(element: HTMLElement): boolean;
+    /**
+     * Helper function to check if an element is scrollable
+     */
+    static isScrollable(element: HTMLElement): boolean;
+    /**
+     * Utility function to find scrollable parent elements
+     */
+    static getScrollableParents(element: HTMLElement): HTMLElement[];
+}
+
+declare function AXAutoUnsubscriber(): (constructor: any) => void;
+declare class AXUnsubscriber implements OnDestroy {
+    private readonly _destroy$;
+    readonly takeUntilDestroy: <T>(origin: Observable<T> | Subject<T>) => Observable<T> | Subject<T>;
+    unsubscribe(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXUnsubscriber, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXUnsubscriber>;
+}
+
+declare function getWordBoundsAtPosition(str: string, position: number): {
+    start: number;
+    end: number;
+};
+
+export { AXAutoUnsubscriber, AXColorUtil, AXDrawingUtil, AXHtmlUtil, AXUnsubscriber, debounceAsync, delay, fallbackChain, getWordBoundsAtPosition, pollUntil, pollUntilAbortable, retryUntil, throttleAsync, waitFor };
+export type { AXBoundingClientRect, AXColorFormat, AXColorMode, AXPoint };

package/validation/index.d.ts

@@ -1,14 +1,249 @@
-export * from './lib/rules/callback-rule';
-export * from './lib/rules/regex-rule';
-export * from './lib/rules/required-rule';
-export * from './lib/rules/length-rule';
-export * from './lib/rules/maxlength-rule';
-export * from './lib/rules/minlength-rule';
-export * from './lib/rules/between-rule';
-export * from './lib/rules/equal-rule';
-export * from './lib/rules/greater-than';
-export * from './lib/rules/less-than-rule';
-export * from './lib/validation.config';
-export * from './lib/validation.module';
-export * from './lib/validation.service';
-export * from './lib/validation.types';
+import * as i0 from '@angular/core';
+import { InjectionToken, ModuleWithProviders } from '@angular/core';
+
+interface AXValidationRuleOptions {
+    message?: string;
+    [key: string]: unknown;
+}
+interface AXValidationRuleOptionsMap {
+}
+declare abstract class AXValidationRule {
+    abstract get name(): string;
+    abstract validate(value: unknown, options?: AXValidationRuleOptions): Promise<AXValidationRuleResult>;
+}
+interface AXValidationRuleResult {
+    rule: string;
+    value?: unknown;
+    message?: string | null;
+    result: boolean;
+    [key: string]: unknown;
+}
+interface AXValidationSummary {
+    result: boolean;
+    rules: AXValidationRuleResult[];
+}
+
+type AXCallbackValidationRuleResult = Promise<{
+    result: boolean;
+    message?: string;
+}> | {
+    result: boolean;
+    message?: string;
+} | boolean;
+type AXCallbackValidation<T> = (value: T, options?: AXCallbackValidationRuleOptions<T>) => AXCallbackValidationRuleResult;
+interface AXCallbackValidationRuleOptions<T> extends AXValidationRuleOptions {
+    validate: AXCallbackValidation<T>;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        callback: AXCallbackValidationRuleOptions<unknown>;
+    }
+}
+declare class AXCallbackValidationRule<T> implements AXValidationRule {
+    get name(): string;
+    validate(value: T, options: AXCallbackValidationRuleOptions<T>): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCallbackValidationRule<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXCallbackValidationRule<any>>;
+}
+
+interface AXRegexValidationRuleOptions extends AXValidationRuleOptions {
+    pattern: string | RegExp;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        regex: AXRegexValidationRuleOptions;
+    }
+}
+declare class AXRegexValidationRule implements AXValidationRule {
+    private traslationService;
+    get name(): string;
+    validate(value: string, options: AXRegexValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXRegexValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXRegexValidationRule>;
+}
+
+interface AXRequiredValidationRuleOptions extends AXValidationRuleOptions {
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        required: AXRequiredValidationRuleOptions;
+    }
+}
+declare class AXRequiredValidationRule implements AXValidationRule {
+    private traslationService;
+    get name(): string;
+    validate(value?: unknown, options?: AXRequiredValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXRequiredValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXRequiredValidationRule>;
+}
+
+interface AXLengthValidationRuleOptions extends AXValidationRuleOptions {
+    min: number;
+    max: number;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        length: AXLengthValidationRuleOptions;
+    }
+}
+declare class AXLengthValidationRule implements AXValidationRule {
+    get name(): string;
+    validate(value: string, options: AXLengthValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLengthValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLengthValidationRule>;
+}
+
+interface AXMaxLengthValidationRuleOptions extends AXValidationRuleOptions {
+    value: number;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        maxLength: AXMaxLengthValidationRuleOptions;
+    }
+}
+declare class AXMaxLengthValidationRule implements AXValidationRule {
+    get name(): string;
+    validate(value: string, options: AXMaxLengthValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMaxLengthValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMaxLengthValidationRule>;
+}
+
+interface AXMinLengthValidationRuleOptions extends AXValidationRuleOptions {
+    value: number;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        minLength: AXMinLengthValidationRuleOptions;
+    }
+}
+declare class AXMinLengthValidationRule implements AXValidationRule {
+    get name(): string;
+    validate(value: string, options: AXMinLengthValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXMinLengthValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXMinLengthValidationRule>;
+}
+
+interface AXBetweenValidationRuleOptions<T = number | Date> extends AXValidationRuleOptions {
+    lowerValue: T;
+    upperValue: T;
+    inclusive?: boolean;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        between: AXBetweenValidationRuleOptions;
+    }
+}
+declare class AXBetweenValidationRule<T = number | Date> implements AXValidationRule {
+    get name(): string;
+    validate(value: T, options: AXBetweenValidationRuleOptions<T>): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXBetweenValidationRule<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXBetweenValidationRule<any>>;
+}
+
+interface AXEqualValidationRuleOptions extends AXValidationRuleOptions {
+    value: any;
+    not?: boolean;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        equal: AXEqualValidationRuleOptions;
+    }
+}
+declare class AXEqualValidationRule implements AXValidationRule {
+    get name(): string;
+    validate(value: any, options: AXEqualValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXEqualValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXEqualValidationRule>;
+}
+
+interface AXGreaterThanValidationRuleOptions extends AXValidationRuleOptions {
+    value: number;
+    inclusive?: boolean;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        greaterThan: AXGreaterThanValidationRuleOptions;
+    }
+}
+declare class AXGreaterThanValidationRule implements AXValidationRule {
+    get name(): string;
+    validate(value: number, options: AXGreaterThanValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXGreaterThanValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXGreaterThanValidationRule>;
+}
+
+interface AXLessThanValidationRuleOptions extends AXValidationRuleOptions {
+    value: number;
+    inclusive?: boolean;
+}
+declare module '../validation.types' {
+    interface AXValidationRuleOptionsMap {
+        lessThan: AXLessThanValidationRuleOptions;
+    }
+}
+declare class AXLessThanValidationRule implements AXValidationRule {
+    get name(): string;
+    validate(value: number, options: AXLessThanValidationRuleOptions): Promise<AXValidationRuleResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXLessThanValidationRule, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXLessThanValidationRule>;
+}
+
+type AXValidationConfigRules = {
+    [key: string]: {
+        rule: keyof AXValidationRuleOptionsMap;
+        options: AXValidationRuleOptions;
+    };
+};
+interface AXValidationConfig {
+    rules: AXValidationConfigRules;
+}
+declare const AX_VALIDATION_CONFIG: InjectionToken<AXValidationConfig>;
+declare const AXValidationDefaultConfig: AXValidationConfig;
+type AXPartialValidationConfig = Partial<AXValidationConfig>;
+declare function validationConfig(config?: AXPartialValidationConfig): AXValidationConfig;
+
+interface AXValidationModuleConfigs {
+    rules: (new () => AXValidationRule)[];
+}
+declare class AXValidationModule {
+    static forRoot(configs?: AXValidationModuleConfigs): ModuleWithProviders<AXValidationModule>;
+    static forChild(configs?: AXValidationModuleConfigs): ModuleWithProviders<AXValidationModule>;
+    /**
+     * @ignore
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXValidationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXValidationModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXValidationModule>;
+}
+
+declare class AXValidationRegistryService {
+    private plugins;
+    private configs;
+    get customRules(): AXValidationConfigRules;
+    private injector;
+    register(...plugins: (new () => AXValidationRule)[]): void;
+    get(ruleName: string): AXValidationRule | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXValidationRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXValidationRegistryService>;
+}
+declare class AXValidationService {
+    private translationService;
+    private pluginRegistry;
+    validate(ruleName: string, value: unknown, options?: AXValidationRuleOptions): Promise<AXValidationRuleResult>;
+    ruleFor(value: unknown): AXValidationRuleChain;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXValidationService>;
+}
+declare class AXValidationRuleChain {
+    private validationService;
+    private initialValue;
+    private rules;
+    private validationSummary;
+    constructor(validationService: AXValidationService, initialValue: unknown);
+    addRule(name: string, options?: any): AXValidationRuleChain;
+    validate(): Promise<AXValidationSummary>;
+}
+
+export { AXBetweenValidationRule, AXCallbackValidationRule, AXEqualValidationRule, AXGreaterThanValidationRule, AXLengthValidationRule, AXLessThanValidationRule, AXMaxLengthValidationRule, AXMinLengthValidationRule, AXRegexValidationRule, AXRequiredValidationRule, AXValidationDefaultConfig, AXValidationModule, AXValidationRegistryService, AXValidationRule, AXValidationService, AX_VALIDATION_CONFIG, validationConfig };
+export type { AXBetweenValidationRuleOptions, AXCallbackValidation, AXCallbackValidationRuleOptions, AXCallbackValidationRuleResult, AXEqualValidationRuleOptions, AXGreaterThanValidationRuleOptions, AXLengthValidationRuleOptions, AXLessThanValidationRuleOptions, AXMaxLengthValidationRuleOptions, AXMinLengthValidationRuleOptions, AXPartialValidationConfig, AXRegexValidationRuleOptions, AXRequiredValidationRuleOptions, AXValidationConfig, AXValidationConfigRules, AXValidationModuleConfigs, AXValidationRuleOptions, AXValidationRuleOptionsMap, AXValidationRuleResult, AXValidationSummary };

package/components/lib/component.service.d.ts

@@ -1,11 +0,0 @@
-import { ComponentRef, EmbeddedViewRef, TemplateRef } from '@angular/core';
-import { AXComponentType } from './component.types';
-import * as i0 from "@angular/core";
-export declare class AXComponentService {
-    private appRef;
-    private getRootViewContainerRef;
-    createFromComponent<T>(content: AXComponentType<T>): Promise<ComponentRef<T>>;
-    createFromTemplate<T>(content: TemplateRef<T>): Promise<EmbeddedViewRef<T>>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXComponentService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXComponentService>;
-}

package/components/lib/component.types.d.ts

@@ -1,9 +0,0 @@
-import { TemplateRef } from '@angular/core';
-export interface AXComponentType<T> {
-    new (...args: any[]): T;
-}
-export type AXComponentContent<T = any> = AXComponentType<T> | TemplateRef<T>;
-export type AXComponentInputs = Record<string, unknown>;
-export interface AXComponentOptions {
-    inputs?: AXComponentInputs;
-}