@progress/kendo-angular-inputs 13.2.1-develop.11 → 13.2.1-develop.13

package/esm2020/maskedtextbox/masking.service.mjs

@@ -0,0 +1,191 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { greedy, sequence } from './parsing/combinators';
+import { literal, mask as maskParser, rawLiteral, rawMask, token, unliteral, unmask } from './parsing/parsers';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class MaskingService {
+    constructor() {
+        this.rules = {};
+        this.prompt = "_";
+        this.mask = "";
+        this.promptPlaceholder = " ";
+        this.includeLiterals = false;
+        this.maskTokens = [];
+        this.unmaskTokens = [];
+        this.rawTokens = [];
+        this.validationTokens = [];
+    }
+    update({ mask = '', prompt = '', promptPlaceholder = ' ', rules = {}, includeLiterals = false }) {
+        this.mask = mask;
+        this.prompt = prompt;
+        this.promptPlaceholder = promptPlaceholder;
+        this.rules = rules;
+        this.includeLiterals = includeLiterals;
+        this.tokenize();
+    }
+    validationValue(maskedValue = '') {
+        let value = maskedValue;
+        sequence(this.validationTokens)
+            .run(maskedValue)
+            .fold(unmasked => {
+            value = unmasked.join('');
+        });
+        return value;
+    }
+    rawValue(maskedValue = '') {
+        let value = maskedValue;
+        if (!this.rawTokens.length) {
+            return value;
+        }
+        sequence(this.rawTokens)
+            .run(maskedValue)
+            .fold(unmasked => {
+            value = unmasked.join('');
+        });
+        return value;
+    }
+    /**
+     * @hidden
+     */
+    maskRaw(rawValue = '') {
+        let value = rawValue;
+        if (!this.maskTokens.length) {
+            return value;
+        }
+        sequence(this.maskTokens)
+            .run(rawValue)
+            .fold(masked => {
+            value = masked.join('');
+        });
+        return value;
+    }
+    maskInput(input, control, splitPoint) {
+        if (input.length < control.length) {
+            return this.maskRemoved(input, control, splitPoint);
+        }
+        return this.maskInserted(input, control, splitPoint);
+    }
+    maskInRange(pasted, oldValue, start, end) {
+        let value = '';
+        const selection = end;
+        const beforeChange = oldValue.split('').slice(0, start);
+        const afterChange = oldValue.split('').slice(end);
+        sequence(this.maskTokens.slice(start, end))
+            .run(pasted)
+            .fold(masked => {
+            value = beforeChange
+                .concat(masked)
+                .concat(afterChange)
+                .join('');
+        });
+        return {
+            selection,
+            value
+        };
+    }
+    maskRemoved(input, control, splitPoint) {
+        let value = '';
+        let selection = splitPoint;
+        const unchanged = input.split('').slice(splitPoint);
+        const changed = input.split('').slice(0, splitPoint).join('');
+        const take = this.maskTokens.length - (input.length - splitPoint);
+        sequence(this.maskTokens.slice(0, take))
+            .run(changed, control)
+            .fold(masked => {
+            selection = this.adjustPosition(masked, selection);
+            value = masked.concat(unchanged).join('');
+        });
+        return {
+            selection,
+            value
+        };
+    }
+    adjustPosition(input, selection) {
+        const caretChar = input[selection];
+        const isLiteral = this.maskTokens[selection].isLiteral(caretChar);
+        if (!isLiteral && caretChar !== this.prompt) {
+            return selection + 1;
+        }
+        return selection;
+    }
+    maskInserted(input, control, splitPoint) {
+        let value = '';
+        let selection = splitPoint;
+        const changed = input.slice(0, splitPoint);
+        sequence(this.unmaskTokens)
+            .run(changed, control)
+            .chain(unmasked => {
+            selection = unmasked.join('').length;
+            const unchanged = control.slice(selection);
+            return sequence(this.maskTokens)
+                .run(unmasked.join('') + unchanged, control);
+        })
+            .fold(masked => {
+            value = masked.join('');
+        });
+        return {
+            selection,
+            value
+        };
+    }
+    get maskTokenCreator() {
+        const { prompt, promptPlaceholder } = this;
+        return {
+            literal: rule => literal(rule),
+            mask: rule => maskParser({ prompt, promptPlaceholder })(rule)
+        };
+    }
+    get unmaskTokenCreator() {
+        return {
+            literal: rule => unliteral(rule),
+            mask: rule => unmask(this.prompt)(rule)
+        };
+    }
+    get rawTokenCreator() {
+        const { prompt, promptPlaceholder, includeLiterals } = this;
+        return {
+            literal: _ => rawLiteral(includeLiterals),
+            mask: _ => rawMask({ prompt, promptPlaceholder })
+        };
+    }
+    get validationTokenCreator() {
+        const { prompt } = this;
+        return {
+            literal: _ => rawLiteral(false),
+            mask: _ => rawMask({ prompt, promptPlaceholder: '' })
+        };
+    }
+    tokenize() {
+        greedy(token(this.rules, this.maskTokenCreator))
+            .run(this.mask)
+            .fold((tokens, _) => {
+            this.maskTokens = tokens;
+        });
+        greedy(token(this.rules, this.unmaskTokenCreator))
+            .run(this.mask)
+            .fold((tokens, _) => {
+            this.unmaskTokens = tokens;
+        });
+        greedy(token(this.rules, this.rawTokenCreator))
+            .run(this.mask)
+            .fold((tokens, _) => {
+            this.rawTokens = tokens;
+        });
+        greedy(token(this.rules, this.validationTokenCreator))
+            .run(this.mask)
+            .fold((tokens, _) => {
+            this.validationTokens = tokens;
+        });
+    }
+}
+MaskingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MaskingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskingService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskingService, decorators: [{
+            type: Injectable
+        }] });

