import * as i0 from '@angular/core';
import { OnInit, PipeTransform, ModuleWithProviders, InjectionToken, Provider } from '@angular/core';
import { ValidationErrors } from '@angular/forms';
import * as i1 from '@angular/common';

type JsonMessage<T> = Record<string, T> | Record<string, Record<string, T>>;
type ErrorWhenType = 'dirty' | 'invalid' | 'pristine' | 'touched' | 'untouched';
type ErrorPriority = string;
interface ClassNames {
    control: string;
    message: string;
}
interface ErrorMessageConfig {
    validationsPrefix?: string;
    patternsPrefix?: string;
    errorMessages?: Record<string, string | Record<string, string>>;
    errorPriority?: ErrorPriority[];
}
/** The provider-resolved shape of {@link ErrorMessageConfig}: every field defaulted. */
interface ResolvedErrorMessageConfig {
    validationsPrefix: string;
    patternsPrefix: string;
    errorMessages: Record<string, string | Record<string, string>>;
    errorPriority: ErrorPriority[];
}

declare class NgxErrorMessageDirective implements OnInit {
    readonly fieldName: i0.InputSignal<string>;
    readonly classNames: i0.InputSignal<ClassNames>;
    readonly patternKey: i0.InputSignal<string | undefined>;
    readonly when: i0.InputSignal<ErrorWhenType | ErrorWhenType[]>;
    readonly errorPriority: i0.InputSignal<string[] | undefined>;
    private readonly ngControl;
    private readonly elementRef;
    private readonly renderer;
    private readonly container;
    private readonly errorMessageService;
    private readonly destroyRef;
    private readonly revision;
    private componentRef?;
    readonly hasError: i0.Signal<boolean>;
    readonly message: i0.Signal<string>;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxErrorMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxErrorMessageDirective, "[ngxErrorMessage]", ["ngxErrorMessage"], { "fieldName": { "alias": "ngxErrorMessage"; "required": false; "isSignal": true; }; "classNames": { "alias": "classNames"; "required": false; "isSignal": true; }; "patternKey": { "alias": "patternKey"; "required": false; "isSignal": true; }; "when": { "alias": "when"; "required": false; "isSignal": true; }; "errorPriority": { "alias": "errorPriority"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NgxErrorMessageService {
    private readonly config;
    private readonly translator;
    getErrorMessage(controlErrors: ValidationErrors, patternKey?: string, fieldName?: string, errorPriority?: ErrorPriority[]): string;
    private pickErrorKey;
    private patternMatchExpression;
    private getValueByRegexFromObject;
    private interpolateMessage;
    private getNestedMessage;
    private getMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxErrorMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgxErrorMessageService>;
}

/** For consumers rendering messages manually (e.g. via `exportAs`); the directive itself calls `NgxErrorMessageService` directly. */
declare class NgxErrorMessagePipe implements PipeTransform {
    private readonly errorMessageService;
    transform(value: ValidationErrors | null, patternKey?: string, fieldName?: string, errorPriority?: ErrorPriority[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxErrorMessagePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NgxErrorMessagePipe, "ngxErrorMessage", true>;
}

declare class NgxErrorMessageComponent {
    readonly message: i0.InputSignal<string>;
    readonly messageClass: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxErrorMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxErrorMessageComponent, "ngx-error-message", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; "messageClass": { "alias": "messageClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * @deprecated Use `provideNgxErrorMessage()` instead. Will be removed in a
 * future major version. Note: `NgxErrorMessageModule` alone doesn't wire up
 * `@ngx-translate/core` - add `withNgxTranslate()` (from the
 * `ngx-error-message/ngx-translate` secondary entry point) to your own
 * providers if you need it.
 */
declare class NgxErrorMessageModule {
    static forRoot(config?: ErrorMessageConfig): ModuleWithProviders<NgxErrorMessageModule>;
    static forChild(config?: ErrorMessageConfig): ModuleWithProviders<NgxErrorMessageModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxErrorMessageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxErrorMessageModule, never, [typeof i1.CommonModule, typeof NgxErrorMessageComponent, typeof NgxErrorMessageDirective, typeof NgxErrorMessagePipe], [typeof NgxErrorMessageDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxErrorMessageModule>;
}

declare const ERROR_MESSAGE_CONFIG: InjectionToken<ResolvedErrorMessageConfig>;

/**
 * Resolves a translation key to a message. The default implementation is a
 * zero-dependency no-op; `withNgxTranslate()` from the
 * `ngx-error-message/ngx-translate` secondary entry point overrides it with
 * an `@ngx-translate/core`-backed adapter.
 *
 * `translate()` is a plain synchronous method - implementations that read
 * signals while computing their result get reactivity for free, since
 * callers only ever invoke it from inside the directive's `computed()`.
 */
interface NgxErrorMessageTranslator {
    translate(key: string, params?: Record<string, string>): string;
}
declare const NGX_ERROR_MESSAGE_TRANSLATOR: InjectionToken<NgxErrorMessageTranslator>;

/**
 * Composable, like `provideHttpClient(withXhr(), ...)`:
 * `provideNgxErrorMessage(withErrorMessageConfig({...}), withNgxTranslate())`.
 */
declare function provideNgxErrorMessage(...features: Provider[][]): Provider[];
declare function withErrorMessageConfig(config: ErrorMessageConfig): Provider[];

declare const regEx: {
    phoneNumber: RegExp;
    websiteUrl: RegExp;
    numeric: RegExp;
    smallLetters: RegExp;
    capitalLetters: RegExp;
    alphabet: RegExp;
    alphaNumeric: RegExp;
    ip: RegExp;
};
declare const DEFAULT_ERROR_PRIORITY: string[];

export { DEFAULT_ERROR_PRIORITY, ERROR_MESSAGE_CONFIG, NGX_ERROR_MESSAGE_TRANSLATOR, NgxErrorMessageComponent, NgxErrorMessageDirective, NgxErrorMessageModule, NgxErrorMessagePipe, NgxErrorMessageService, provideNgxErrorMessage, regEx, withErrorMessageConfig };
export type { ClassNames, ErrorMessageConfig, ErrorPriority, ErrorWhenType, JsonMessage, NgxErrorMessageTranslator, ResolvedErrorMessageConfig };