@ardium-pl/ui 5.0.0-alpha.106

package/lib/inputs/hex-input/hex-input.defaults.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+import { _FormFieldComponentDefaults } from '../../_internal/form-field-component';
+import { ArdFormFieldFramePrefixSuffix } from '../../form-field-frame';
+import { Nullable } from '../../types/utility.types';
+import { CaseTransformerType } from '../input-types';
+import { FormElementAppearance, FormElementVariant } from './../../types/theming.types';
+export interface ArdHexInputDefaults extends _FormFieldComponentDefaults {
+    appearance: FormElementAppearance;
+    variant: FormElementVariant;
+    compact: boolean;
+    placeholder: string;
+    case: CaseTransformerType;
+    maxDigits: Nullable<number>;
+    hideHash: boolean;
+    clearable: boolean;
+    clearButtonTitle: string;
+    inputAttrs: Record<string, any>;
+    PrefixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+    SuffixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+}
+export declare const ARD_HEX_INPUT_DEFAULTS: InjectionToken<ArdHexInputDefaults>;
+export declare function provideHexInputDefaults(config: Partial<ArdHexInputDefaults>): Provider;

package/lib/inputs/hex-input/hex-input.directives.d.ts

@@ -0,0 +1,21 @@
+import { TemplateRef } from '@angular/core';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import * as i0 from "@angular/core";
+export declare class ArdHexInputPlaceholderTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdHexInputPlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdHexInputPlaceholderTemplateDirective, "ard-hex-input > ng-template[ard-placeholder-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdHexInputPrefixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdHexInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdHexInputPrefixTemplateDirective, "ard-hex-input ng-template[ard-prefix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdHexInputSuffixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdHexInputSuffixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdHexInputSuffixTemplateDirective, "ard-hex-input ng-template[ard-suffix-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/inputs/hex-input/hex-input.model.d.ts

@@ -0,0 +1,26 @@
+import { ElementRef, Signal } from '@angular/core';
+import { Nullable } from '../../types/utility.types';
+import { CaseTransformerType } from '../input-types';
+export interface HexInputModelHost {
+    readonly case: Signal<CaseTransformerType>;
+    readonly maxDigits: Signal<Nullable<number>>;
+    readonly textInputEl: Signal<ElementRef<HTMLInputElement> | undefined>;
+}
+export declare class HexInputModel {
+    protected readonly _hostComp: HexInputModelHost;
+    constructor(_hostComp: HexInputModelHost);
+    readonly value: import("@angular/core").WritableSignal<string | null>;
+    readonly stringValue: Signal<string>;
+    readonly hashSignValue: Signal<string>;
+    writeValue(v: any): boolean;
+    protected _writeValue(v: string | null): boolean;
+    clear(): void;
+    rewriteValueAfterHostUpdate(): void;
+    _updateInputElement(): void;
+    get caretPos(): number;
+    set caretPos(pos: number);
+    private _charactersRegexTransformer;
+    private _applyCharactersConstraint;
+    private _applyDigitsConstraint;
+    private _applyCaseTransformer;
+}

package/lib/inputs/hex-input/hex-input.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./hex-input.component";
+import * as i2 from "./hex-input.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "../../form-field-frame/form-field-frame.module";
+import * as i5 from "../../_internal/clear-button/clear-button.module";
+export declare class ArdiumHexInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumHexInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumHexInputModule, [typeof i1.ArdiumHexInputComponent, typeof i2.ArdHexInputPlaceholderTemplateDirective, typeof i2.ArdHexInputPrefixTemplateDirective, typeof i2.ArdHexInputSuffixTemplateDirective], [typeof i3.CommonModule, typeof i4.ArdiumFormFieldFrameModule, typeof i5._ClearButtonModule], [typeof i1.ArdiumHexInputComponent, typeof i2.ArdHexInputPlaceholderTemplateDirective, typeof i2.ArdHexInputPrefixTemplateDirective, typeof i2.ArdHexInputSuffixTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumHexInputModule>;
+}

package/lib/inputs/hex-input/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hex-input.component';
+export * from './hex-input.defaults';
+export * from './hex-input.directives';
+export * from './hex-input.module';

package/lib/inputs/input/index.d.ts

@@ -0,0 +1,4 @@
+export * from './input.component';
+export * from './input.defaults';
+export * from './input.directives';
+export * from './input.module';

package/lib/inputs/input/input.component.d.ts

@@ -0,0 +1,15 @@
+import { _SimpleInputComponentBase } from '../_simple-input-base';
+import { ArdInputDefaults } from './input.defaults';
+import { ArdInputPlaceholderTemplateDirective, ArdInputPrefixTemplateDirective, ArdInputSuffixTemplateDirective } from './input.directives';
+import * as i0 from "@angular/core";
+export declare class ArdiumInputComponent extends _SimpleInputComponentBase {
+    protected readonly _DEFAULTS: ArdInputDefaults;
+    constructor(defaults: ArdInputDefaults);
+    readonly prefixTemplate: import("@angular/core").Signal<ArdInputPrefixTemplateDirective | undefined>;
+    readonly suffixTemplate: import("@angular/core").Signal<ArdInputSuffixTemplateDirective | undefined>;
+    readonly prefixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly suffixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly placeholderTemplate: import("@angular/core").Signal<ArdInputPlaceholderTemplateDirective | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumInputComponent, "ard-input", never, {}, {}, ["prefixTemplate", "suffixTemplate", "placeholderTemplate"], never, false, never>;
+}

package/lib/inputs/input/input.defaults.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+import { ArdFormFieldFramePrefixSuffix } from '../../form-field-frame';
+import { _SimpleInputComponentDefaults } from '../_simple-input-base';
+export interface ArdInputDefaults extends _SimpleInputComponentDefaults {
+    PrefixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+    SuffixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+}
+export declare const ARD_SIMPLE_INPUT_DEFAULTS: InjectionToken<ArdInputDefaults>;
+export declare function provideInputDefaults(config: Partial<ArdInputDefaults>): Provider;

package/lib/inputs/input/input.directives.d.ts

@@ -0,0 +1,21 @@
+import { TemplateRef } from '@angular/core';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import * as i0 from "@angular/core";
+export declare class ArdInputPlaceholderTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdInputPlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdInputPlaceholderTemplateDirective, "ard-input > ng-template[ard-placeholder-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdInputPrefixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdInputPrefixTemplateDirective, "ard-input > ng-template[ard-prefix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdInputSuffixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdInputSuffixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdInputSuffixTemplateDirective, "ard-input > ng-template[ard-suffix-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/inputs/input/input.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input.component";
+import * as i2 from "./input.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "../../_internal/clear-button/clear-button.module";
+import * as i5 from "../../form-field-frame/form-field-frame.module";
+export declare class ArdiumInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumInputModule, [typeof i1.ArdiumInputComponent, typeof i2.ArdInputPlaceholderTemplateDirective, typeof i2.ArdInputPrefixTemplateDirective, typeof i2.ArdInputSuffixTemplateDirective], [typeof i3.CommonModule, typeof i4._ClearButtonModule, typeof i5.ArdiumFormFieldFrameModule], [typeof i1.ArdiumInputComponent, typeof i2.ArdInputPlaceholderTemplateDirective, typeof i2.ArdInputPrefixTemplateDirective, typeof i2.ArdInputSuffixTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumInputModule>;
+}

package/lib/inputs/input-transformers.d.ts

@@ -0,0 +1,24 @@
+export type ArdTransformerFn = (currentText: string, previousText: string, caretPos: number) => {
+    text: string;
+    caretPos: number;
+};
+interface IRegExpTransformer {
+    apply: ArdTransformerFn;
+}
+export declare class RegExpTransformer implements IRegExpTransformer {
+    regex: RegExp;
+    replace: string;
+    caretModif: number;
+    constructor(regex: RegExp, replace?: string, caretModif?: number);
+    apply(currentText: string, previousText: string, caretPos: number): {
+        text: string;
+        caretPos: number;
+    };
+}
+export declare const ArdTransformer: {
+    readonly ToUpper: ArdTransformerFn;
+    readonly ToLower: ArdTransformerFn;
+    readonly Integer: ArdTransformerFn;
+    readonly Float: ArdTransformerFn;
+};
+export {};

package/lib/inputs/input-types.d.ts

@@ -0,0 +1,15 @@
+export declare const CaseTransformerType: {
+    readonly NoChange: "nochange";
+    readonly Uppercase: "uppercase";
+    readonly Lowercase: "lowercase";
+};
+export type CaseTransformerType = (typeof CaseTransformerType)[keyof typeof CaseTransformerType];
+export declare const ArdInputType: {
+    readonly Text: "text";
+    readonly Password: "password";
+    readonly Email: "email";
+    readonly Tel: "tel";
+    readonly Url: "url";
+    readonly Search: "search";
+};
+export type ArdInputType = (typeof ArdInputType)[keyof typeof ArdInputType];

package/lib/inputs/input-utils.d.ts

@@ -0,0 +1,66 @@
+import { ElementRef, Signal } from '@angular/core';
+import { Nullable } from '../types/utility.types';
+import { ArdNumberInputMinMaxBehavior } from './number-input/number-input.types';
+export interface InputModelHost {
+    readonly maxLength: Signal<Nullable<number>>;
+    readonly textInputEl: Signal<ElementRef<HTMLInputElement> | undefined>;
+}
+export declare class InputModel {
+    protected readonly _ardHostCmp: InputModelHost;
+    constructor(_ardHostCmp: InputModelHost);
+    readonly value: import("@angular/core").WritableSignal<string | null>;
+    readonly stringValue: Signal<string>;
+    writeValue(v: any): boolean;
+    protected _writeValue(v: string | null): boolean;
+    rewriteValueAfterHostUpdate(): void;
+    clear(): void;
+    trim(): void;
+    _updateInputElement(): void;
+    get caretPos(): number;
+    set caretPos(pos: number);
+    protected _applyLengthTransformer(v: string | null): string | null;
+}
+export interface AutocompleteInputModelHost extends InputModelHost {
+    charlist: Signal<RegExp | undefined>;
+}
+export declare class AutocompleteInputModel extends InputModel {
+    protected readonly _ardHostCmp: AutocompleteInputModelHost;
+    constructor(_ardHostCmp: AutocompleteInputModelHost);
+    protected _writeValue(v: string | null): boolean;
+    setSelection(from: number | null, to: number | null): void;
+    protected _applyAllowOrDenylistTransformer(v: string, prev: string): string;
+}
+export interface NumberInputModelHost {
+    readonly max: Signal<number>;
+    readonly min: Signal<number>;
+    readonly minMaxBehavior: Signal<ArdNumberInputMinMaxBehavior>;
+    readonly maxDecimalPlaces: Signal<number>;
+    readonly fixedDecimalPlaces: Signal<boolean>;
+    readonly decimalSeparator: Signal<string>;
+    readonly allowFloat: Signal<boolean>;
+    readonly inputEl: Signal<ElementRef<HTMLInputElement> | undefined>;
+}
+export declare class NumberInputModel {
+    protected readonly _ardHostCmp: NumberInputModelHost;
+    constructor(_ardHostCmp: NumberInputModelHost);
+    protected readonly _value: import("@angular/core").WritableSignal<string | null>;
+    readonly value: Signal<string | null>;
+    readonly stringValue: Signal<string>;
+    readonly numberValue: Signal<number | null>;
+    setValue(v: string | number | null): void;
+    updateOnBlur(adjustMinMax?: boolean): void;
+    private _fixDecimalPlaces;
+    private _updateInputEl;
+    writeValue(v: any, applyConstraints: boolean): boolean;
+    protected _writeValue(v: string | null, applyConstraints: boolean): boolean;
+    rewriteValueAfterHostUpdate(): void;
+    get caretPos(): number;
+    set caretPos(pos: number);
+    private _applyStandardConstraints;
+    private _standardizeSeparator;
+    private _removeDecimalPlaces;
+    private _applyNumberConstraint;
+    private _applyMinMaxConstraints;
+    private _applyMaxDecimalPlaces;
+}
+export declare function escapeAndCreateRegex(str: string, flags?: string, negated?: boolean): RegExp;

package/lib/inputs/number-input/index.d.ts

@@ -0,0 +1,4 @@
+export * from './number-input.component';
+export * from './number-input.defaults';
+export * from './number-input.directives';
+export * from './number-input.module';

package/lib/inputs/number-input/number-input.component.d.ts

@@ -0,0 +1,78 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanLike, NumberLike } from '@ardium-ui/devkit';
+import { _FormFieldComponentBase } from '../../_internal/form-field-component';
+import { ButtonAppearance, ButtonVariant } from '../../buttons/general-button.types';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import { OneAxisAlignment } from '../../types/alignment.types';
+import { FormElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { Nullable } from '../../types/utility.types';
+import { NumberInputModel, NumberInputModelHost } from '../input-utils';
+import { ArdNumberInputDefaults } from './number-input.defaults';
+import { ArdNumberInputPlaceholderTemplateDirective, ArdNumberInputPrefixTemplateDirective, ArdNumberInputSuffixTemplateDirective } from './number-input.directives';
+import { ArdNumberInputMinMaxBehavior } from './number-input.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumNumberInputComponent extends _FormFieldComponentBase implements ControlValueAccessor, NumberInputModelHost, AfterViewInit {
+    protected readonly _DEFAULTS: ArdNumberInputDefaults;
+    constructor(defaults: ArdNumberInputDefaults);
+    readonly inputEl: import("@angular/core").Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly inputModel: NumberInputModel;
+    private _wasViewInit;
+    ngAfterViewInit(): void;
+    readonly placeholder: import("@angular/core").InputSignal<Nullable<string>>;
+    readonly placeholderTemplate: import("@angular/core").Signal<ArdNumberInputPlaceholderTemplateDirective | undefined>;
+    readonly shouldDisplayPlaceholder: import("@angular/core").Signal<boolean>;
+    readonly prefixTemplate: import("@angular/core").Signal<ArdNumberInputPrefixTemplateDirective | undefined>;
+    readonly suffixTemplate: import("@angular/core").Signal<ArdNumberInputSuffixTemplateDirective | undefined>;
+    readonly prefixSuffixTemplateContext: import("@angular/core").Signal<FormFieldFrameTemplateContext>;
+    readonly prefixComponent: import("@angular/core").Type<import("../../form-field-frame").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly suffixComponent: import("@angular/core").Type<import("../../form-field-frame").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly prefixComponentInputs: import("@angular/core").Signal<Partial<import("../../form-field-frame").ArdFormFieldFramePrefixSuffix>>;
+    readonly suffixComponentInputs: import("@angular/core").Signal<Partial<import("../../form-field-frame").ArdFormFieldFramePrefixSuffix>>;
+    readonly appearance: import("@angular/core").InputSignal<FormElementAppearance>;
+    readonly variant: import("@angular/core").InputSignal<FormElementVariant>;
+    readonly alignText: import("@angular/core").InputSignal<OneAxisAlignment>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    readonly buttonVariant: import("@angular/core").Signal<ButtonVariant>;
+    readonly buttonAppearance: import("@angular/core").Signal<ButtonAppearance>;
+    readonly inputAttrs: import("@angular/core").InputSignal<Record<string, any>>;
+    writeValue(v: any): void;
+    protected _valueBeforeInit?: string | null;
+    set value(v: string | number | null);
+    readonly valueChange: import("@angular/core").OutputEmitterRef<number | null>;
+    readonly inputEvent: import("@angular/core").OutputEmitterRef<number | null>;
+    readonly changeEvent: import("@angular/core").OutputEmitterRef<number | null>;
+    readonly clearEvent: import("@angular/core").OutputEmitterRef<MouseEvent>;
+    readonly quickChangeEvent: import("@angular/core").OutputEmitterRef<{
+        readonly direction: 1 | -1;
+        readonly value: number;
+    }>;
+    readonly min: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly max: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly minMaxBehavior: import("@angular/core").InputSignal<ArdNumberInputMinMaxBehavior>;
+    readonly maxDecimalPlaces: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    readonly fixedDecimalPlaces: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly decimalSeparator: import("@angular/core").InputSignalWithTransform<string, string>;
+    readonly allowFloat: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly noButtons: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly keepFocusOnQuickChangeButton: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly stepSize: import("@angular/core").InputSignalWithTransform<number, NumberLike>;
+    onQuickChangeButtonClick(direction: 1 | -1, event?: MouseEvent): void;
+    private _focusInputIfCantQuickChange;
+    private _isQuickChangeButtonFocused;
+    onQuickChangeButtonMouseup(event: MouseEvent): void;
+    readonly canIncrement: import("@angular/core").Signal<boolean>;
+    readonly canDecrement: import("@angular/core").Signal<boolean>;
+    onInput(newVal: string): void;
+    protected _emitInput(): void;
+    onFocusMaster(event: FocusEvent): void;
+    onBlurMaster(event: FocusEvent): void;
+    onChange(event: Event): void;
+    protected _emitChange(): void;
+    onMouseup(): void;
+    onCopy(event: ClipboardEvent): void;
+    protected _setInputAttributes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumNumberInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumNumberInputComponent, "ard-number-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "alignText": { "alias": "alignText"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "inputAttrs": { "alias": "inputAttrs"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "minMaxBehavior": { "alias": "minMaxBehavior"; "required": false; "isSignal": true; }; "maxDecimalPlaces": { "alias": "maxDecimalPlaces"; "required": false; "isSignal": true; }; "fixedDecimalPlaces": { "alias": "fixedDecimalPlaces"; "required": false; "isSignal": true; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; "isSignal": true; }; "allowFloat": { "alias": "allowFloat"; "required": false; "isSignal": true; }; "noButtons": { "alias": "noButtons"; "required": false; "isSignal": true; }; "keepFocusOnQuickChangeButton": { "alias": "keepFocusOnQuickChangeButton"; "required": false; "isSignal": true; }; "stepSize": { "alias": "stepSize"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "inputEvent": "input"; "changeEvent": "change"; "clearEvent": "clear"; "quickChangeEvent": "quickChange"; }, ["placeholderTemplate", "prefixTemplate", "suffixTemplate"], never, false, never>;
+}

package/lib/inputs/number-input/number-input.defaults.d.ts

@@ -0,0 +1,28 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+import { _FormFieldComponentDefaults } from '../../_internal/form-field-component';
+import { ArdFormFieldFramePrefixSuffix } from '../../form-field-frame';
+import { OneAxisAlignment } from './../../types/alignment.types';
+import { FormElementAppearance, FormElementVariant } from './../../types/theming.types';
+import { ArdNumberInputMinMaxBehavior } from './number-input.types';
+export interface ArdNumberInputDefaults extends _FormFieldComponentDefaults {
+    appearance: FormElementAppearance;
+    variant: FormElementVariant;
+    compact: boolean;
+    placeholder: string;
+    alignText: OneAxisAlignment;
+    inputAttrs: Record<string, any>;
+    min: number;
+    max: number;
+    minMaxBehavior: ArdNumberInputMinMaxBehavior;
+    maxDecimalPlaces: number;
+    fixedDecimalPlaces: boolean;
+    decimalSeparator: string;
+    allowFloat: boolean;
+    noButtons: boolean;
+    stepSize: number;
+    keepFocusOnQuickChangeButton: boolean;
+    PrefixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+    SuffixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+}
+export declare const ARD_NUMBER_INPUT_DEFAULTS: InjectionToken<ArdNumberInputDefaults>;
+export declare function provideNumberInputDefaults(config: Partial<ArdNumberInputDefaults>): Provider;

package/lib/inputs/number-input/number-input.directives.d.ts

@@ -0,0 +1,21 @@
+import { TemplateRef } from '@angular/core';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import * as i0 from "@angular/core";
+export declare class ArdNumberInputPlaceholderTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdNumberInputPlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdNumberInputPlaceholderTemplateDirective, "ard-number-input > ng-template[ard-placeholder-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdNumberInputPrefixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdNumberInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdNumberInputPrefixTemplateDirective, "ard-number-input > ng-template[ard-prefix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdNumberInputSuffixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdNumberInputSuffixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdNumberInputSuffixTemplateDirective, "ard-number-input > ng-template[ard-suffix-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/inputs/number-input/number-input.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./number-input.component";
+import * as i2 from "./number-input.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "@ardium-ui/devkit";
+import * as i5 from "../../buttons/button/button.module";
+export declare class ArdiumNumberInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumNumberInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumNumberInputModule, [typeof i1.ArdiumNumberInputComponent, typeof i2.ArdNumberInputPlaceholderTemplateDirective, typeof i2.ArdNumberInputPrefixTemplateDirective, typeof i2.ArdNumberInputSuffixTemplateDirective], [typeof i3.CommonModule, typeof i4.ArdiumHoldModule, typeof i5.ArdiumButtonModule], [typeof i1.ArdiumNumberInputComponent, typeof i2.ArdNumberInputPlaceholderTemplateDirective, typeof i2.ArdNumberInputPrefixTemplateDirective, typeof i2.ArdNumberInputSuffixTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumNumberInputModule>;
+}

package/lib/inputs/number-input/number-input.types.d.ts

@@ -0,0 +1,6 @@
+export declare const ArdNumberInputMinMaxBehavior: {
+    readonly AdjustOnInput: "adjust-on-input";
+    readonly AdjustOnBlur: "adjust-on-blur";
+    readonly Noop: "noop";
+};
+export type ArdNumberInputMinMaxBehavior = typeof ArdNumberInputMinMaxBehavior[keyof typeof ArdNumberInputMinMaxBehavior];

package/lib/inputs/password-input/index.d.ts

@@ -0,0 +1,5 @@
+export * from './password-input.component';
+export * from './password-input.defaults';
+export * from './password-input.directives';
+export * from './password-input.module';
+export * from './password-input.types';

package/lib/inputs/password-input/password-input.component.d.ts

@@ -0,0 +1,48 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { _FormFieldComponentBase } from '../../_internal/form-field-component';
+import { FormElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { Nullable } from '../../types/utility.types';
+import { ArdPasswordInputDefaults } from './password-input.defaults';
+import { ArdPasswordInputPlaceholderTemplateDirective, ArdPasswordInputPrefixTemplateDirective, ArdPasswordInputRevealButtonTemplateDirective, ArdPasswordInputSuffixTemplateDirective } from './password-input.directives';
+import { PasswordInputRevealButtonContext } from './password-input.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumPasswordInputComponent extends _FormFieldComponentBase implements ControlValueAccessor, OnInit, OnDestroy {
+    protected readonly _DEFAULTS: ArdPasswordInputDefaults;
+    constructor(defaults: ArdPasswordInputDefaults);
+    readonly textInputEl: import("@angular/core").Signal<ElementRef<HTMLInputElement> | undefined>;
+    ngOnInit(): void;
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    readonly prefixTemplate: import("@angular/core").Signal<ArdPasswordInputPrefixTemplateDirective | undefined>;
+    readonly suffixTemplate: import("@angular/core").Signal<ArdPasswordInputSuffixTemplateDirective | undefined>;
+    readonly prefixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly suffixComponent: import("@angular/core").Type<import("@ardium-pl/ui").ArdFormFieldFramePrefixSuffix> | undefined;
+    readonly placeholderTemplate: import("@angular/core").Signal<ArdPasswordInputPlaceholderTemplateDirective | undefined>;
+    readonly shouldDisplayPlaceholder: import("@angular/core").Signal<boolean>;
+    readonly revealable: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly holdToReveal: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly autoHideTimeoutMs: import("@angular/core").InputSignalWithTransform<Nullable<number>, any>;
+    readonly revealed: import("@angular/core").ModelSignal<boolean>;
+    private _hideTimeout;
+    toggleReveal(newState?: boolean): void;
+    onMouseUp(): void;
+    ngOnDestroy(): void;
+    readonly revealTemplate: import("@angular/core").Signal<ArdPasswordInputRevealButtonTemplateDirective | undefined>;
+    readonly revealButtonContext: import("@angular/core").Signal<PasswordInputRevealButtonContext>;
+    readonly appearance: import("@angular/core").InputSignal<FormElementAppearance>;
+    readonly variant: import("@angular/core").InputSignal<FormElementVariant>;
+    readonly compact: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    readonly inputAttrs: import("@angular/core").InputSignal<Record<string, any>>;
+    writeValue(v: any): void;
+    protected _writeValue(v: string | null): boolean;
+    readonly value: import("@angular/core").ModelSignal<string | null>;
+    onInput(newVal: string): void;
+    protected _emitChange(): void;
+    onChange(event: Event): void;
+    onCopy(event: ClipboardEvent): void;
+    protected _setInputAttributes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumPasswordInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumPasswordInputComponent, "ard-password-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "revealable": { "alias": "revealable"; "required": false; "isSignal": true; }; "holdToReveal": { "alias": "holdToReveal"; "required": false; "isSignal": true; }; "autoHideTimeoutMs": { "alias": "autoHideTimeoutMs"; "required": false; "isSignal": true; }; "revealed": { "alias": "revealed"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "inputAttrs": { "alias": "inputAttrs"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "revealed": "revealedChange"; "value": "valueChange"; }, ["prefixTemplate", "suffixTemplate", "placeholderTemplate", "revealTemplate"], never, false, never>;
+}

package/lib/inputs/password-input/password-input.defaults.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+import { _FormFieldComponentDefaults } from '../../_internal/form-field-component';
+import { ArdFormFieldFramePrefixSuffix } from '../../form-field-frame';
+import { FormElementAppearance, FormElementVariant } from './../../types/theming.types';
+import { Nullable } from './../../types/utility.types';
+export interface ArdPasswordInputDefaults extends _FormFieldComponentDefaults {
+    appearance: FormElementAppearance;
+    variant: FormElementVariant;
+    compact: boolean;
+    placeholder: string;
+    revealable: boolean;
+    holdToReveal: boolean;
+    autoHideTimeoutMs: Nullable<number>;
+    revealed: boolean;
+    inputAttrs: Record<string, any>;
+    PrefixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+    SuffixComponent?: Type<ArdFormFieldFramePrefixSuffix>;
+}
+export declare const ARD_PASSWORD_INPUT_DEFAULTS: InjectionToken<ArdPasswordInputDefaults>;
+export declare function providePasswordInputDefaults(config: Partial<ArdPasswordInputDefaults>): Provider;

package/lib/inputs/password-input/password-input.directives.d.ts

@@ -0,0 +1,28 @@
+import { TemplateRef } from '@angular/core';
+import { FormFieldFrameTemplateContext } from '../../form-field-frame';
+import { PasswordInputRevealButtonContext } from './password-input.types';
+import * as i0 from "@angular/core";
+export declare class ArdPasswordInputPlaceholderTemplateDirective {
+    template: TemplateRef<undefined>;
+    constructor(template: TemplateRef<undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdPasswordInputPlaceholderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdPasswordInputPlaceholderTemplateDirective, "ard-password-input > ng-template[ard-placeholder-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdPasswordInputPrefixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdPasswordInputPrefixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdPasswordInputPrefixTemplateDirective, "ard-password-input > ng-template[ard-prefix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdPasswordInputSuffixTemplateDirective {
+    template: TemplateRef<FormFieldFrameTemplateContext>;
+    constructor(template: TemplateRef<FormFieldFrameTemplateContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdPasswordInputSuffixTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdPasswordInputSuffixTemplateDirective, "ard-password-input > ng-template[ard-suffix-tmp]", never, {}, {}, never, never, false, never>;
+}
+export declare class ArdPasswordInputRevealButtonTemplateDirective {
+    template: TemplateRef<PasswordInputRevealButtonContext>;
+    constructor(template: TemplateRef<PasswordInputRevealButtonContext>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdPasswordInputRevealButtonTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdPasswordInputRevealButtonTemplateDirective, "ard-password-input > ng-template[ard-reveal-tmp]", never, {}, {}, never, never, false, never>;
+}

package/lib/inputs/password-input/password-input.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./password-input.component";
+import * as i2 from "./password-input.directives";
+import * as i3 from "@angular/common";
+import * as i4 from "../../form-field-frame/form-field-frame.module";
+import * as i5 from "../../icon/icon.module";
+export declare class ArdiumPasswordInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumPasswordInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ArdiumPasswordInputModule, [typeof i1.ArdiumPasswordInputComponent, typeof i2.ArdPasswordInputPlaceholderTemplateDirective, typeof i2.ArdPasswordInputPrefixTemplateDirective, typeof i2.ArdPasswordInputSuffixTemplateDirective, typeof i2.ArdPasswordInputRevealButtonTemplateDirective], [typeof i3.CommonModule, typeof i4.ArdiumFormFieldFrameModule, typeof i5.ArdiumIconModule], [typeof i1.ArdiumPasswordInputComponent, typeof i2.ArdPasswordInputPlaceholderTemplateDirective, typeof i2.ArdPasswordInputPrefixTemplateDirective, typeof i2.ArdPasswordInputSuffixTemplateDirective, typeof i2.ArdPasswordInputRevealButtonTemplateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ArdiumPasswordInputModule>;
+}

package/lib/inputs/password-input/password-input.types.d.ts

@@ -0,0 +1,3 @@
+export interface PasswordInputRevealButtonContext {
+    $implicit: boolean;
+}

package/lib/kbd/index.d.ts

@@ -0,0 +1,5 @@
+export * from './kbd.component';
+export * from './kbd.defaults';
+export * from './kbd.directive';
+export * from './kbd.module';
+export * from './kbd.pipe';

package/lib/kbd/kbd.component.d.ts

@@ -0,0 +1,15 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { BooleanLike } from '@ardium-ui/devkit';
+import { FormElementAppearance } from './../types/theming.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumKbdComponent implements AfterViewInit {
+    protected readonly _DEFAULTS: import("./kbd.defaults").ArdKbdDefaults;
+    readonly contentWrapper: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    ngAfterViewInit(): void;
+    readonly key: import("@angular/core").InputSignal<string>;
+    readonly full: import("@angular/core").InputSignalWithTransform<boolean, BooleanLike>;
+    readonly appearance: import("@angular/core").InputSignal<FormElementAppearance>;
+    readonly ngClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumKbdComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ArdiumKbdComponent, "ard-kbd", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; "full": { "alias": "full"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}

package/lib/kbd/kbd.defaults.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { FormElementAppearance } from './../types/theming.types';
+export interface ArdKbdDefaults {
+    full: boolean;
+    appearance: FormElementAppearance;
+}
+export declare const ARD_KBD_DEFAULTS: InjectionToken<ArdKbdDefaults>;
+export declare function provideKbdDefaults(config: Partial<ArdKbdDefaults>): Provider;

package/lib/kbd/kbd.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import { FormElementAppearance } from './../types/theming.types';
+import * as i0 from "@angular/core";
+export declare class ArdiumKbdDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly renderer: Renderer2;
+    readonly appearance: import("@angular/core").InputSignal<FormElementAppearance>;
+    readonly ngClasses: import("@angular/core").Signal<string[]>;
+    constructor();
+    private updateClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArdiumKbdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ArdiumKbdDirective, "[ardKbd]", never, { "appearance": { "alias": "ardKbdAppearance"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}