package/esm2020/maskedtextbox/parsing/combinators.mjs

@@ -0,0 +1,28 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Parser } from './parsers';
+import { Result } from './result';
+/**
+ * @hidden
+ */
+const always = value => new Parser(stream => new Result(value, stream));
+/**
+ * @hidden
+ */
+const append = (p1, p2) => p1.chain(vs => p2.map(v => vs.concat([v])));
+/**
+ * @hidden
+ */
+export const sequence = list => list.reduce((acc, parser) => append(acc, parser), always([]));
+/**
+ * @hidden
+ */
+export const greedy = parser => new Parser(stream => {
+    let result = new Result([], stream);
+    while (!stream.eof()) {
+        result = result.concat(parser.run(stream));
+    }
+    return result;
+});

package/esm2020/maskedtextbox/parsing/parsers.mjs

@@ -0,0 +1,147 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Result, ResultType } from './result';
+import { Stream } from './stream';
+const toArray = (value) => (value || '').split('');
+const ESCAPE_CHARACTER = '\\';
+/**
+ * @hidden
+ */
+export class Parser {
+    constructor(parse) {
+        this.parse = parse;
+    }
+    run(input, control = '') {
+        if (input instanceof Stream) {
+            return this.parse(input);
+        }
+        else {
+            return this.parse(new Stream(toArray(input), toArray(control)));
+        }
+    }
+    //map :: Functor f => f a ~> (a -> b) -> f b
+    map(f) {
+        return new Parser(stream => this.parse(stream).map(f));
+    }
+    //chain :: Chain m => m a ~> (a -> m b) -> m b
+    chain(f) {
+        return new Parser(stream => this.parse(stream).chain((v, s) => f(v).run(s)));
+    }
+    isLiteral(c) {
+        return this.run(c).type === ResultType.Literal;
+    }
+}
+/**
+ * @hidden
+ */
+export const mask = ({ prompt, promptPlaceholder }) => rule => new Parser(stream => {
+    while (!stream.eof()) {
+        const { char, control } = stream.peek();
+        if (char === control && control === prompt) {
+            stream.eat();
+            return new Result(prompt, stream, ResultType.Mask);
+        }
+        if (rule.test(char)) {
+            stream.eat();
+            return new Result(char, stream, ResultType.Mask);
+        }
+        if (char === promptPlaceholder) {
+            stream.eat();
+            return new Result(prompt, stream, ResultType.Mask);
+        }
+        stream.eat_input();
+    }
+    stream.eat();
+    return new Result(prompt, stream, ResultType.Mask);
+});
+/**
+ * @hidden
+ */
+export const literal = _token => new Parser(stream => {
+    //    let {char, control} = stream.peek();
+    const char = stream.peek().char;
+    if (char === _token) {
+        stream.eat();
+        return new Result(_token, stream, ResultType.Literal);
+    }
+    //    if (control === _token) {
+    //        while (!stream.eof() && char !== _token) {
+    //            stream.eat_input();
+    //            char = stream.peek().char;
+    //        }
+    //    }
+    //
+    //    if (control !== undefined) {
+    //        stream.eat();
+    //    }
+    return new Result(_token, stream, ResultType.Literal);
+});
+/**
+ * @hidden
+ */
+export const unmask = prompt => rule => new Parser(stream => {
+    while (!stream.eof()) {
+        const { char, control } = stream.peek();
+        if (char === prompt && control === prompt) {
+            stream.eat();
+            return new Result(char, stream);
+        }
+        if (rule.test(char)) {
+            stream.eat();
+            return new Result(char, stream);
+        }
+        stream.eat_input();
+    }
+    stream.eat();
+    return new Result('', stream);
+});
+/**
+ * @hidden
+ */
+export const unliteral = _token => new Parser(stream => {
+    if (stream.eof()) {
+        return new Result('', stream);
+    }
+    const { char } = stream.peek();
+    if (char === _token) {
+        stream.eat();
+    }
+    return new Result(_token, stream);
+});
+/**
+ * @hidden
+ */
+export const token = (rules, creator) => new Parser(stream => {
+    let { char } = stream.next();
+    const rule = rules[char];
+    if (char === ESCAPE_CHARACTER) {
+        char = stream.next().char;
+        return new Result(creator.literal(char), stream);
+    }
+    if (!rule) {
+        return new Result(creator.literal(char), stream);
+    }
+    return new Result(creator.mask(rule), stream);
+});
+/**
+ * @hidden
+ */
+export const rawMask = ({ prompt, promptPlaceholder }) => new Parser(stream => {
+    const { char } = stream.next();
+    if (char === prompt) {
+        return new Result(promptPlaceholder, stream);
+    }
+    return new Result(char, stream);
+});
+/**
+ * @hidden
+ */
+export const rawLiteral = includeLiterals => new Parser(stream => {
+    const { char } = stream.next();
+    if (includeLiterals) {
+        return new Result(char, stream);
+    }
+    return new Result('', stream);
+});

