init

node_modules/ng-zorro-antd/input/index.d.ts

@@ -0,0 +1,352 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, DoCheck, TemplateRef, OnInit, ViewContainerRef, ComponentRef, ElementRef, AfterContentInit, OnChanges, QueryList, SimpleChanges, InjectionToken } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { Direction } from '@angular/cdk/bidi';
+import * as ng_zorro_antd_core_types from 'ng-zorro-antd/core/types';
+import { NzVariant, NzSizeLDSType, NzStatus, NgClassInterface, NzValidateStatus, OnTouchedType } from 'ng-zorro-antd/core/types';
+import * as rxjs from 'rxjs';
+import { NgControl, ControlValueAccessor, FormArray, FormControl } from '@angular/forms';
+import { NzFormItemFeedbackIconComponent } from 'ng-zorro-antd/core/form';
+import * as i1 from 'ng-zorro-antd/space';
+
+interface AutoSizeType {
+    minRows?: number;
+    maxRows?: number;
+}
+declare class NzAutosizeDirective implements AfterViewInit, DoCheck {
+    private ngZone;
+    private platform;
+    private destroyRef;
+    private resizeService;
+    private el;
+    private autosize;
+    private cachedLineHeight;
+    private previousValue;
+    private previousMinRows;
+    private minRows;
+    private maxRows;
+    private maxHeight;
+    private minHeight;
+    private inputGap;
+    private destroyed;
+    constructor();
+    set nzAutosize(value: string | boolean | AutoSizeType);
+    resizeToFitContent(force?: boolean): void;
+    private cacheTextareaLineHeight;
+    setMinHeight(): number | null;
+    setMaxHeight(): number | null;
+    noopInputHandler(): void;
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzAutosizeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzAutosizeDirective, "textarea[nzAutosize]", ["nzAutosize"], { "nzAutosize": { "alias": "nzAutosize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NzInputAddonBeforeDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputAddonBeforeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputAddonBeforeDirective, "[nzInputAddonBefore]", never, {}, {}, never, never, true, never>;
+}
+declare class NzInputAddonAfterDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputAddonAfterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputAddonAfterDirective, "[nzInputAddonAfter]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NzInputPrefixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputPrefixDirective, "[nzInputPrefix]", never, {}, {}, never, never, true, never>;
+}
+declare class NzInputSuffixDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputSuffixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputSuffixDirective, "[nzInputSuffix]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+/**
+ * @deprecated Will be removed in v22.0.0. This component will be removed along with input-group.
+ */
+declare class NzInputGroupSlotComponent {
+    icon?: string | null;
+    type: 'addon' | 'prefix' | 'suffix' | null;
+    template?: string | TemplateRef<void> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputGroupSlotComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NzInputGroupSlotComponent, "[nz-input-group-slot]", never, { "icon": { "alias": "icon"; "required": false; }; "type": { "alias": "type"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NzInputPasswordDirective {
+    readonly nzVisibilityToggle: _angular_core.InputSignal<boolean>;
+    readonly nzVisible: _angular_core.ModelSignal<boolean>;
+    toggleVisible(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputPasswordDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputPasswordDirective, "nz-input-password", ["nzInputPassword"], { "nzVisibilityToggle": { "alias": "nzVisibilityToggle"; "required": false; "isSignal": true; }; "nzVisible": { "alias": "nzVisible"; "required": false; "isSignal": true; }; }, { "nzVisible": "nzVisibleChange"; }, never, never, true, never>;
+}
+declare class NzInputPasswordIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputPasswordIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputPasswordIconDirective, "[nzInputPasswordIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NzInputSearchDirective {
+    private readonly inputDir;
+    private readonly inputRef;
+    readonly nzEnterButton: _angular_core.InputSignal<string | boolean>;
+    readonly nzLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nzSearch: _angular_core.OutputEmitterRef<NzInputSearchEvent>;
+    readonly size: _angular_core.Signal<ng_zorro_antd_core_types.NzSizeLDSType>;
+    search(event: Event, source?: 'input' | 'clear'): void;
+    onEnter(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputSearchDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputSearchDirective, "nz-input-search", ["nzInputSearch"], { "nzEnterButton": { "alias": "nzEnterButton"; "required": false; "isSignal": true; }; "nzLoading": { "alias": "nzLoading"; "required": false; "isSignal": true; }; }, { "nzSearch": "nzSearch"; }, ["inputDir", "inputRef"], never, true, never>;
+}
+declare class NzInputSearchEnterButtonDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputSearchEnterButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputSearchEnterButtonDirective, "[nzInputSearchEnterButton]", never, {}, {}, never, never, true, never>;
+}
+interface NzInputSearchEvent {
+    value: string;
+    event: Event;
+    source: 'clear' | 'input';
+}
+
+declare class NzInputDirective implements OnInit {
+    private elementRef;
+    private compactSize;
+    private destroyRef;
+    private nzFormStatusService;
+    private nzFormNoStatusService;
+    private inputWrapper;
+    private focusMonitor;
+    protected hostView: ViewContainerRef;
+    protected readonly inputPasswordDir: NzInputPasswordDirective | null;
+    protected readonly inputSearchDir: NzInputSearchDirective | null;
+    readonly ngControl: NgControl | null;
+    readonly value: _angular_core.WritableSignal<string>;
+    /**
+     * @deprecated Will be removed in v21. It is recommended to use `nzVariant` instead.
+     */
+    readonly nzBorderless: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nzVariant: _angular_core.InputSignal<NzVariant>;
+    readonly nzSize: _angular_core.InputSignal<NzSizeLDSType>;
+    /**
+     * @deprecated Will be removed in v22.
+     */
+    readonly nzStepperless: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nzStatus: _angular_core.InputSignal<NzStatus>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly controlDisabled: _angular_core.WritableSignal<boolean>;
+    readonly finalDisabled: _angular_core.WritableSignal<boolean> | _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dir: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    readonly size: _angular_core.WritableSignal<NzSizeLDSType>;
+    readonly status: _angular_core.Signal<ng_zorro_antd_core_types.NzValidateStatus>;
+    readonly hasFeedback: _angular_core.Signal<boolean>;
+    readonly classes: _angular_core.Signal<ng_zorro_antd_core_types.NgClassInterface>;
+    readonly type: _angular_core.Signal<any>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly finalSize: _angular_core.Signal<NzSizeLDSType>;
+    feedbackRef: ComponentRef<NzFormItemFeedbackIconComponent> | null;
+    disabled$: rxjs.Observable<boolean>;
+    constructor();
+    ngOnInit(): void;
+    private renderFeedbackIcon;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputDirective, "input[nz-input],textarea[nz-input]", ["nzInput"], { "nzBorderless": { "alias": "nzBorderless"; "required": false; "isSignal": true; }; "nzVariant": { "alias": "nzVariant"; "required": false; "isSignal": true; }; "nzSize": { "alias": "nzSize"; "required": false; "isSignal": true; }; "nzStepperless": { "alias": "nzStepperless"; "required": false; "isSignal": true; }; "nzStatus": { "alias": "nzStatus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NzSpaceCompactItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * @deprecated Will be removed in v22.0.0. This component will be removed along with input-group.
+ */
+declare class NzInputGroupWhitSuffixOrPrefixDirective {
+    readonly elementRef: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputGroupWhitSuffixOrPrefixDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NzInputGroupWhitSuffixOrPrefixDirective, "nz-input-group[nzSuffix], nz-input-group[nzPrefix]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * @deprecated Will be removed in v22. It is recommended to use `<nz-input-wrapper>` instead.
+ */
+declare class NzInputGroupComponent implements AfterContentInit, OnChanges, OnInit {
+    private focusMonitor;
+    private elementRef;
+    private renderer;
+    private cdr;
+    private directionality;
+    private destroyRef;
+    private nzFormStatusService;
+    private nzFormNoStatusService;
+    listOfNzInputDirective: QueryList<NzInputDirective>;
+    nzAddOnBeforeIcon?: string | null;
+    nzAddOnAfterIcon?: string | null;
+    nzPrefixIcon?: string | null;
+    nzSuffixIcon?: string | null;
+    nzAddOnBefore?: string | TemplateRef<void>;
+    nzAddOnAfter?: string | TemplateRef<void>;
+    nzPrefix?: string | TemplateRef<void>;
+    nzStatus: NzStatus;
+    nzSuffix?: string | TemplateRef<void>;
+    nzSize: NzSizeLDSType;
+    nzSearch: boolean;
+    isLarge: boolean;
+    isSmall: boolean;
+    isAffix: boolean;
+    isAddOn: boolean;
+    isFeedback: boolean;
+    focused: boolean;
+    disabled: boolean;
+    dir: Direction;
+    prefixCls: string;
+    affixStatusCls: NgClassInterface;
+    groupStatusCls: NgClassInterface;
+    affixInGroupStatusCls: NgClassInterface;
+    status: NzValidateStatus;
+    hasFeedback: boolean;
+    constructor();
+    updateChildrenInputSize(): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private setStatusStyles;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NzInputGroupComponent, "nz-input-group", ["nzInputGroup"], { "nzAddOnBeforeIcon": { "alias": "nzAddOnBeforeIcon"; "required": false; }; "nzAddOnAfterIcon": { "alias": "nzAddOnAfterIcon"; "required": false; }; "nzPrefixIcon": { "alias": "nzPrefixIcon"; "required": false; }; "nzSuffixIcon": { "alias": "nzSuffixIcon"; "required": false; }; "nzAddOnBefore": { "alias": "nzAddOnBefore"; "required": false; }; "nzAddOnAfter": { "alias": "nzAddOnAfter"; "required": false; }; "nzPrefix": { "alias": "nzPrefix"; "required": false; }; "nzStatus": { "alias": "nzStatus"; "required": false; }; "nzSuffix": { "alias": "nzSuffix"; "required": false; }; "nzSize": { "alias": "nzSize"; "required": false; }; "nzSearch": { "alias": "nzSearch"; "required": false; }; }, {}, ["listOfNzInputDirective"], ["*"], true, [{ directive: typeof i1.NzSpaceCompactItemDirective; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_nzSearch: unknown;
+}
+
+declare class NzInputOtpComponent implements ControlValueAccessor, OnChanges {
+    private formBuilder;
+    private destroyRef;
+    otpInputs: QueryList<ElementRef>;
+    nzLength: number;
+    nzSize: NzSizeLDSType;
+    disabled: boolean;
+    nzStatus: NzStatus;
+    nzFormatter: (value: string) => string;
+    nzMask: string | null;
+    protected otpArray: FormArray<FormControl<string>>;
+    private internalValue;
+    private onChangeCallback?;
+    onTouched: OnTouchedType;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    onInput(index: number, event: Event): void;
+    onFocus(event: FocusEvent): void;
+    onKeyDown(index: number, event: KeyboardEvent): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => {}): void;
+    setDisabledState(isDisabled: boolean): void;
+    onPaste(index: number, event: ClipboardEvent): void;
+    private createFormArray;
+    private emitValue;
+    private selectInputBox;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputOtpComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NzInputOtpComponent, "nz-input-otp", ["nzInputOtp"], { "nzLength": { "alias": "nzLength"; "required": false; }; "nzSize": { "alias": "nzSize"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "nzStatus": { "alias": "nzStatus"; "required": false; }; "nzFormatter": { "alias": "nzFormatter"; "required": false; }; "nzMask": { "alias": "nzMask"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_nzLength: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class NzInputWrapperComponent {
+    private readonly focusMonitor;
+    protected readonly inputPasswordDir: NzInputPasswordDirective | null;
+    protected readonly inputSearchDir: NzInputSearchDirective | null;
+    protected readonly inputRef: _angular_core.Signal<ElementRef<any>>;
+    protected readonly inputDir: _angular_core.Signal<NzInputDirective>;
+    protected readonly prefix: _angular_core.Signal<NzInputPrefixDirective | undefined>;
+    protected readonly suffix: _angular_core.Signal<NzInputSuffixDirective | undefined>;
+    protected readonly addonBefore: _angular_core.Signal<NzInputAddonBeforeDirective | undefined>;
+    protected readonly addonAfter: _angular_core.Signal<NzInputAddonAfterDirective | undefined>;
+    protected readonly inputPasswordIconTmpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly inputSearchEnterButton: _angular_core.Signal<NzInputSearchEnterButtonDirective | undefined>;
+    readonly nzAllowClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly nzPrefix: _angular_core.InputSignal<string | undefined>;
+    readonly nzSuffix: _angular_core.InputSignal<string | undefined>;
+    readonly nzAddonBefore: _angular_core.InputSignal<string | undefined>;
+    readonly nzAddonAfter: _angular_core.InputSignal<string | undefined>;
+    readonly nzClear: _angular_core.OutputEmitterRef<void>;
+    readonly size: _angular_core.Signal<ng_zorro_antd_core_types.NzSizeLDSType>;
+    readonly variant: _angular_core.Signal<ng_zorro_antd_core_types.NzVariant>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly readOnly: _angular_core.Signal<boolean>;
+    readonly status: _angular_core.Signal<ng_zorro_antd_core_types.NzValidateStatus>;
+    readonly hasFeedback: _angular_core.Signal<boolean>;
+    protected readonly hasPrefix: _angular_core.Signal<boolean>;
+    protected readonly hasSuffix: _angular_core.Signal<true | NzInputPasswordDirective | null>;
+    protected readonly hasAffix: _angular_core.Signal<true | NzInputPasswordDirective | null>;
+    protected readonly hasAddonBefore: _angular_core.Signal<boolean>;
+    protected readonly hasAddonAfter: _angular_core.Signal<boolean>;
+    protected readonly hasAddon: _angular_core.Signal<boolean>;
+    private readonly compactSize;
+    protected readonly dir: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    protected readonly focused: _angular_core.WritableSignal<boolean>;
+    protected readonly isTextarea: _angular_core.Signal<boolean>;
+    protected readonly finalSize: _angular_core.Signal<ng_zorro_antd_core_types.NzSizeLDSType>;
+    protected readonly class: _angular_core.Signal<{
+        'ant-input-group-wrapper': boolean;
+        'ant-input-group-wrapper-sm': boolean;
+        'ant-input-group-wrapper-lg': boolean;
+        'ant-input-group-wrapper-rtl': boolean;
+    } | {
+        'ant-input-affix-wrapper': boolean;
+        'ant-input-affix-wrapper-lg': boolean;
+        'ant-input-affix-wrapper-sm': boolean;
+        'ant-input-affix-wrapper-disabled': boolean;
+        'ant-input-affix-wrapper-readonly': boolean;
+        'ant-input-affix-wrapper-focused': boolean;
+        'ant-input-affix-wrapper-rtl': boolean;
+    } | null>;
+    protected readonly affixWrapperClass: _angular_core.Signal<{
+        'ant-input-affix-wrapper': boolean;
+        'ant-input-affix-wrapper-lg': boolean;
+        'ant-input-affix-wrapper-sm': boolean;
+        'ant-input-affix-wrapper-disabled': boolean;
+        'ant-input-affix-wrapper-readonly': boolean;
+        'ant-input-affix-wrapper-focused': boolean;
+        'ant-input-affix-wrapper-rtl': boolean;
+    }>;
+    protected readonly groupWrapperClass: _angular_core.Signal<{
+        'ant-input-group-wrapper': boolean;
+        'ant-input-group-wrapper-sm': boolean;
+        'ant-input-group-wrapper-lg': boolean;
+        'ant-input-group-wrapper-rtl': boolean;
+    }>;
+    constructor();
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NzInputWrapperComponent, "nz-input-wrapper,nz-input-password,nz-input-search", ["nzInputWrapper"], { "nzAllowClear": { "alias": "nzAllowClear"; "required": false; "isSignal": true; }; "nzPrefix": { "alias": "nzPrefix"; "required": false; "isSignal": true; }; "nzSuffix": { "alias": "nzSuffix"; "required": false; "isSignal": true; }; "nzAddonBefore": { "alias": "nzAddonBefore"; "required": false; "isSignal": true; }; "nzAddonAfter": { "alias": "nzAddonAfter"; "required": false; "isSignal": true; }; }, { "nzClear": "nzClear"; }, ["inputRef", "inputDir", "prefix", "suffix", "addonBefore", "addonAfter", "inputPasswordIconTmpl", "inputSearchEnterButton"], ["[nzInputAddonBefore]", "[nzInputSearchEnterButton]", "[nzInputAddonAfter]", "[nzInputPrefix]", "[nzInputClearIcon]", "[nzInputSuffix]", "[nz-input]"], true, [{ directive: typeof i1.NzSpaceCompactItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare class NzTextareaCountComponent implements AfterContentInit {
+    private renderer;
+    private destroyRef;
+    private elementRef;
+    nzInputDirective: NzInputDirective;
+    nzMaxCharacterCount: number;
+    nzComputeCharacterCount: (v: string) => number;
+    nzFormatter: (cur: number, max: number) => string;
+    ngAfterContentInit(): void;
+    setDataCount(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzTextareaCountComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NzTextareaCountComponent, "nz-textarea-count", never, { "nzMaxCharacterCount": { "alias": "nzMaxCharacterCount"; "required": false; }; "nzComputeCharacterCount": { "alias": "nzComputeCharacterCount"; "required": false; }; "nzFormatter": { "alias": "nzFormatter"; "required": false; }; }, {}, ["nzInputDirective"], ["textarea[nz-input]"], true, never>;
+    static ngAcceptInputType_nzMaxCharacterCount: unknown;
+}
+
+declare class NzInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NzInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NzInputModule, never, [typeof NzTextareaCountComponent, typeof NzInputDirective, typeof NzInputWrapperComponent, typeof NzInputPasswordDirective, typeof NzInputPasswordIconDirective, typeof NzInputSearchDirective, typeof NzInputSearchEnterButtonDirective, typeof NzInputAddonBeforeDirective, typeof NzInputAddonAfterDirective, typeof NzInputPrefixDirective, typeof NzInputSuffixDirective, typeof NzInputGroupComponent, typeof NzAutosizeDirective, typeof NzInputGroupSlotComponent, typeof NzInputGroupWhitSuffixOrPrefixDirective, typeof NzInputOtpComponent], [typeof NzTextareaCountComponent, typeof NzInputDirective, typeof NzInputWrapperComponent, typeof NzInputPasswordDirective, typeof NzInputPasswordIconDirective, typeof NzInputSearchDirective, typeof NzInputSearchEnterButtonDirective, typeof NzInputAddonBeforeDirective, typeof NzInputAddonAfterDirective, typeof NzInputPrefixDirective, typeof NzInputSuffixDirective, typeof NzInputGroupComponent, typeof NzAutosizeDirective, typeof NzInputGroupWhitSuffixOrPrefixDirective, typeof NzInputOtpComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NzInputModule>;
+}
+
+/**
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/NG-ZORRO/ng-zorro-antd/blob/master/LICENSE
+ */
+
+declare const NZ_INPUT_WRAPPER: InjectionToken<NzInputWrapperComponent>;
+
+export { NZ_INPUT_WRAPPER, NzAutosizeDirective, NzInputAddonAfterDirective, NzInputAddonBeforeDirective, NzInputDirective, NzInputGroupComponent, NzInputGroupSlotComponent, NzInputGroupWhitSuffixOrPrefixDirective, NzInputModule, NzInputOtpComponent, NzInputPasswordDirective, NzInputPasswordIconDirective, NzInputPrefixDirective, NzInputSearchDirective, NzInputSearchEnterButtonDirective, NzInputSuffixDirective, NzInputWrapperComponent, NzTextareaCountComponent };
+export type { AutoSizeType, NzInputSearchEvent };

node_modules/ng-zorro-antd/input/package.json

@@ -0,0 +1,3 @@
+{
+  "module": "../fesm2022/ng-zorro-antd-input.mjs"
+}

node_modules/ng-zorro-antd/input/style/IE11.less

@@ -0,0 +1,20 @@
+// Fix Input component height issue in IE11
+@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
+  .@{ant-prefix}-input {
+    height: @input-height-base;
+
+    &-lg {
+      height: @input-height-lg;
+    }
+
+    &-sm {
+      height: @input-height-sm;
+    }
+
+    &-affix-wrapper {
+      > input.@{ant-prefix}-input {
+        height: auto;
+      }
+    }
+  }
+}

node_modules/ng-zorro-antd/input/style/affix.less

@@ -0,0 +1,79 @@
+@import './mixin';
+@import (reference) '../../style/themes/index';
+@input-prefix-cls: ~'@{ant-prefix}-input';
+
+@input-affix-margin: 4px;
+
+.@{ant-prefix}-input {
+  &-affix-wrapper {
+    .input();
+    display: inline-flex;
+
+    &:not(&-disabled):hover {
+      .hover();
+      z-index: 1;
+      .@{ant-prefix}-input-search-with-button & {
+        z-index: 0;
+      }
+    }
+
+    &-focused,
+    &:focus {
+      z-index: 1;
+    }
+
+    &-disabled {
+      .@{ant-prefix}-input[disabled] {
+        background: rgba(255, 255, 255, 0);
+      }
+    }
+
+    > .@{ant-prefix}-input {
+      font-size: inherit;
+      border: none;
+      outline: none;
+
+      &:focus {
+        box-shadow: none !important;
+      }
+
+      &:not(textarea) {
+        padding: 0;
+      }
+    }
+
+    &::before {
+      display: inline-block;
+      width: 0;
+      visibility: hidden;
+      content: '\a0';
+    }
+  }
+
+  &-prefix,
+  &-suffix {
+    display: flex;
+    flex: none;
+    align-items: center;
+
+    > *:not(:last-child) {
+      margin-right: 8px;
+    }
+  }
+
+  &-show-count-suffix {
+    color: @text-color-secondary;
+  }
+
+  &-show-count-has-suffix {
+    margin-right: 2px;
+  }
+
+  &-prefix {
+    margin-right: @input-affix-margin;
+  }
+
+  &-suffix {
+    margin-left: @input-affix-margin;
+  }
+}

node_modules/ng-zorro-antd/input/style/allow-clear.less

@@ -0,0 +1,43 @@
+@import (reference) '../../style/themes/index';
+@input-prefix-cls: ~'@{ant-prefix}-input';
+
+// ========================= Input =========================
+.@{iconfont-css-prefix}.@{input-prefix-cls}-clear-icon,
+.@{input-prefix-cls}-clear-icon {
+  margin: 0;
+  color: @disabled-color;
+  font-size: @font-size-sm;
+  vertical-align: -1px;
+  // https://github.com/ant-design/ant-design/pull/18151
+  // https://codesandbox.io/s/wizardly-sun-u10br
+  cursor: pointer;
+  transition: color 0.3s;
+
+  &:hover {
+    color: @text-color-secondary;
+  }
+
+  &:active {
+    color: @text-color;
+  }
+
+  &-hidden {
+    visibility: hidden;
+  }
+
+  &-has-suffix {
+    margin: 0 @input-affix-margin;
+  }
+}
+
+// ======================= TextArea ========================
+.@{input-prefix-cls}-affix-wrapper.@{input-prefix-cls}-affix-wrapper-textarea-with-clear-btn {
+  padding: 0;
+
+  .@{input-prefix-cls}-clear-icon {
+    position: absolute;
+    top: 8px;
+    right: 8px;
+    z-index: 1;
+  }
+}

node_modules/ng-zorro-antd/input/style/entry.less

@@ -0,0 +1,2 @@
+@import './index.less';
+@import './patch.less';

node_modules/ng-zorro-antd/input/style/index.less

@@ -0,0 +1,100 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import './mixin';
+@import './affix';
+@import './allow-clear';
+@import './status';
+@input-prefix-cls: ~'@{ant-prefix}-input';
+
+// Input styles
+.@{input-prefix-cls} {
+  .reset-component();
+  .input();
+
+  //== Style for input-group: input with label, with button or dropdown...
+  &-group {
+    .reset-component();
+    .input-group(~'@{input-prefix-cls}');
+
+    &-wrapper {
+      display: inline-block;
+      width: 100%;
+      text-align: start;
+      vertical-align: top; // https://github.com/ant-design/ant-design/issues/6403
+
+      .input-group-wrapper-compact(~'@{input-prefix-cls}');
+    }
+  }
+
+  &-password-icon {
+    color: @text-color-secondary;
+    cursor: pointer;
+    transition: all 0.3s;
+
+    &:hover {
+      color: @input-icon-hover-color;
+    }
+
+    .@{input-prefix-cls}-disabled & {
+      cursor: not-allowed;
+
+      &:hover {
+        color: @text-color-secondary;
+      }
+    }
+  }
+
+  &[type='color'] {
+    height: @input-height-base;
+
+    &.@{input-prefix-cls}-lg {
+      height: @input-height-lg;
+    }
+    &.@{input-prefix-cls}-sm {
+      height: @input-height-sm;
+      padding-top: 3px;
+      padding-bottom: 3px;
+    }
+  }
+
+  &-textarea-show-count {
+    // https://github.com/ant-design/ant-design/issues/33049
+    > .@{input-prefix-cls} {
+      height: 100%;
+    }
+
+    &::after {
+      float: right;
+      color: @text-color-secondary;
+      white-space: nowrap;
+      content: attr(data-count);
+      pointer-events: none;
+    }
+
+    &.@{input-prefix-cls}-textarea-in-form-item {
+      &::after {
+        margin-bottom: -22px;
+      }
+    }
+  }
+
+  &-textarea-suffix {
+    position: absolute;
+    top: 0;
+    right: @input-padding-horizontal-base;
+    bottom: 0;
+    z-index: 1;
+    display: inline-flex;
+    align-items: center;
+    margin: auto;
+  }
+
+  // ===================== Compact Item Styles =====================
+  .compact-item(@input-prefix-cls);
+  .compact-item(~'@{input-prefix-cls}-affix-wrapper');
+  .compact-item(~'@{input-prefix-cls}-group-wrapper', ~'@{input-prefix-cls}-group-addon');
+}
+
+@import './search-input';
+@import './rtl';
+@import './IE11';

node_modules/ng-zorro-antd/input/style/input-otp.less

@@ -0,0 +1,11 @@
+.@{ant-prefix}-otp {
+  display: inline-flex;
+  flex-wrap: nowrap;
+  align-items: center;
+  column-gap: 8px;
+
+  &-input {
+    text-align: center;
+    padding-inline: 4px;
+  }
+}

node_modules/ng-zorro-antd/input/style/mixin.less

@@ -0,0 +1,549 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@input-affix-with-clear-btn-width: 38px;
+
+// size mixins for input
+.input-lg() {
+  padding: @input-padding-vertical-lg @input-padding-horizontal-lg;
+  font-size: @font-size-lg;
+}
+
+.input-sm() {
+  padding: @input-padding-vertical-sm @input-padding-horizontal-sm;
+}
+
+// input status
+// == when focus or active
+.active(@borderColor: @primary-color; @hoverBorderColor: @primary-color-hover; @outlineColor: @primary-color-outline) {
+  & when (@theme = dark) {
+    border-color: @borderColor;
+  }
+  & when (not (@theme = dark) and not (@theme = variable)) {
+    border-color: @hoverBorderColor;
+  }
+  & when not (@theme = variable) {
+    box-shadow: @input-outline-offset @outline-blur-size @outline-width
+      fade(@borderColor, @outline-fade);
+  }
+  & when (@theme = variable) {
+    border-color: @hoverBorderColor;
+    box-shadow: @input-outline-offset @outline-blur-size @outline-width @outlineColor;
+  }
+  border-right-width: @border-width-base;
+  outline: 0;
+}
+
+// == when hover
+.hover(@color: @input-hover-border-color) {
+  border-color: @color;
+  border-right-width: @border-width-base;
+}
+
+.disabled() {
+  color: @input-disabled-color;
+  background-color: @input-disabled-bg;
+  border-color: @input-border-color;
+  box-shadow: none;
+  cursor: not-allowed;
+  opacity: 1;
+
+  &:hover {
+    .hover(@input-border-color);
+  }
+}
+
+// Basic style for input
+.input() {
+  position: relative;
+  display: inline-block;
+  width: 100%;
+  min-width: 0;
+  padding: @input-padding-vertical-base @input-padding-horizontal-base;
+  color: @input-color;
+  font-size: @font-size-base;
+  line-height: @line-height-base;
+  background-color: @input-bg;
+  background-image: none;
+  border: @border-width-base @border-style-base @input-border-color;
+  border-radius: @control-border-radius;
+  transition: all 0.3s;
+  .placeholder(); // Reset placeholder
+
+  &:hover {
+    .hover();
+  }
+
+  &:focus,
+  &-focused {
+    .active();
+  }
+
+  &-disabled {
+    .disabled();
+  }
+
+  &[disabled] {
+    .disabled();
+  }
+
+  &&-borderless,
+  &&-borderless:hover,
+  &&-borderless:focus,
+  &&-borderless&-focused,
+  &&-borderless&-disabled,
+  &&-borderless&[disabled] {
+    background-color: transparent;
+    border: none;
+    box-shadow: none;
+  }
+
+  &&-filled {
+    background-color: @input-variant-filled-bg;
+    border-color: transparent;
+    box-shadow: none;
+  }
+
+  &&-filled:hover {
+    background-color: @input-variant-filled-hover-bg;
+  }
+
+  &&-filled:focus,
+  &&-filled&-focused {
+    .active();
+    background-color: transparent;
+    box-shadow: none;
+  }
+
+  &&-filled&-disabled,
+  &&-filled&[disabled] {
+    .disabled();
+  }
+
+  &&-underlined,
+  &&-underlined:hover,
+  &&-underlined:focus,
+  &&-underlined&-focused,
+  &&-underlined&-disabled,
+  &&-underlined&[disabled] {
+    background-color: transparent;
+    border-width: 0 0 @border-width-base;
+    border-radius: 0;
+    box-shadow: none;
+  }
+
+  &&-underlined:hover:not(&-focused):not(:focus) {
+    border-color: @input-border-color;
+  }
+
+  // Reset height for `textarea`s
+  textarea& {
+    max-width: 100%; // prevent textearea resize from coming out of its container
+    height: auto;
+    min-height: @input-height-base;
+    line-height: @line-height-base;
+    vertical-align: bottom;
+    transition: all 0.3s, height 0s;
+  }
+
+  // Size
+  &-lg {
+    .input-lg();
+  }
+
+  &-sm {
+    .input-sm();
+  }
+}
+
+// label input
+.input-group(@inputClass) {
+  position: relative;
+  display: table;
+  width: 100%;
+  border-collapse: separate;
+  border-spacing: 0;
+
+  // Undo padding and float of grid classes
+  &[class*='col-'] {
+    float: none;
+    padding-right: 0;
+    padding-left: 0;
+  }
+
+  > [class*='col-'] {
+    padding-right: 8px;
+
+    &:last-child {
+      padding-right: 0;
+    }
+  }
+
+  &-addon,
+  &-wrap,
+  > .@{inputClass} {
+    display: table-cell;
+
+    &:not(:first-child):not(:last-child) {
+      border-radius: 0;
+    }
+  }
+
+  &-addon,
+  &-wrap {
+    width: 1px; // To make addon/wrap as small as possible
+    white-space: nowrap;
+    vertical-align: middle;
+  }
+
+  &-wrap > * {
+    display: block !important;
+  }
+
+  .@{inputClass} {
+    float: left;
+    width: 100%;
+    margin-bottom: 0;
+    text-align: inherit;
+
+    &:focus {
+      z-index: 1; // Fix https://gw.alipayobjects.com/zos/rmsportal/DHNpoqfMXSfrSnlZvhsJ.png
+      border-right-width: 1px;
+    }
+
+    &:hover {
+      z-index: 1;
+      border-right-width: 1px;
+      .@{ant-prefix}-input-search-with-button & {
+        z-index: 0;
+      }
+    }
+  }
+
+  &-addon {
+    position: relative;
+    padding: 0 @input-padding-horizontal-base;
+    color: @input-color;
+    font-weight: normal;
+    font-size: @font-size-base;
+    text-align: center;
+    background-color: @input-addon-bg;
+    border: @border-width-base @border-style-base @input-border-color;
+    border-radius: @control-border-radius;
+    transition: all 0.3s;
+
+    // Reset Select's style in addon
+    .@{ant-prefix}-select {
+      margin: -(@input-padding-vertical-base + 1px) (-@input-padding-horizontal-base);
+
+      &.@{ant-prefix}-select-single:not(.@{ant-prefix}-select-customize-input)
+        .@{ant-prefix}-select-selector {
+        background-color: inherit;
+        border: @border-width-base @border-style-base transparent;
+        box-shadow: none;
+      }
+
+      &-open,
+      &-focused {
+        .@{ant-prefix}-select-selector {
+          color: @primary-color;
+        }
+      }
+    }
+
+    // https://github.com/ant-design/ant-design/issues/31333
+    .@{ant-prefix}-cascader-picker {
+      margin: -9px (-@control-padding-horizontal);
+      background-color: transparent;
+      .@{ant-prefix}-cascader-input {
+        text-align: left;
+        border: 0;
+        box-shadow: none;
+      }
+    }
+  }
+
+  // Reset rounded corners
+  > .@{inputClass}:first-child,
+  &-addon:first-child {
+    border-top-right-radius: 0;
+    border-bottom-right-radius: 0;
+
+    // Reset Select's style in addon
+    .@{ant-prefix}-select .@{ant-prefix}-select-selector {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+    }
+  }
+
+  > .@{inputClass}-affix-wrapper {
+    &:not(:first-child) .@{inputClass} {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+    }
+
+    &:not(:last-child) .@{inputClass} {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+    }
+  }
+
+  &-addon:first-child {
+    border-right: 0;
+  }
+
+  &-addon:last-child {
+    border-left: 0;
+  }
+
+  > .@{inputClass}:last-child,
+  &-addon:last-child {
+    border-top-left-radius: 0;
+    border-bottom-left-radius: 0;
+
+    // Reset Select's style in addon
+    .@{ant-prefix}-select .@{ant-prefix}-select-selector {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+    }
+  }
+
+  // Sizing options
+  &-lg .@{inputClass},
+  &-lg > &-addon {
+    .input-lg();
+  }
+
+  &-sm .@{inputClass},
+  &-sm > &-addon {
+    .input-sm();
+  }
+
+  // Fix https://github.com/ant-design/ant-design/issues/5754
+  &-lg .@{ant-prefix}-select-single .@{ant-prefix}-select-selector {
+    height: @input-height-lg;
+  }
+
+  &-sm .@{ant-prefix}-select-single .@{ant-prefix}-select-selector {
+    height: @input-height-sm;
+  }
+
+  .@{inputClass}-affix-wrapper {
+    &:not(:last-child) {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+      .@{ant-prefix}-input-search & {
+        border-top-left-radius: @control-border-radius;
+        border-bottom-left-radius: @control-border-radius;
+      }
+    }
+
+    &:not(:first-child),
+    .@{ant-prefix}-input-search &:not(:first-child) {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+    }
+  }
+
+  &&-compact {
+    display: block;
+    .clearfix();
+
+    &-addon,
+    &-wrap,
+    > .@{inputClass} {
+      &:not(:first-child):not(:last-child) {
+        border-right-width: @border-width-base;
+
+        &:hover {
+          z-index: 1;
+        }
+
+        &:focus {
+          z-index: 1;
+        }
+      }
+    }
+
+    & > * {
+      display: inline-block;
+      float: none;
+      vertical-align: top; // https://github.com/ant-design/ant-design-pro/issues/139
+      border-radius: 0;
+    }
+
+    & > .@{inputClass}-affix-wrapper,
+    & > .@{inputClass}-number-affix-wrapper,
+    & > .@{ant-prefix}-picker-range {
+      display: inline-flex;
+    }
+
+    & > *:not(:last-child) {
+      margin-right: -@border-width-base;
+      border-right-width: @border-width-base;
+    }
+
+    // Undo float for .ant-input-group .ant-input
+    .@{inputClass} {
+      float: none;
+    }
+
+    // reset border for Select, DatePicker, AutoComplete, Cascader, Mention, TimePicker, Input
+    & > .@{ant-prefix}-select > .@{ant-prefix}-select-selector,
+    & > .@{ant-prefix}-select-auto-complete .@{ant-prefix}-input,
+    & > .@{ant-prefix}-cascader-picker .@{ant-prefix}-input,
+    & > .@{ant-prefix}-input-group-wrapper .@{ant-prefix}-input {
+      border-right-width: @border-width-base;
+      border-radius: 0;
+
+      &:hover {
+        z-index: 1;
+      }
+
+      &:focus {
+        z-index: 1;
+      }
+    }
+
+    & > .@{ant-prefix}-select-focused {
+      z-index: 1;
+    }
+
+    // update z-index for arrow icon
+    & > .@{ant-prefix}-select > .@{ant-prefix}-select-arrow {
+      z-index: 1; // https://github.com/ant-design/ant-design/issues/20371
+    }
+
+    & > *:first-child,
+    & > .@{ant-prefix}-select:first-child > .@{ant-prefix}-select-selector,
+    & > .@{ant-prefix}-select-auto-complete:first-child .@{ant-prefix}-input,
+    & > .@{ant-prefix}-cascader-picker:first-child .@{ant-prefix}-input {
+      border-top-left-radius: @control-border-radius;
+      border-bottom-left-radius: @control-border-radius;
+    }
+
+    & > *:last-child,
+    & > .@{ant-prefix}-select:last-child > .@{ant-prefix}-select-selector,
+    & > .@{ant-prefix}-cascader-picker:last-child .@{ant-prefix}-input,
+    & > .@{ant-prefix}-cascader-picker-focused:last-child .@{ant-prefix}-input {
+      border-right-width: @border-width-base;
+      border-top-right-radius: @control-border-radius;
+      border-bottom-right-radius: @control-border-radius;
+    }
+
+    // https://github.com/ant-design/ant-design/issues/12493
+    & > .@{ant-prefix}-select-auto-complete .@{ant-prefix}-input {
+      vertical-align: top;
+    }
+
+    .@{ant-prefix}-input-group-wrapper + .@{ant-prefix}-input-group-wrapper {
+      margin-left: -1px;
+      .@{ant-prefix}-input-affix-wrapper {
+        border-radius: 0;
+      }
+    }
+
+    .@{ant-prefix}-input-group-wrapper:not(:last-child) {
+      &.@{ant-prefix}-input-search > .@{ant-prefix}-input-group {
+        & > .@{ant-prefix}-input-group-addon > .@{ant-prefix}-input-search-button {
+          border-radius: 0;
+        }
+
+        & > .@{ant-prefix}-input {
+          border-radius: @control-border-radius 0 0 @control-border-radius;
+        }
+      }
+    }
+  }
+}
+
+.input-group-wrapper-compact(@inputClass) {
+  // Fix the issue of using icons in Space Compact mode
+  // https://github.com/ant-design/ant-design/issues/42122
+  &:not(.@{inputClass}-compact-first-item):not(.@{inputClass}-compact-last-item).@{inputClass}-compact-item {
+    .@{inputClass},
+    .@{inputClass}-group-addon {
+      border-radius: 0,
+    }
+  }
+
+  &:not(.@{inputClass}-compact-last-item).@{inputClass}-compact-first-item {
+    .@{inputClass},
+    .@{inputClass}-group-addon {
+      border-start-end-radius: 0;
+      border-end-end-radius: 0;
+    }
+  }
+
+  &:not(.@{inputClass}-compact-first-item).@{inputClass}-compact-last-item {
+    .@{inputClass},
+    .@{inputClass}-group-addon {
+      border-start-start-radius: 0;
+      border-end-start-radius: 0;
+    }
+  }
+
+  // Fix the issue of input use show-count param in space compact mode
+  // https://github.com/ant-design/ant-design/issues/46872
+  &:not(.@{inputClass}-compact-last-item).@{inputClass}-compact-item {
+    .@{inputClass}-affix-wrapper {
+      border-start-end-radius: 0;
+      border-end-end-radius: 0;
+    }
+  }
+
+  // Fix the issue of input use `addonAfter` param in space compact mode
+  // https://github.com/ant-design/ant-design/issues/52483
+  &:not(.@{inputClass}-compact-first-item).@{inputClass}-compact-item {
+    .@{inputClass}-affix-wrapper {
+      border-start-start-radius: 0;
+      border-end-start-radius: 0;
+    }
+  }
+}
+
+.status-color(
+  @prefix-cls: @input-prefix-cls;
+  @text-color: @input-color;
+  @border-color: @input-border-color;
+  @background-color: @input-bg;
+  @hoverBorderColor: @primary-color-hover;
+  @outlineColor: @primary-color-outline;
+) {
+  &:not(.@{prefix-cls}-disabled):not(.@{prefix-cls}-borderless).@{prefix-cls} {
+    &,
+    &:hover {
+      background: @background-color;
+      border-color: @border-color;
+    }
+
+    &:focus,
+    &-focused {
+      .active(@text-color, @hoverBorderColor, @outlineColor);
+    }
+  }
+}
+
+.status-color-common(
+  @prefix-cls: @input-prefix-cls;
+  @text-color: @input-color;
+  @border-color: @input-border-color;
+  @background-color: @input-bg;
+  @hoverBorderColor: @primary-color-hover;
+  @outlineColor: @primary-color-outline;
+) {
+  .@{prefix-cls}-prefix {
+    color: @text-color;
+  }
+}
+
+.group-status-color(
+  @prefix-cls: @input-prefix-cls;
+  @text-color: @input-color;
+  @border-color: @input-border-color;
+) {
+  .@{prefix-cls}-group-addon {
+    color: @text-color;
+    border-color: @border-color;
+  }
+}

node_modules/ng-zorro-antd/input/style/patch.less

@@ -0,0 +1,82 @@
+@import './input-otp';
+
+textarea.nz-textarea-autosize-measuring {
+  height: auto !important;
+  // Having 2px top and bottom padding seems to fix a bug where Chrome gets an incorrect
+  // measurement. We just have to account for it later and subtract it off the final result.
+  padding: 2px 0 !important;
+  overflow: hidden !important;
+}
+
+.@{search-prefix} {
+  &-enter-button {
+    & + .@{ant-prefix}-input-group-addon,
+    input + .@{ant-prefix}-input-group-addon {
+      .@{search-rtl-cls}& {
+        .@{search-prefix}-button.@{ant-prefix}-btn-icon-only {
+          .square(@btn-height-base);
+          &.@{ant-prefix}-btn-sm {
+            .square(@btn-height-sm);
+          }
+          &.@{ant-prefix}-btn-lg {
+            .square(@btn-height-lg);
+          }
+        }
+      }
+    }
+  }
+}
+
+.ant-input-affix-wrapper-textarea-with-clear-btn .ant-input-suffix {
+  margin-left: 0;
+}
+
+nz-form-item-feedback-icon.@{ant-prefix}-input {
+  &-suffix {
+    position: absolute;
+    top: 0;
+    right: 0;
+    z-index: 1;
+    display: flex;
+    flex: none;
+    align-items: center;
+    height: 100%;
+    margin-right: @padding-sm;
+    margin-left: @input-affix-margin;
+    pointer-events: none;
+  }
+}
+
+.@{ant-prefix}-input {
+  &-status-error,
+  &-status-warning,
+  &-status-validating,
+  &-status-success {
+    &.@{ant-prefix}-input-has-feedback {
+      padding-right: @padding-lg + @padding-xss;
+    }
+  }
+}
+
+.@{ant-prefix}-input-textarea-show-count {
+  position: relative;
+  display: block;
+}
+
+.input() {
+  &-stepperless[type='number'] {
+    /* stylelint-disable-next-line property-no-vendor-prefix */
+    -moz-appearance: textfield;
+
+    &::-webkit-inner-spin-button,
+    ::-webkit-outer-spin-button {
+      margin: 0;
+      /* stylelint-disable-next-line property-no-vendor-prefix */
+      -webkit-appearance: none;
+    }
+  }
+}
+
+.@{ant-prefix}-otp-input {
+  width: auto;
+}

node_modules/ng-zorro-antd/input/style/rtl.less

@@ -0,0 +1,210 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+//== Style for input-group: input with label, with button or dropdown...
+.@{ant-prefix}-input-group {
+  &-wrapper {
+    &-rtl {
+      direction: rtl;
+    }
+  }
+
+  &-rtl {
+    direction: rtl;
+  }
+}
+
+// affix
+@input-affix-margin: 4px;
+
+.@{ant-prefix}-input {
+  &-affix-wrapper&-affix-wrapper-rtl {
+    > input.@{ant-prefix}-input {
+      border: none;
+      outline: none;
+    }
+  }
+
+  &-affix-wrapper-rtl {
+    .@{ant-prefix}-input-prefix {
+      margin: 0 0 0 @input-affix-margin;
+    }
+
+    .@{ant-prefix}-input-suffix {
+      margin: 0 @input-affix-margin 0 0;
+    }
+  }
+
+  &-textarea {
+    &-rtl {
+      direction: rtl;
+    }
+
+    &-rtl&-show-count::after {
+      text-align: left;
+    }
+  }
+}
+
+// allow-clear
+.@{ant-prefix}-input-clear-icon {
+  &-has-suffix {
+    .@{ant-prefix}-input-affix-wrapper-rtl & {
+      margin-right: 0;
+      margin-left: @input-affix-margin;
+    }
+  }
+
+  .@{ant-prefix}-input-affix-wrapper-rtl & {
+    right: auto;
+    left: 8px;
+  }
+}
+
+// mixin
+@input-rtl-cls: ~'@{ant-prefix}-input-rtl';
+
+.active() {
+  .@{input-rtl-cls} & {
+    border-right-width: 0;
+    border-left-width: @border-width-base !important;
+  }
+}
+
+.hover() {
+  .@{input-rtl-cls} & {
+    border-right-width: 0;
+    border-left-width: @border-width-base !important;
+  }
+}
+
+.input() {
+  &-rtl {
+    direction: rtl;
+  }
+}
+
+// label input
+.input-group(@inputClass) {
+  > .@{inputClass}-rtl:first-child,
+  &-rtl &-addon:first-child {
+    border-radius: 0 @border-radius-base @border-radius-base 0;
+  }
+
+  &-addon:first-child {
+    .@{inputClass}-group-rtl & {
+      border-right: @border-width-base @border-style-base @input-border-color;
+      border-left: 0;
+    }
+  }
+
+  &-addon:last-child {
+    .@{inputClass}-group-rtl & {
+      border-right: 0;
+      border-left: @border-width-base @border-style-base @input-border-color;
+      border-radius: @border-radius-base 0 0 @border-radius-base;
+    }
+  }
+
+  > .@{inputClass}:last-child,
+  &-addon:last-child {
+    .@{inputClass}-group-rtl& {
+      border-radius: @border-radius-base 0 0 @border-radius-base;
+    }
+  }
+
+  .@{inputClass}-affix-wrapper {
+    &:not(:first-child) {
+      .@{inputClass}-group-rtl& {
+        border-radius: @border-radius-base 0 0 @border-radius-base;
+      }
+    }
+
+    &:not(:last-child) {
+      .@{inputClass}-group-rtl& {
+        border-radius: 0 @border-radius-base @border-radius-base 0;
+      }
+    }
+  }
+
+  &&-compact {
+    & > *:not(:last-child) {
+      .@{inputClass}-group-rtl& {
+        margin-right: 0;
+        margin-left: -@border-width-base;
+        border-left-width: @border-width-base;
+      }
+    }
+
+    & > *:first-child,
+    & > .@{ant-prefix}-select:first-child > .@{ant-prefix}-select-selector,
+    & > .@{ant-prefix}-select-auto-complete:first-child .@{ant-prefix}-input,
+    & > .@{ant-prefix}-cascader-picker:first-child .@{ant-prefix}-input {
+      .@{inputClass}-group-rtl& {
+        border-radius: 0 @border-radius-base @border-radius-base 0;
+      }
+    }
+
+    & > *:last-child,
+    & > .@{ant-prefix}-select:last-child > .@{ant-prefix}-select-selector,
+    & > .@{ant-prefix}-select-auto-complete:last-child .@{ant-prefix}-input,
+    & > .@{ant-prefix}-cascader-picker:last-child .@{ant-prefix}-input,
+    & > .@{ant-prefix}-cascader-picker-focused:last-child .@{ant-prefix}-input {
+      .@{inputClass}-group-rtl& {
+        border-left-width: @border-width-base;
+        border-radius: @border-radius-base 0 0 @border-radius-base;
+      }
+    }
+
+    .@{ant-prefix}-input-group-wrapper-rtl + .@{ant-prefix}-input-group-wrapper-rtl {
+      margin-right: -1px;
+      margin-left: 0;
+    }
+
+    .@{ant-prefix}-input-group-wrapper-rtl:not(:last-child) {
+      &.@{ant-prefix}-input-search > .@{ant-prefix}-input-group {
+        & > .@{ant-prefix}-input {
+          border-radius: 0 @border-radius-base @border-radius-base 0;
+        }
+      }
+    }
+  }
+}
+
+// search-input
+@search-prefix: ~'@{ant-prefix}-input-search';
+@search-rtl-cls: ~'@{search-prefix}-rtl';
+
+.@{search-prefix}-rtl {
+  direction: rtl;
+
+  .@{ant-prefix}-input {
+    &:hover,
+    &:focus {
+      + .@{ant-prefix}-input-group-addon .@{search-prefix}-button:not(.@{ant-prefix}-btn-primary) {
+        border-left-color: @border-color-base;
+
+        &:hover {
+          border-left-color: @input-hover-border-color;
+        }
+      }
+    }
+  }
+
+  > .@{ant-prefix}-input-group {
+    > .@{ant-prefix}-input-affix-wrapper {
+      &:hover,
+      &-focused {
+        border-right-color: @input-hover-border-color;
+      }
+    }
+
+    > .@{ant-prefix}-input-group-addon:last-child {
+      right: -1px;
+      left: auto;
+      .@{search-prefix}-button {
+        border-radius: @border-radius-base 0 0 @border-radius-base;
+      }
+    }
+  }
+}

node_modules/ng-zorro-antd/input/style/search-input.less

@@ -0,0 +1,117 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import '../../button/style/mixin';
+@import './mixin';
+
+@search-prefix: ~'@{ant-prefix}-input-search';
+
+.@{search-prefix} {
+  .@{ant-prefix}-input {
+    &:hover,
+    &:focus {
+      border-color: @input-hover-border-color;
+
+      + .@{ant-prefix}-input-group-addon .@{search-prefix}-button:not(.@{ant-prefix}-btn-primary) {
+        border-left-color: @input-hover-border-color;
+      }
+    }
+  }
+
+  .@{ant-prefix}-input-affix-wrapper {
+    border-radius: 0;
+  }
+
+  // fix slight height diff in Firefox:
+  // https://ant.design/components/auto-complete-cn/#components-auto-complete-demo-certain-category
+  .@{ant-prefix}-input-lg {
+    line-height: @line-height-base - 0.0002;
+  }
+
+  > .@{ant-prefix}-input-group {
+    > .@{ant-prefix}-input-group-addon:last-child {
+      left: -1px;
+      padding: 0;
+      border: 0;
+
+      .@{search-prefix}-button {
+        padding-top: 0;
+        padding-bottom: 0;
+        border-radius: 0 @border-radius-base @border-radius-base 0;
+      }
+
+      .@{search-prefix}-button:not(.@{ant-prefix}-btn-primary) {
+        color: @text-color-secondary;
+
+        &.@{ant-prefix}-btn-loading::before {
+          top: 0;
+          right: 0;
+          bottom: 0;
+          left: 0;
+        }
+      }
+    }
+  }
+
+  &-button {
+    height: @input-height-base;
+
+    &:hover,
+    &:focus {
+      z-index: 1;
+    }
+  }
+
+  &-large &-button {
+    height: @input-height-lg;
+  }
+
+  &-small &-button {
+    height: @input-height-sm;
+  }
+
+  // ===================== Compact Item Customized Styles =====================
+  &.@{input-prefix-cls}-compact-item {
+    &:not(.@{input-prefix-cls}-compact-item-rtl) {
+      &:not(.@{input-prefix-cls}-compact-last-item) {
+        .@{input-prefix-cls}-group-addon {
+          .@{input-prefix-cls}-search-button {
+            margin-right: -@border-width-base;
+            border-radius: 0;
+          }
+        }
+      }
+    }
+
+    &:not(.@{input-prefix-cls}-compact-first-item) {
+      .@{input-prefix-cls},
+      .@{input-prefix-cls}-affix-wrapper {
+        border-radius: 0;
+      }
+    }
+
+    > .@{input-prefix-cls}-group-addon .@{input-prefix-cls}-search-button,
+    > .@{input-prefix-cls},
+    .@{input-prefix-cls}-affix-wrapper {
+      &:hover,
+      &:focus,
+      &:active {
+        z-index: 2;
+      }
+    }
+
+    > .@{input-prefix-cls}-affix-wrapper-focused {
+      z-index: 2;
+    }
+  }
+  // ===================== For RTL Compact Item Customized Styles =====================
+  &.@{input-prefix-cls}-compact-item-rtl {
+    &:not(.@{input-prefix-cls}-compact-last-item) {
+      .@{input-prefix-cls}-group-addon:last-child {
+        .@{input-prefix-cls}-search-button {
+          margin-left: -@border-width-base;
+          border-radius: 0;
+        }
+      }
+    }
+  }
+}

node_modules/ng-zorro-antd/input/style/status.less

@@ -0,0 +1,42 @@
+@import './mixin';
+
+@input-prefix-cls: ~'@{ant-prefix}-input';
+
+@input-wrapper-cls: @input-prefix-cls, ~'@{input-prefix-cls}-affix-wrapper';
+
+each(@input-wrapper-cls, {
+  .@{value} {
+    &-status-error {
+      .status-color(@value, @error-color, @error-color, @input-bg, @error-color-hover, @error-color-outline);
+      .status-color-common(@input-prefix-cls, @error-color, @error-color, @input-bg, @error-color-hover, @error-color-outline);
+    }
+
+    &-status-warning {
+      .status-color(@value, @warning-color, @warning-color, @input-bg, @warning-color-hover, @warning-color-outline);
+      .status-color-common(@input-prefix-cls, @warning-color, @warning-color, @input-bg, @warning-color-hover, @warning-color-outline);
+    }
+  }
+});
+
+.@{input-prefix-cls}-textarea {
+  &-status-error,
+  &-status-warning,
+  &-status-success,
+  &-status-validating {
+    &.@{input-prefix-cls}-textarea-has-feedback {
+      .@{input-prefix-cls} {
+        padding-right: 24px;
+      }
+    }
+  }
+}
+
+.@{input-prefix-cls}-group-wrapper {
+  &-status-error {
+    .group-status-color(@input-prefix-cls, @error-color, @error-color);
+  }
+
+  &-status-warning {
+    .group-status-color(@input-prefix-cls, @warning-color, @warning-color);
+  }
+}