ngx-mask

import * as _angular_core from '@angular/core'; import { InjectionToken, EventEmitter, EnvironmentProviders, Provider, ElementRef, OnChanges, SimpleChanges, PipeTransform } from '@angular/core'; import * as ngx_mask from 'ngx-mask'; import { ControlValueAccessor, Validator, FormControl, ValidationErrors } from '@angular/forms'; import { FormValueControl } from '@angular/forms/signals'; type InputTransformFn = (value: unknown) => string | number; type OutputTransformFn = (value: string | number | undefined | null) => unknown; /** Single decimal marker character accepted when `decimalMarker` is given as an array. */ type DecimalMarkerChar = '.' | ','; type NgxMaskConfig = { suffix: string; prefix: string; thousandSeparator: string; decimalMarker: DecimalMarkerChar | [DecimalMarkerChar, DecimalMarkerChar]; clearIfNotMatch: boolean; showMaskTyped: boolean; placeHolderCharacter: string; shownMaskExpression: string; specialCharacters: string[] | readonly string[]; dropSpecialCharacters: boolean | string[] | readonly string[]; hiddenInput: boolean; validation: boolean; instantPrefix: boolean; separatorLimit: string; apm: boolean; allowNegativeNumbers: boolean; leadZeroDateTime: boolean; leadZero: boolean; /** * Opt-in "banking" typing mode for separator masks with a fixed precision * (`separator.N`, N > 0): typed digits fill the value from the decimal end, * ATM/calculator style (5 -> 0.05 -> 0.57 -> 5.73); backspace shifts digits * back to the right. Pasted and model-written values keep the regular * separator formatting. Config-only option (provideNgxMask / pipe config) — * it has no directive input. */ typeFromDecimals: boolean; triggerOnMaskChange: boolean; keepCharacterPositions: boolean; inputTransformFn: InputTransformFn; outputTransformFn: OutputTransformFn; maskFilled: EventEmitter<void>; /** * User-defined named mask aliases resolved at the DI-config level (static per injector). * When the `mask` input (or pipe mask argument) exactly matches an alias key, the aliased * expression is substituted before any other mask processing (including `||` multi-masks). * Alias keys must not shadow built-in tokens (IP, CPF_CNPJ, CPF_CNPJ_ALPHA, ...) — such * aliases are ignored with a one-time console warning. */ maskAliases: Record<string, string>; /** * When set, this raw value is written through the regular mask pipeline on blur * whenever the control's unmasked value is empty (covers '', a bare prefix/suffix and * the showMaskTyped skeleton): the display shows the masked default and the model * receives the usual output (dropSpecialCharacters/outputTransformFn applied). The * write keeps the control's pristine state. `null` (default) keeps current behavior. */ defaultValueOnBlur: string | null; patterns: Record<string, { pattern: RegExp; optional?: boolean; symbol?: string; }>; }; type NgxMaskOptions = Partial<NgxMaskConfig>; declare const NGX_MASK_CONFIG: InjectionToken<NgxMaskConfig>; declare const NEW_CONFIG: InjectionToken<NgxMaskConfig>; declare const INITIAL_CONFIG: InjectionToken<NgxMaskConfig>; declare const initialConfig: NgxMaskConfig; /** * Resolves a user-defined mask alias to its mask expression. Returns the input expression * unchanged when no alias matches or when the alias key shadows a built-in token (in which * case a console warning is emitted once per key and the built-in wins). */ declare function resolveMaskAlias(maskExpression: string | null | undefined, maskAliases: Record<string, string> | undefined): string; declare const timeMasks: string[]; declare const withoutValidation: string[]; declare function provideNgxMask(configValue?: NgxMaskOptions | (() => NgxMaskOptions)): Provider[]; declare function provideEnvironmentNgxMask(configValue?: NgxMaskOptions | (() => NgxMaskOptions)): EnvironmentProviders; declare class NgxMaskApplierService { protected _config: NgxMaskConfig; dropSpecialCharacters: NgxMaskConfig['dropSpecialCharacters']; hiddenInput: NgxMaskConfig['hiddenInput']; clearIfNotMatch: NgxMaskConfig['clearIfNotMatch']; specialCharacters: NgxMaskConfig['specialCharacters']; patterns: NgxMaskConfig['patterns']; prefix: NgxMaskConfig['prefix']; suffix: NgxMaskConfig['suffix']; thousandSeparator: NgxMaskConfig['thousandSeparator']; decimalMarker: NgxMaskConfig['decimalMarker']; customPattern: NgxMaskConfig['patterns']; showMaskTyped: NgxMaskConfig['showMaskTyped']; placeHolderCharacter: NgxMaskConfig['placeHolderCharacter']; validation: NgxMaskConfig['validation']; separatorLimit: NgxMaskConfig['separatorLimit']; allowNegativeNumbers: NgxMaskConfig['allowNegativeNumbers']; leadZeroDateTime: NgxMaskConfig['leadZeroDateTime']; leadZero: NgxMaskConfig['leadZero']; typeFromDecimals: NgxMaskConfig['typeFromDecimals']; apm: NgxMaskConfig['apm']; inputTransformFn: NgxMaskConfig['inputTransformFn'] | null; outputTransformFn: NgxMaskConfig['outputTransformFn'] | null; keepCharacterPositions: NgxMaskConfig['keepCharacterPositions']; instantPrefix: NgxMaskConfig['instantPrefix']; triggerOnMaskChange: NgxMaskConfig['triggerOnMaskChange']; protected _shift: Set<number>; plusOnePosition: boolean; maskExpression: string; actualValue: string; showKeepCharacterExp: string; shownMaskExpression: NgxMaskConfig['shownMaskExpression']; deletedSpecialCharacter: boolean; /** * Whether we are currently in writeValue function, in this case when applying the mask we don't want to trigger onChange function, * since writeValue should be a one way only process of writing the DOM value based on the Angular model value. */ writingValue: boolean; ipError?: boolean; cpfCnpjError?: boolean; applyMask(inputValue: string | object | boolean | null | undefined, maskExpression: string, position?: number, justPasted?: boolean, backspaced?: boolean, cb?: (...args: any[]) => any): string; _findDropSpecialChar(inputSymbol: string): undefined | string; _findSpecialChar(inputSymbol: string): undefined | string; _checkSymbolMask(inputSymbol: string, maskSymbol: string): boolean; protected _formatWithSeparators: (str: string, thousandSeparatorChar: string, decimalChars: string | string[], precision: number) => string; /** * Formats a value for the `typeFromDecimals` mode: every digit of the raw value is * read as one integer that is then split `precision` digits from the right * (ATM/calculator style). Non-digit characters are ignored, so plain typing, * mid-string edits and backspace all reduce to "digits shifted through the * decimal marker". */ protected _formatFromDecimals(value: string, precision: number, decimalMarker: string): string; /** Inserts `separator` between every 3-digit group of an integer-digit string. */ private _applyThousandGrouping; protected percentage: (str: string) => boolean; getPrecision: (maskExpression: string) => number; private checkAndRemoveSuffix; protected checkInputPrecision: (inputValue: string, precision: number, decimalMarker: NgxMaskConfig["decimalMarker"]) => string; protected _stripToDecimal(str: string): string; protected _charToRegExpExpression(char: string): string; protected _shiftStep(cursor: number): void; protected _compareOrIncludes<T>(value: T, comparedValue: T | T[], excludedValue: T): boolean; protected _validIP(valuesIP: string[]): boolean; protected _splitPercentZero(value: string): string; protected _findFirstNonZeroAndDecimalIndex(inputString: string, decimalMarker: '.' | ','): { decimalMarkerIndex: number | null; nonZeroIndex: number | null; }; static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxMaskApplierService, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxMaskApplierService>; } declare class NgxMaskService extends NgxMaskApplierService { isNumberValue: boolean; maskIsShown: string; selStart: number | null; selEnd: number | null; maskChanged: boolean; maskExpressionArray: string[]; previousValue: string; currentValue: string; isInitialized: boolean; /** * Set by the directive's keepCharacterPositions handling for the current edit: * true — the directive fully resolved the resulting display value into actualValue, * so applyMask must short-circuit and render actualValue as-is; * false — the edit must flow through regular masking (no short-circuit); * null — the directive was not involved in this applyMask call (legacy behavior). * Consumed and reset by applyMask. This lets keepCharacterPositions work without * showMaskTyped (#1545, #1543). */ keepCharacterPositionsHandled: boolean | null; _isFocused: _angular_core.WritableSignal<boolean>; private _emitValue; private _start; private _end; onChange: (_: any) => void; readonly _elementRef: ElementRef<any> | null; private readonly document; protected _config: NgxMaskConfig; private readonly _renderer; /** * Applies the mask to the input value. * @param inputValue The input value to be masked. * @param maskExpression The mask expression to apply. * @param position The position in the input value. * @param justPasted Whether the value was just pasted. * @param backspaced Whether the value was backspaced. * @param cb Callback function. * @returns The masked value. */ applyMask(inputValue: string, maskExpression: string, position?: number, justPasted?: boolean, backspaced?: boolean, cb?: (...args: any[]) => any): string; private _numberSkipedSymbols; applyValueChanges(position: number, justPasted: boolean, backspaced: boolean, cb?: (...args: any[]) => any): void; hideInput(inputValue: string, maskExpression: string): string; getActualValue(res: string): string; shiftTypedSymbols(inputValue: string): string; /** * Convert number value to string * 3.1415 -> '3.1415' * 1e-7 -> '0.0000001' */ numberToString(value: number | string): string; /** * Locale-independent replacement for toLocaleString('fullwide', { useGrouping: false, * maximumFractionDigits: 20 }) (#1573): expands exponential notation ('7e-7', '1e+21') * to plain decimal form using '.' as decimal marker, regardless of the runtime locale. */ private _toPlainDecimalString; showMaskInInput(inputVal?: string): string; clearIfNotMatchFn(): void; set formElementProperty([name, value]: [string, string | boolean]); checkDropSpecialCharAmount(mask: string): number; removeMask(inputValue: string): string; private _checkForIp; private _checkForCpfCnpj; /** Collects the characters counted as "typed" for CPF/CNPJ progress tracking: digits only * for the numeric mask, alphanumerics for CPF_CNPJ_ALPHA. */ private _countCpfCnpjTypedChars; /** * Recursively determine the current active element by navigating the Shadow DOM until the Active Element is found. */ private _getActiveElement; /** * Propogates the input value back to the Angular model by triggering the onChange function. It won't do this if writingValue * is true. If that is true it means we are currently in the writeValue function, which is supposed to only update the actual * DOM element based on the Angular model value. It should be a one way process, i.e. writeValue should not be modifying the Angular * model value too. Therefore, we don't trigger onChange in this scenario. * @param inputValue the current form input value */ private formControlResult; private _toNumber; private _removeMask; private _removePrefix; private _removeSuffix; private _retrieveSeparatorValue; private _regExpForRemove; private _replaceDecimalMarkerToDot; _checkSymbols(result: string): string | number | undefined | null; private _checkPatternForSpace; private _retrieveSeparatorPrecision; _checkPrecision(separatorExpression: string, separatorValue: string): number | string; /** * True when the plain decimal string carries more significant digits than an IEEE-754 * double can represent exactly (15 is the guaranteed round-trip digit count), meaning a * Number() round-trip would corrupt it (#1567). */ private _exceedsDoublePrecision; /** * Exact string-based equivalent of Number.prototype.toFixed (round half away from zero) * for plain decimal strings beyond double precision (#1567). */ private _stringToFixed; _repeatPatternSymbols(maskExp: string): string; /** * Decimal marker of the value being normalized in writeValue/pipe flows. * * #1573: this used to return the RUNTIME default locale's decimal marker * ((1.1).toLocaleString().substring(1, 2)), which made mask behavior depend on the * OS/browser regional format: under a comma-decimal locale (e.g. Edge + Austrian * regional settings) a preformatted value like '10,000' (thousandSeparator ',') * had its ',' replaced by the configured '.' decimalMarker, corrupting the value * 1000x. JS number stringification (String(n)) always uses '.', and string values * are expected to use the configured markers — the runtime locale is never the * right source, so this is always '.'. */ currentLocaleDecimalMarker(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxMaskService, never>; static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxMaskService>; } declare class NgxMaskDirective implements ControlValueAccessor, OnChanges, Validator, FormValueControl<string> { mask: _angular_core.InputSignal<string | null | undefined>; specialCharacters: _angular_core.InputSignal<string[] | readonly string[]>; patterns: _angular_core.InputSignal<Record<string, { pattern: RegExp; optional?: boolean; symbol?: string; }>>; prefix: _angular_core.InputSignal<string>; suffix: _angular_core.InputSignal<string>; thousandSeparator: _angular_core.InputSignal<string>; decimalMarker: _angular_core.InputSignal<ngx_mask.DecimalMarkerChar | [ngx_mask.DecimalMarkerChar, ngx_mask.DecimalMarkerChar]>; dropSpecialCharacters: _angular_core.InputSignal<boolean | string[] | readonly string[] | null>; hiddenInput: _angular_core.InputSignal<boolean | null>; showMaskTyped: _angular_core.InputSignal<boolean | null>; placeHolderCharacter: _angular_core.InputSignal<string | null>; shownMaskExpression: _angular_core.InputSignal<string | null>; clearIfNotMatch: _angular_core.InputSignal<boolean | null>; validation: _angular_core.InputSignal<boolean | null>; separatorLimit: _angular_core.InputSignal<string | null>; typeFromDecimals: _angular_core.InputSignal<boolean | null>; allowNegativeNumbers: _angular_core.InputSignal<boolean | null>; leadZeroDateTime: _angular_core.InputSignal<boolean | null>; leadZero: _angular_core.InputSignal<boolean | null>; triggerOnMaskChange: _angular_core.InputSignal<boolean | null>; apm: _angular_core.InputSignal<boolean | null>; inputTransformFn: _angular_core.InputSignal<ngx_mask.InputTransformFn | null>; outputTransformFn: _angular_core.InputSignal<ngx_mask.OutputTransformFn | null>; keepCharacterPositions: _angular_core.InputSignal<boolean | null>; instantPrefix: _angular_core.InputSignal<boolean | null>; defaultValueOnBlur: _angular_core.InputSignal<string | null>; value: _angular_core.ModelSignal<string>; disabled: _angular_core.InputSignalWithTransform<boolean, unknown>; touched: _angular_core.ModelSignal<boolean>; maskFilled: _angular_core.OutputEmitterRef<void>; private _maskValue; private _inputValue; private _position; private _code; private _maskExpressionArray; private _justPasted; private _isFocused; /** For IME composition event */ private _isComposing; /** * True once Angular has driven this directive through the `ControlValueAccessor` contract * (`registerOnChange`). NOTE: Signal Forms' `FormField` ALSO takes this path — it prefers a * host-provided `NG_VALUE_ACCESSOR` over the custom-control `value` model binding (see * `FormField.ɵngControlCreate`), so it calls `registerOnChange`/`writeValue` too and this * flag is `true` in both modes. That is fine: with the flag set, the `value`-model effect * below is a no-op and all rendering goes through `writeValue()`. The `value` model is only * driven directly (flag stays `false`) when the directive is used standalone with a * `[(value)]` binding and no forms integration. */ private _isCvaMode; /** Guards against the value effect echoing back a value we just propagated ourselves. */ private _skipNextValueEffect; /** * The exact stringified value last pushed through `onChange` (view → model). Signal Forms' * `FormField` echoes every model update back through `writeValue()` — including updates that * originated from the view. Re-masking that unmasked echo is at best a redundant re-render * and at worst destructive for masks whose unmasked form is ambiguous (e.g. IP: * '192168178' cannot reconstruct the typed dots of '192.168.1.78'). `writeValue()` consumes * this marker to skip exactly that echo. `null` = no pending propagation. */ private _lastPropagatedValue; /** * True once the first `ngOnChanges` pass has applied the mask configuration to the service. * Signal Forms' `FormField` syncs its field value through the template `ɵɵcontrol` update * instruction, which runs BEFORE the sibling directives' first `ngOnChanges` on the same * element — so the very first `writeValue()` would otherwise see an unconfigured service * (empty `maskExpression`, default `leadZero`/`thousandSeparator`/...) and render the raw * value. Until this flag is set, `writeValue()` stashes the incoming value and `ngOnChanges` * replays it once the configuration is in place. */ private _configApplied; private _pendingInitialValue; private _hasPendingInitialValue; /** * True once the `disabled` input has ever delivered `true`. The disabled effect's very * first run fires with the input's default `false` even when nothing binds `[disabled]`. * Because effects run after Angular Forms' `setUpControl` (which calls * `setDisabledState(true)` for initially-disabled controls) and both DOM writes are * queueMicrotask-deferred in FIFO order, forwarding that default `false` would land last * and re-enable an initially-disabled control (#1607, #1614). An initial `false` write is * never needed — inputs are enabled by default — so `false` is only forwarded after the * input has explicitly driven the state to `true` at least once. */ private _disabledEverSet; /** Ensures the multi-character placeHolderCharacter warning (#1347) is emitted only once. */ private _warnedAboutMultiCharPlaceholder; _maskService: NgxMaskService; private readonly document; protected _config: NgxMaskConfig; /** * Under zoneless change detection, writing to the underlying FormControl programmatically * (e.g. `setValue`/`patchValue` from outside a signal/effect context, or from a callback * zone.js used to auto-flush like `requestAnimationFrame`/`queueMicrotask`) does not itself * trigger a CD run. Bindings that read `form.pristine`/`form.dirty`/`form.value` on the host * template need an explicit `markForCheck()` once the directive finishes reacting to a * programmatic value write, otherwise the view stays stale until something else schedules CD. */ private readonly _changeDetectorRef; private readonly _elementRef; private readonly _renderer; private readonly _injector; private _ngControl; private _resolveNgControl; onChange: (_: any) => void; onTouch: () => void; constructor(); ngOnChanges(changes: SimpleChanges): void; validate({ value }: FormControl): ValidationErrors | null; onPaste(): void; onFocus(): void; onModelChange(value: unknown): void; onInput(e: Event): void; /** * Whether any pattern slot of the current mask expression can accept a letter. * IME composition is only meaningful for such masks; for purely numeric masks * (digit patterns, separator, date/time, IP, CPF_CNPJ) waiting for compositionend * only delays the model sync — and Samsung Keyboard may never fire it until blur * (#1293). Unknown/letterless probe failures fall back to `false` (process live). */ private _maskAcceptsLetterInput; onCompositionStart(): void; onCompositionEnd(e: Event): void; onBlur(e: Event): void; /** * Issue #1435 (defaultValueOnBlur): when configured — via the directive input or the * DI config — and the control's unmasked value is empty on blur (covers '', a bare * prefix/suffix and the showMaskTyped skeleton), writes the default through the * regular mask pipeline: applyMask renders the masked display and emits the usual * model output (dropSpecialCharacters/outputTransformFn applied) via formControlResult. * Returns the control's pre-write pristine state for the caller to restore once the * whole blur pass is done, or `null` when no default was applied. */ private _applyDefaultValueOnBlur; onClick(e: Event): void; onKeyDown(event: Event): void; /** * Restores the control's pristine/untouched state after a writeValue-driven emission. * * writeValue is a one-way model->view sync. When the mask normalizes the written value * (e.g. leadZero '10.2' -> '10.20'), the directive must still emit the corrected value so * the model adopts it — but that emission runs through Angular's view-change pipeline, which * calls markAsDirty()/markAsTouched(). A programmatic setValue/patchValue must leave the * control pristine, so we undo that side effect here when the control was pristine before * the write. `onlySelf: true` keeps parent group state untouched. */ private _restoreControlStateAfterWrite; /** It writes the value in the input */ writeValue(controlValue: unknown): Promise<void>; /** * Mirrors a writeValue-driven render into the DOM synchronously, in the same * change-detection pass (#1305). The service's `formElementProperty` setter defers all * writes via queueMicrotask (to keep FIFO ordering with config-driven re-renders and * dodge ExpressionChanged issues), but consumers that read `nativeElement.value` DURING * the CD pass — Angular Material's floating label (`MatInput.empty`), CDK autofill — * never see a value that only lands in a later microtask. The deferred write still runs * afterwards and re-applies the same final value, so ordering guarantees are preserved. * * Skipped while a mask reconfiguration is pending (`mask()` input changed but * `ngOnChanges` has not applied it yet — e.g. `mask.set(...)` + `setValue(...)` before * the next CD pass): the value just computed used the STALE mask config, and rendering * it synchronously would expose an intermediate state that the deferred pipeline is * about to supersede. Multi-masks (`||`) resolve `_maskValue` to one alternative and * therefore also fall back to the deferred-only path. */ private _writeElementValueSync; /** The `mask` input with a user-defined alias (config maskAliases) expanded, if any. */ private _resolvedMaskInput; registerOnChange(fn: typeof this.onChange): void; registerOnTouched(fn: typeof this.onTouch): void; /** * Pushes the current unmasked value into the `value` model input. In Signal Forms mode this * fires the `valueChange` output that Angular listens to; in CVA mode it is a harmless write * to a model nobody reads. We flag `_skipNextValueEffect` so the resulting model change does * not bounce back through the value effect and overwrite the raw `_inputValue`. */ private _propagateToValueModel; /** * Focus the input element. * Required by FormValueControl interface for Signal Forms. */ focus(): void; private _getActiveElement; checkSelectionOnDeletion(el: HTMLInputElement): void; /** It disables the input element */ setDisabledState(isDisabled: boolean): void; private _applyMask; /** * Renders `inputValue` through the mask, falling back to the raw value verbatim when the * mask cannot process ANY of it (#1615, e.g. a sentinel like 'ONGOING' written into a * digits-only control). Values that PARTIALLY match keep regular masking. * * Shared by writeValue() and _applyMask() (called from every ngOnChanges pass, including * ones triggered by an UNRELATED input like `disabled`) so the verbatim verdict for a * value written once via writeValue() is not lost on a later re-render that replays the * same raw `inputValue` outside of writeValue — which would otherwise re-run regular * masking, produce an empty result, and emit it through onChange, clobbering the model. * * Excludes an actual mask RECONFIGURATION (`maskChanged`): when the mask itself just * changed, a value that no longer matches must clear through the regular path (see * trigger-on-mask-change.spec.ts) — verbatim passthrough only covers re-renders of the * SAME mask. */ private _maskedOrVerbatim; private _validateTime; private _getActualInputLength; /** * For `||` multi-masks only (#1583): a value shorter than the currently selected * alternative is still valid when it is a pattern-valid prefix of that alternative * ending exactly at a special-character boundary (e.g. `0` for `0,N`) and it meets * the length requirement of at least one alternative (e.g. `1`). Values stopping * mid-pattern-block (e.g. `112A` for `000SS`) remain invalid. */ private _isCompleteAlternativeBoundary; /** * True when every character of the mask expression is either a pattern token or a * special character — i.e. the mask has no quantifiers (`*`, `?`), curly-bracket * repetitions or other constructs the position-aware matcher does not model. */ private _isPlainTokenMask; /** * Backtracking match of a value against a mask mixing optional and mandatory pattern * tokens (#1515, e.g. `999SSS`). Optional tokens may be left unfilled; special * characters may be absent from the value (dropSpecialCharacters). The value is valid * when it is fully consumed and every remaining mask token is optional or special. */ private _matchesMaskWithOptionalSkip; private _createValidationError; private _setMask; private _areAllCharactersInEachStringSame; static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxMaskDirective, never>; static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxMaskDirective, "input[mask], textarea[mask]", ["mask", "ngxMask"], { "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "specialCharacters": { "alias": "specialCharacters"; "required": false; "isSignal": true; }; "patterns": { "alias": "patterns"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "thousandSeparator": { "alias": "thousandSeparator"; "required": false; "isSignal": true; }; "decimalMarker": { "alias": "decimalMarker"; "required": false; "isSignal": true; }; "dropSpecialCharacters": { "alias": "dropSpecialCharacters"; "required": false; "isSignal": true; }; "hiddenInput": { "alias": "hiddenInput"; "required": false; "isSignal": true; }; "showMaskTyped": { "alias": "showMaskTyped"; "required": false; "isSignal": true; }; "placeHolderCharacter": { "alias": "placeHolderCharacter"; "required": false; "isSignal": true; }; "shownMaskExpression": { "alias": "shownMaskExpression"; "required": false; "isSignal": true; }; "clearIfNotMatch": { "alias": "clearIfNotMatch"; "required": false; "isSignal": true; }; "validation": { "alias": "validation"; "required": false; "isSignal": true; }; "separatorLimit": { "alias": "separatorLimit"; "required": false; "isSignal": true; }; "typeFromDecimals": { "alias": "typeFromDecimals"; "required": false; "isSignal": true; }; "allowNegativeNumbers": { "alias": "allowNegativeNumbers"; "required": false; "isSignal": true; }; "leadZeroDateTime": { "alias": "leadZeroDateTime"; "required": false; "isSignal": true; }; "leadZero": { "alias": "leadZero"; "required": false; "isSignal": true; }; "triggerOnMaskChange": { "alias": "triggerOnMaskChange"; "required": false; "isSignal": true; }; "apm": { "alias": "apm"; "required": false; "isSignal": true; }; "inputTransformFn": { "alias": "inputTransformFn"; "required": false; "isSignal": true; }; "outputTransformFn": { "alias": "outputTransformFn"; "required": false; "isSignal": true; }; "keepCharacterPositions": { "alias": "keepCharacterPositions"; "required": false; "isSignal": true; }; "instantPrefix": { "alias": "instantPrefix"; "required": false; "isSignal": true; }; "defaultValueOnBlur": { "alias": "defaultValueOnBlur"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "maskFilled": "maskFilled"; }, never, never, true, never>; } declare class NgxMaskPipe implements PipeTransform { private readonly defaultOptions; private readonly _maskService; private _maskExpressionArray; private mask; transform(value: string | number, mask: string, { patterns, maskAliases, ...config }?: Partial<NgxMaskConfig>): string; private _setMask; static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxMaskPipe, never>; static ɵpipe: _angular_core.ɵɵPipeDeclaration<NgxMaskPipe, "mask", true>; } export { INITIAL_CONFIG, NEW_CONFIG, NGX_MASK_CONFIG, NgxMaskDirective, NgxMaskPipe, NgxMaskService, initialConfig, provideEnvironmentNgxMask, provideNgxMask, resolveMaskAlias, timeMasks, withoutValidation }; export type { DecimalMarkerChar, InputTransformFn, NgxMaskConfig, NgxMaskOptions, OutputTransformFn };