package/esm2020/maskedtextbox/parsing/result.mjs

@@ -0,0 +1,41 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export var ResultType;
+(function (ResultType) {
+    ResultType[ResultType["Literal"] = 0] = "Literal";
+    ResultType[ResultType["Mask"] = 1] = "Mask";
+    // eslint-disable-next-line id-denylist
+    ResultType[ResultType["Undefined"] = 2] = "Undefined";
+})(ResultType || (ResultType = {}));
+/**
+ * @hidden
+ */
+export class Result {
+    constructor(value, rest, type = ResultType.Undefined) {
+        this.value = value;
+        this.rest = rest;
+        this.type = type;
+    }
+    //map :: Functor f => f a ~> (a -> b) -> f b
+    map(fn) {
+        return new Result(fn(this.value), this.rest);
+    }
+    //chain :: Chain m => m a ~> (a -> m b) -> m b
+    chain(fn) {
+        return fn(this.value, this.rest);
+    }
+    fold(s, _ /*we don't need it*/) {
+        return s(this.value, this.rest);
+    }
+    concat(r) {
+        return this.map((vs, _) => r.chain((v, __) => vs.concat([v])));
+    }
+    toString() {
+        return `Result({ value: '${this.value}', rest: ${this.rest} })`;
+    }
+}

package/esm2020/maskedtextbox/parsing/stream.mjs

@@ -0,0 +1,41 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export class Stream {
+    constructor(input = [], control = []) {
+        this.input = input;
+        this.control = control;
+        this.inputCursor = 0;
+        this.controlCursor = 0;
+    }
+    eof() {
+        return this.inputCursor >= this.input.length;
+    }
+    // Get the first value from the input.
+    next() {
+        return {
+            char: this.input[this.inputCursor++],
+            control: this.control[this.controlCursor++]
+        };
+    }
+    peek() {
+        return {
+            char: this.input[this.inputCursor],
+            control: this.control[this.controlCursor]
+        };
+    }
+    eat_input() {
+        this.inputCursor++;
+    }
+    eat_control() {
+        this.controlCursor++;
+    }
+    eat() {
+        this.inputCursor++;
+        this.controlCursor++;
+    }
+}

package/esm2020/maskedtextbox.module.mjs

@@ -0,0 +1,53 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NgModule } from '@angular/core';
+import { MaskedTextBoxComponent } from './maskedtextbox/maskedtextbox.component';
+import { CommonModule } from '@angular/common';
+import { EventsModule } from '@progress/kendo-angular-common';
+import * as i0 from "@angular/core";
+/**
+ * Represents the [NgModule](link:site.data.urls.angular['ngmoduleapi'])
+ * definition for the MaskedTextBox component.
+ *
+ * @example
+ *
+ * ```ts-no-run
+ * // Import the MaskedTextBox module
+ * import { MaskedTextBoxModule } from '@progress/kendo-angular-inputs';
+ *
+ * // The browser platform with a compiler
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ *
+ * import { NgModule } from '@angular/core';
+ *
+ * // Import the app component
+ * import { AppComponent } from './app.component';
+ *
+ * // Define the app module
+ * _@NgModule({
+ *     declarations: [AppComponent], // declare app component
+ *     imports:      [BrowserModule, MaskedTextBoxModule], // import MaskedTextBox module
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * // Compile and launch the module
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+export class MaskedTextBoxModule {
+}
+MaskedTextBoxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskedTextBoxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MaskedTextBoxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskedTextBoxModule, declarations: [MaskedTextBoxComponent], imports: [CommonModule, EventsModule], exports: [MaskedTextBoxComponent] });
+MaskedTextBoxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskedTextBoxModule, imports: [[CommonModule, EventsModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MaskedTextBoxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MaskedTextBoxComponent],
+                    exports: [MaskedTextBoxComponent],
+                    imports: [CommonModule, EventsModule]
+                }]
+        }] });

package/esm2020/numerictextbox/arrow-direction.mjs

@@ -0,0 +1,13 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export var ArrowDirection;
+(function (ArrowDirection) {
+    ArrowDirection[ArrowDirection["Down"] = -1] = "Down";
+    ArrowDirection[ArrowDirection["None"] = 0] = "None";
+    ArrowDirection[ArrowDirection["Up"] = 1] = "Up";
+})(ArrowDirection || (ArrowDirection = {}));

package/esm2020/numerictextbox/constants.mjs

@@ -0,0 +1,28 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export const MIN_DOC_LINK = 'http://www.telerik.com/kendo-angular-ui/components/inputs/api/NumericTextBoxComponent/#toc-min';
+/**
+ * @hidden
+ */
+export const MAX_DOC_LINK = 'http://www.telerik.com/kendo-angular-ui/components/inputs/api/NumericTextBoxComponent/#toc-max';
+/**
+ * @hidden
+ */
+export const POINT = ".";
+/**
+ * @hidden
+ */
+export const INITIAL_SPIN_DELAY = 500;
+/**
+ * @hidden
+ */
+export const SPIN_DELAY = 50;
+/**
+ * @hidden
+ */
+export const EXPONENT_REGEX = /[eE][\-+]?([0-9]+)/;

package/esm2020/numerictextbox/localization/custom-messages.component.mjs

@@ -0,0 +1,41 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { NumericTextBoxMessages } from './messages';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Custom component messages override default component messages.
+ */
+export class NumericTextBoxCustomMessagesComponent extends NumericTextBoxMessages {
+    constructor(service) {
+        super();
+        this.service = service;
+    }
+    get override() {
+        return true;
+    }
+}
+NumericTextBoxCustomMessagesComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: NumericTextBoxCustomMessagesComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+NumericTextBoxCustomMessagesComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: NumericTextBoxCustomMessagesComponent, selector: "kendo-numerictextbox-messages", providers: [
+        {
+            provide: NumericTextBoxMessages,
+            useExisting: forwardRef(() => NumericTextBoxCustomMessagesComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: NumericTextBoxCustomMessagesComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: NumericTextBoxMessages,
+                            useExisting: forwardRef(() => NumericTextBoxCustomMessagesComponent)
+                        }
+                    ],
+                    selector: 'kendo-numerictextbox-messages',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2020/numerictextbox/localization/localized-numerictextbox-messages.directive.mjs

@@ -0,0 +1,37 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, forwardRef } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { NumericTextBoxMessages } from './messages';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * @hidden
+ */
+export class LocalizedNumericTextBoxMessagesDirective extends NumericTextBoxMessages {
+    constructor(service) {
+        super();
+        this.service = service;
+    }
+}
+LocalizedNumericTextBoxMessagesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: LocalizedNumericTextBoxMessagesDirective, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Directive });
+LocalizedNumericTextBoxMessagesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.12", type: LocalizedNumericTextBoxMessagesDirective, selector: "[kendoNumericTextBoxLocalizedMessages]", providers: [
+        {
+            provide: NumericTextBoxMessages,
+            useExisting: forwardRef(() => LocalizedNumericTextBoxMessagesDirective)
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: LocalizedNumericTextBoxMessagesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    providers: [
+                        {
+                            provide: NumericTextBoxMessages,
+                            useExisting: forwardRef(() => LocalizedNumericTextBoxMessagesDirective)
+                        }
+                    ],
+                    selector: '[kendoNumericTextBoxLocalizedMessages]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2020/numerictextbox/localization/messages.mjs

@@ -0,0 +1,25 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2023 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Input } from '@angular/core';
+import { ComponentMessages } from '@progress/kendo-angular-l10n';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class NumericTextBoxMessages extends ComponentMessages {
+}
+NumericTextBoxMessages.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: NumericTextBoxMessages, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NumericTextBoxMessages.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.12", type: NumericTextBoxMessages, selector: "kendo-numerictextbox-messages-base", inputs: { decrement: "decrement", increment: "increment" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: NumericTextBoxMessages, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'kendo-numerictextbox-messages-base'
+                }]
+        }], propDecorators: { decrement: [{
+                type: Input
+            }], increment: [{
+                type: Input
+            }] } });