init

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

@@ -0,0 +1,474 @@
+import { Direction } from '@angular/cdk/bidi';
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter, Type, ViewContainerRef, ChangeDetectorRef, NgZone, ElementRef, Renderer2, DestroyRef, ComponentRef, EmbeddedViewRef, OnDestroy, InjectionToken, OnChanges, SimpleChanges, OnInit } from '@angular/core';
+import { NzButtonType, NzButtonShape, NzButtonSize } from 'ng-zorro-antd/button';
+import { NzSafeAny } from 'ng-zorro-antd/core/types';
+import { Observable, Subject } from 'rxjs';
+import * as i1 from '@angular/cdk/overlay';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { AnimationEvent, AnimationTriggerMetadata } from '@angular/animations';
+import { FocusTrapFactory } from '@angular/cdk/a11y';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { NzConfigService, NzConfigKey } from 'ng-zorro-antd/core/config';
+import { NzModalI18nInterface } from 'ng-zorro-antd/i18n';
+
+/**
+ * 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
+ */
+
+type OnClickCallback<T> = (instance: T) => (false | void | {}) | Promise<false | void | {}>;
+type ModalTypes = 'default' | 'confirm';
+type ConfirmType = 'confirm' | 'info' | 'success' | 'error' | 'warning';
+interface StyleObjectLike {
+    [key: string]: string;
+}
+declare class ModalOptions<T = NzSafeAny, D = NzSafeAny, R = NzSafeAny> {
+    nzCentered?: boolean;
+    nzClosable?: boolean;
+    nzOkLoading?: boolean;
+    nzOkDisabled?: boolean;
+    nzCancelDisabled?: boolean;
+    nzCancelLoading?: boolean;
+    nzDraggable?: boolean;
+    nzNoAnimation?: boolean;
+    nzAutofocus?: 'ok' | 'cancel' | 'auto' | null;
+    nzMask?: boolean;
+    nzMaskClosable?: boolean;
+    nzKeyboard?: boolean;
+    nzZIndex?: number;
+    nzWidth?: number | string;
+    nzCloseIcon?: string | TemplateRef<void>;
+    nzOkType?: NzButtonType;
+    nzOkDanger?: boolean;
+    nzModalType?: ModalTypes;
+    nzOnCancel?: EventEmitter<T> | OnClickCallback<T>;
+    nzOnOk?: EventEmitter<T> | OnClickCallback<T>;
+    nzData?: D;
+    nzMaskStyle?: StyleObjectLike;
+    nzBodyStyle?: StyleObjectLike;
+    nzWrapClassName?: string;
+    nzClassName?: string;
+    nzStyle?: object;
+    nzTitle?: string | TemplateRef<{}>;
+    nzFooter?: string | TemplateRef<{}> | Array<ModalButtonOptions<T>> | null;
+    nzCancelText?: string | null;
+    nzOkText?: string | null;
+    nzContent?: string | TemplateRef<NzSafeAny> | Type<T>;
+    nzCloseOnNavigation?: boolean;
+    nzViewContainerRef?: ViewContainerRef;
+    nzAfterOpen?: EventEmitter<void>;
+    nzAfterClose?: EventEmitter<R>;
+    nzIconType?: string;
+    nzDirection?: Direction;
+}
+interface ModalButtonOptions<T = NzSafeAny> {
+    label: string;
+    type?: NzButtonType;
+    danger?: boolean;
+    shape?: NzButtonShape;
+    ghost?: boolean;
+    size?: NzButtonSize;
+    autoLoading?: boolean;
+    show?: boolean | ((this: ModalButtonOptions<T>, contentComponentInstance?: T) => boolean);
+    loading?: boolean | ((this: ModalButtonOptions<T>, contentComponentInstance?: T) => boolean);
+    disabled?: boolean | ((this: ModalButtonOptions<T>, contentComponentInstance?: T) => boolean);
+    onClick?(this: ModalButtonOptions<T>, contentComponentInstance?: T): NzSafeAny | Promise<NzSafeAny>;
+    [key: string]: NzSafeAny;
+}
+
+/**
+ * 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 function throwNzModalContentAlreadyAttachedError(): never;
+declare class BaseModalContainerComponent extends BasePortalOutlet {
+    readonly document: Document;
+    readonly cdr: ChangeDetectorRef;
+    readonly config: ModalOptions;
+    protected ngZone: NgZone;
+    protected host: ElementRef<HTMLElement>;
+    protected focusTrapFactory: FocusTrapFactory;
+    protected render: Renderer2;
+    protected overlayRef: OverlayRef;
+    protected nzConfigService: NzConfigService;
+    protected animationType: "NoopAnimations" | "BrowserAnimations" | null;
+    protected destroyRef: DestroyRef;
+    portalOutlet: CdkPortalOutlet;
+    modalElementRef: ElementRef<HTMLDivElement>;
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    containerClick: EventEmitter<void>;
+    cancelTriggered: EventEmitter<void>;
+    okTriggered: EventEmitter<void>;
+    state: 'void' | 'enter' | 'exit';
+    modalRef: NzModalRef;
+    isStringContent: boolean;
+    dir: Direction;
+    private elementFocusedBeforeModalWasOpened;
+    private focusTrap;
+    private mouseDown;
+    private oldMaskStyle;
+    get showMask(): boolean;
+    get maskClosable(): boolean;
+    constructor();
+    onContainerClick(e: MouseEvent): void;
+    onCloseClick(): void;
+    onOkClick(): void;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    attachStringContent(): void;
+    getNativeElement(): HTMLElement;
+    private animationDisabled;
+    private setModalTransformOrigin;
+    private savePreviouslyFocusedElement;
+    private trapFocus;
+    private restoreFocus;
+    private setEnterAnimationClass;
+    private setExitAnimationClass;
+    private setMaskExitAnimationClass;
+    private cleanAnimationClass;
+    private setZIndexForBackdrop;
+    bindBackdropStyle(): void;
+    updateMaskClassname(): void;
+    onAnimationDone(event: AnimationEvent): void;
+    onAnimationStart(event: AnimationEvent): void;
+    startExitAnimation(): void;
+    protected setupMouseListeners(modalContainer: ElementRef<HTMLElement>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseModalContainerComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseModalContainerComponent, never, 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
+ */
+
+declare abstract class NzModalLegacyAPI<T, R> {
+    abstract afterOpen: Observable<void>;
+    abstract afterClose: Observable<R | undefined>;
+    abstract close(result?: R): void;
+    abstract destroy(result?: R): void;
+    /**
+     * Trigger the nzOnOk/nzOnCancel by manual
+     */
+    abstract triggerOk(): void;
+    abstract triggerCancel(): void;
+    /**
+     * Return the component instance of nzContent when specify nzContent as a Component
+     */
+    abstract getContentComponent(): T | void;
+    /**
+     * Get the dom element of this Modal
+     */
+    abstract getElement(): HTMLElement | void;
+}
+
+/**
+ * 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 NzModalState: {
+    readonly OPEN: 0;
+    readonly CLOSING: 1;
+    readonly CLOSED: 2;
+};
+type NzModalState = (typeof NzModalState)[keyof typeof NzModalState];
+declare const NzTriggerAction: {
+    readonly CANCEL: "cancel";
+    readonly OK: "ok";
+};
+type NzTriggerAction = (typeof NzTriggerAction)[keyof typeof NzTriggerAction];
+declare class NzModalRef<T = NzSafeAny, R = NzSafeAny> implements NzModalLegacyAPI<T, R> {
+    private overlayRef;
+    private config;
+    containerInstance: BaseModalContainerComponent;
+    componentInstance: T | null;
+    componentRef: ComponentRef<T> | null;
+    result?: R;
+    state: NzModalState;
+    afterClose: Subject<R | undefined>;
+    afterOpen: Subject<void>;
+    private closeTimeout?;
+    private destroy$;
+    constructor(overlayRef: OverlayRef, config: ModalOptions, containerInstance: BaseModalContainerComponent);
+    getContentComponent(): T;
+    getContentComponentRef(): Readonly<ComponentRef<T> | null>;
+    getElement(): HTMLElement;
+    destroy(result?: R): void;
+    triggerOk(): Promise<void>;
+    triggerCancel(): Promise<void>;
+    close(result?: R): void;
+    updateConfig(config: ModalOptions): void;
+    getState(): NzModalState;
+    getConfig(): ModalOptions;
+    getBackdropElement(): HTMLElement | null;
+    private trigger;
+    private closeWhitResult;
+    _finishDialogClose(): void;
+}
+
+declare class NzModalService implements OnDestroy {
+    private injector;
+    private nzConfigService;
+    private directionality;
+    private parentModal;
+    private openModalsAtThisLevel;
+    private readonly afterAllClosedAtThisLevel;
+    get openModals(): NzModalRef[];
+    get _afterAllClosed(): Subject<void>;
+    readonly afterAllClose: Observable<void>;
+    create<T, D = NzSafeAny, R = NzSafeAny>(config: ModalOptions<T, D, R>): NzModalRef<T, R>;
+    closeAll(): void;
+    confirm<T>(options?: ModalOptions<T>, confirmType?: ConfirmType): NzModalRef<T>;
+    info<T>(options?: ModalOptions<T>): NzModalRef<T>;
+    success<T>(options?: ModalOptions<T>): NzModalRef<T>;
+    error<T>(options?: ModalOptions<T>): NzModalRef<T>;
+    warning<T>(options?: ModalOptions<T>): NzModalRef<T>;
+    private open;
+    private removeOpenModal;
+    private closeModals;
+    private createOverlay;
+    private attachModalContainer;
+    private attachModalContent;
+    private createInjector;
+    private confirmFactory;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NzModalService>;
+}
+
+/**
+ * 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 ZOOM_CLASS_NAME_MAP: {
+    enter: string;
+    enterActive: string;
+    leave: string;
+    leaveActive: string;
+};
+declare const FADE_CLASS_NAME_MAP: {
+    enter: string;
+    enterActive: string;
+    leave: string;
+    leaveActive: string;
+};
+declare const MODAL_MASK_CLASS_NAME = "ant-modal-mask";
+declare const NZ_CONFIG_MODULE_NAME: NzConfigKey;
+declare const NZ_MODAL_DATA: InjectionToken<any>;
+
+/**
+ * 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 NzModalComponent<T extends ModalOptions = NzSafeAny, R = NzSafeAny> implements OnChanges, NzModalLegacyAPI<T, R> {
+    private cdr;
+    private modal;
+    private viewContainerRef;
+    private destroyRef;
+    nzMask?: boolean;
+    nzMaskClosable?: boolean;
+    nzCloseOnNavigation?: boolean;
+    nzVisible: boolean;
+    nzClosable: boolean;
+    nzOkLoading: boolean;
+    nzOkDisabled: boolean;
+    nzCancelDisabled: boolean;
+    nzCancelLoading: boolean;
+    nzKeyboard: boolean;
+    nzNoAnimation: boolean;
+    nzCentered: boolean;
+    nzDraggable: boolean;
+    nzContent?: string | TemplateRef<{}> | Type<T>;
+    nzFooter?: string | TemplateRef<{}> | Array<ModalButtonOptions<T>> | null;
+    nzZIndex: number;
+    nzWidth: number | string;
+    nzWrapClassName?: string;
+    nzClassName?: string;
+    nzStyle?: object;
+    nzTitle?: string | TemplateRef<{}>;
+    nzCloseIcon: string | TemplateRef<void>;
+    nzMaskStyle?: StyleObjectLike;
+    nzBodyStyle?: StyleObjectLike;
+    nzOkText?: string | null;
+    nzCancelText?: string | null;
+    nzOkType: NzButtonType;
+    nzOkDanger: boolean;
+    nzIconType: string;
+    nzModalType: ModalTypes;
+    nzAutofocus: 'ok' | 'cancel' | 'auto' | null;
+    readonly nzOnOk: EventEmitter<T> | OnClickCallback<T> | NzSafeAny;
+    readonly nzOnCancel: EventEmitter<T> | OnClickCallback<T> | NzSafeAny;
+    readonly nzAfterOpen: EventEmitter<void>;
+    readonly nzAfterClose: EventEmitter<R>;
+    readonly nzVisibleChange: EventEmitter<boolean>;
+    set modalTitle(value: TemplateRef<NzSafeAny>);
+    contentFromContentChild: TemplateRef<NzSafeAny>;
+    set modalFooter(value: TemplateRef<NzSafeAny>);
+    private modalRef;
+    get afterOpen(): Observable<void>;
+    get afterClose(): Observable<R>;
+    constructor();
+    open(): void;
+    close(result?: R): void;
+    destroy(result?: R): void;
+    triggerOk(): void;
+    triggerCancel(): void;
+    getContentComponent(): T | void;
+    getElement(): HTMLElement | void;
+    getModalRef(): NzModalRef | null;
+    private setTitleWithTemplate;
+    private setFooterWithTemplate;
+    private getConfig;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalComponent<any, any>, "nz-modal", ["nzModal"], { "nzMask": { "alias": "nzMask"; "required": false; }; "nzMaskClosable": { "alias": "nzMaskClosable"; "required": false; }; "nzCloseOnNavigation": { "alias": "nzCloseOnNavigation"; "required": false; }; "nzVisible": { "alias": "nzVisible"; "required": false; }; "nzClosable": { "alias": "nzClosable"; "required": false; }; "nzOkLoading": { "alias": "nzOkLoading"; "required": false; }; "nzOkDisabled": { "alias": "nzOkDisabled"; "required": false; }; "nzCancelDisabled": { "alias": "nzCancelDisabled"; "required": false; }; "nzCancelLoading": { "alias": "nzCancelLoading"; "required": false; }; "nzKeyboard": { "alias": "nzKeyboard"; "required": false; }; "nzNoAnimation": { "alias": "nzNoAnimation"; "required": false; }; "nzCentered": { "alias": "nzCentered"; "required": false; }; "nzDraggable": { "alias": "nzDraggable"; "required": false; }; "nzContent": { "alias": "nzContent"; "required": false; }; "nzFooter": { "alias": "nzFooter"; "required": false; }; "nzZIndex": { "alias": "nzZIndex"; "required": false; }; "nzWidth": { "alias": "nzWidth"; "required": false; }; "nzWrapClassName": { "alias": "nzWrapClassName"; "required": false; }; "nzClassName": { "alias": "nzClassName"; "required": false; }; "nzStyle": { "alias": "nzStyle"; "required": false; }; "nzTitle": { "alias": "nzTitle"; "required": false; }; "nzCloseIcon": { "alias": "nzCloseIcon"; "required": false; }; "nzMaskStyle": { "alias": "nzMaskStyle"; "required": false; }; "nzBodyStyle": { "alias": "nzBodyStyle"; "required": false; }; "nzOkText": { "alias": "nzOkText"; "required": false; }; "nzCancelText": { "alias": "nzCancelText"; "required": false; }; "nzOkType": { "alias": "nzOkType"; "required": false; }; "nzOkDanger": { "alias": "nzOkDanger"; "required": false; }; "nzIconType": { "alias": "nzIconType"; "required": false; }; "nzModalType": { "alias": "nzModalType"; "required": false; }; "nzAutofocus": { "alias": "nzAutofocus"; "required": false; }; "nzOnOk": { "alias": "nzOnOk"; "required": false; }; "nzOnCancel": { "alias": "nzOnCancel"; "required": false; }; }, { "nzOnOk": "nzOnOk"; "nzOnCancel": "nzOnCancel"; "nzAfterOpen": "nzAfterOpen"; "nzAfterClose": "nzAfterClose"; "nzVisibleChange": "nzVisibleChange"; }, ["modalTitle", "contentFromContentChild", "modalFooter"], never, true, never>;
+    static ngAcceptInputType_nzMask: unknown;
+    static ngAcceptInputType_nzMaskClosable: unknown;
+    static ngAcceptInputType_nzCloseOnNavigation: unknown;
+    static ngAcceptInputType_nzVisible: unknown;
+    static ngAcceptInputType_nzClosable: unknown;
+    static ngAcceptInputType_nzOkLoading: unknown;
+    static ngAcceptInputType_nzOkDisabled: unknown;
+    static ngAcceptInputType_nzCancelDisabled: unknown;
+    static ngAcceptInputType_nzCancelLoading: unknown;
+    static ngAcceptInputType_nzKeyboard: unknown;
+    static ngAcceptInputType_nzNoAnimation: unknown;
+    static ngAcceptInputType_nzCentered: unknown;
+    static ngAcceptInputType_nzDraggable: unknown;
+    static ngAcceptInputType_nzZIndex: unknown;
+    static ngAcceptInputType_nzOkDanger: unknown;
+}
+
+/**
+ * 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 NzModalTitleDirective {
+    readonly templateRef: TemplateRef<{}>;
+    private nzModalRef;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzModalTitleDirective, "[nzModalTitle]", ["nzModalTitle"], {}, {}, 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
+ */
+
+declare class NzModalFooterDirective {
+    readonly templateRef: TemplateRef<{}>;
+    private nzModalRef;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzModalFooterDirective, "[nzModalFooter]", ["nzModalFooter"], {}, {}, 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
+ */
+
+declare class NzModalContentDirective {
+    readonly templateRef: TemplateRef<{}>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NzModalContentDirective, "[nzModalContent]", ["nzModalContent"], {}, {}, never, never, true, never>;
+}
+
+declare class NzModalCloseComponent {
+    readonly config: ModalOptions<any, any, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalCloseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalCloseComponent, "button[nz-modal-close]", ["nzModalCloseBuiltin"], {}, {}, 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
+ */
+
+declare class NzModalFooterComponent {
+    private i18n;
+    readonly config: ModalOptions<any, any, any>;
+    buttonsFooter: boolean;
+    buttons: ModalButtonOptions[];
+    locale: NzModalI18nInterface;
+    readonly cancelTriggered: EventEmitter<void>;
+    readonly okTriggered: EventEmitter<void>;
+    modalRef: NzModalRef;
+    constructor();
+    onCancel(): void;
+    onOk(): void;
+    /**
+     * Returns the value of the specified key.
+     * If it is a function, run and return the return value of the function.
+     */
+    getButtonCallableProp(options: ModalButtonOptions, prop: keyof ModalButtonOptions): boolean;
+    /**
+     * Run function based on the type and set its `loading` prop if needed.
+     */
+    onButtonClick(options: ModalButtonOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalFooterComponent, "div[nz-modal-footer]", ["nzModalFooterBuiltin"], { "modalRef": { "alias": "modalRef"; "required": false; }; }, { "cancelTriggered": "cancelTriggered"; "okTriggered": "okTriggered"; }, never, never, true, never>;
+}
+
+declare class NzModalTitleComponent {
+    config: ModalOptions<any, any, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalTitleComponent, "div[nz-modal-title]", ["nzModalTitleBuiltin"], {}, {}, never, never, true, never>;
+}
+
+declare class NzModalContainerComponent extends BaseModalContainerComponent implements OnInit {
+    set _portalOutlet(portalOutlet: CdkPortalOutlet);
+    set _modalElementRef(elementRef: ElementRef<HTMLDivElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalContainerComponent, "nz-modal-container", ["nzModalContainer"], {}, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NzModalConfirmContainerComponent extends BaseModalContainerComponent implements OnInit {
+    private i18n;
+    set _portalOutlet(portalOutlet: CdkPortalOutlet);
+    set _modalElementRef(elementRef: ElementRef<HTMLDivElement>);
+    readonly cancelTriggered: EventEmitter<void>;
+    readonly okTriggered: EventEmitter<void>;
+    locale: NzModalI18nInterface;
+    constructor();
+    ngOnInit(): void;
+    onCancel(): void;
+    onOk(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalConfirmContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NzModalConfirmContainerComponent, "nz-modal-confirm-container", ["nzModalConfirmContainer"], {}, { "cancelTriggered": "cancelTriggered"; "okTriggered": "okTriggered"; }, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+
+declare class NzModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NzModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NzModalModule, never, [typeof NzModalComponent, typeof NzModalFooterDirective, typeof NzModalContentDirective, typeof NzModalCloseComponent, typeof NzModalFooterComponent, typeof NzModalTitleComponent, typeof NzModalTitleDirective, typeof NzModalContainerComponent, typeof NzModalConfirmContainerComponent], [typeof NzModalComponent, typeof NzModalFooterDirective, typeof NzModalContentDirective, typeof NzModalTitleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NzModalModule>;
+}
+
+/**
+ * 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 nzModalAnimations: {
+    readonly modalContainer: AnimationTriggerMetadata;
+};
+
+/**
+ * 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 function applyConfigDefaults(config: ModalOptions, defaultOptions: ModalOptions): ModalOptions;
+declare function getValueWithConfig<T>(userValue: T | undefined, configValue: T | undefined, defaultValue: T): T | undefined;
+declare function getConfigFromComponent<T extends ModalOptions>(component: T): ModalOptions;
+
+export { BaseModalContainerComponent, FADE_CLASS_NAME_MAP, MODAL_MASK_CLASS_NAME, ModalOptions, NZ_CONFIG_MODULE_NAME, NZ_MODAL_DATA, NzModalCloseComponent, NzModalComponent, NzModalConfirmContainerComponent, NzModalContainerComponent, NzModalContentDirective, NzModalFooterComponent, NzModalFooterDirective, NzModalLegacyAPI, NzModalModule, NzModalRef, NzModalService, NzModalState, NzModalTitleComponent, NzModalTitleDirective, NzTriggerAction, ZOOM_CLASS_NAME_MAP, applyConfigDefaults, getConfigFromComponent, getValueWithConfig, nzModalAnimations, throwNzModalContentAlreadyAttachedError };
+export type { ConfirmType, ModalButtonOptions, ModalTypes, OnClickCallback, StyleObjectLike };

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

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

node_modules/ng-zorro-antd/modal/style/confirm.less

@@ -0,0 +1,79 @@
+@import '../../style/mixins/index';
+
+@confirm-prefix-cls: ~'@{ant-prefix}-modal-confirm';
+
+.@{confirm-prefix-cls} {
+  .@{ant-prefix}-modal-header {
+    display: none;
+  }
+
+  .@{ant-prefix}-modal-body {
+    padding: @modal-confirm-body-padding;
+  }
+
+  &-body-wrapper {
+    .clearfix();
+  }
+
+  &-body {
+    .@{confirm-prefix-cls}-title {
+      display: block;
+      // create BFC to avoid
+      // https://user-images.githubusercontent.com/507615/37702510-ba844e06-2d2d-11e8-9b67-8e19be57f445.png
+      overflow: hidden;
+      color: @heading-color;
+      font-weight: 500;
+      font-size: @modal-confirm-title-font-size;
+      line-height: 1.4;
+    }
+
+    .@{confirm-prefix-cls}-content {
+      margin-top: 8px;
+      color: @text-color;
+      font-size: @font-size-base;
+    }
+
+    > .@{iconfont-css-prefix} {
+      float: left;
+      margin-right: 16px;
+      font-size: 22px;
+
+      // `content` after `icon` should set marginLeft
+      + .@{confirm-prefix-cls}-title + .@{confirm-prefix-cls}-content {
+        margin-left: 38px;
+      }
+    }
+  }
+
+  .@{confirm-prefix-cls}-btns {
+    margin-top: 24px;
+    text-align: right;
+
+    .@{ant-prefix}-btn + .@{ant-prefix}-btn {
+      margin-bottom: 0;
+      margin-left: 8px;
+    }
+  }
+
+  &-error &-body > .@{iconfont-css-prefix} {
+    color: @error-color;
+  }
+
+  &-warning &-body > .@{iconfont-css-prefix},
+  &-confirm &-body > .@{iconfont-css-prefix} {
+    color: @warning-color;
+  }
+
+  &-info &-body > .@{iconfont-css-prefix} {
+    color: @info-color;
+  }
+
+  &-success &-body > .@{iconfont-css-prefix} {
+    color: @success-color;
+  }
+
+  // https://github.com/ant-design/ant-design/issues/37329
+  .@{ant-prefix}-zoom-leave .@{confirm-prefix-cls}-btns {
+    pointer-events: none;
+  }
+}

node_modules/ng-zorro-antd/modal/style/customize.less

@@ -0,0 +1,3 @@
+@import './index.less';
+
+.popover-customize-bg(@dialog-prefix-cls, @popover-background);

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

@@ -0,0 +1,3 @@
+@import './index.less';
+// style dependencies
+@import '../../button/style/entry.less';

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

@@ -0,0 +1,7 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+@import './modal';
+@import './confirm';
+@import './rtl';
+
+.popover-customize-bg(@dialog-prefix-cls, @popover-background);

node_modules/ng-zorro-antd/modal/style/modal.less

@@ -0,0 +1,136 @@
+@dialog-prefix-cls: ~'@{ant-prefix}-modal';
+
+.@{dialog-prefix-cls} {
+  .reset-component();
+  .modal-mask();
+
+  position: relative;
+  top: 100px;
+  width: auto;
+  max-width: calc(100vw - 32px);
+  margin: 0 auto;
+  padding-bottom: 24px;
+
+  &-wrap {
+    z-index: @zindex-modal;
+  }
+
+  &-title {
+    margin: 0;
+    color: @modal-heading-color;
+    font-weight: 500;
+    font-size: @modal-header-title-font-size;
+    line-height: @modal-header-title-line-height;
+    word-wrap: break-word;
+  }
+
+  &-content {
+    position: relative;
+    background-color: @modal-content-bg;
+    background-clip: padding-box;
+    border: 0;
+    border-radius: @modal-border-radius;
+    box-shadow: @shadow-2;
+    pointer-events: auto;
+  }
+
+  &-close {
+    position: absolute;
+    top: 0;
+    right: 0;
+    z-index: @zindex-popup-close;
+    padding: 0;
+    color: @modal-close-color;
+    font-weight: 700;
+    line-height: 1;
+    text-decoration: none;
+    background: transparent;
+    border: 0;
+    outline: 0;
+    cursor: pointer;
+    transition: color 0.3s;
+
+    &-x {
+      display: block;
+      width: @modal-header-close-size;
+      height: @modal-header-close-size;
+      font-size: @font-size-lg;
+      font-style: normal;
+      line-height: @modal-header-close-size;
+      text-align: center;
+      text-transform: none;
+      text-rendering: auto;
+    }
+
+    &:focus,
+    &:hover {
+      color: @icon-color-hover;
+      text-decoration: none;
+    }
+  }
+
+  &-header {
+    padding: @modal-header-padding;
+    color: @text-color;
+    background: @modal-header-bg;
+    border-bottom: @modal-header-border-width @modal-header-border-style
+      @modal-header-border-color-split;
+    border-radius: @modal-border-radius @modal-border-radius 0 0;
+  }
+
+  &-body {
+    padding: @modal-body-padding;
+    font-size: @font-size-base;
+    line-height: @line-height-base;
+    word-wrap: break-word;
+  }
+
+  &-footer {
+    padding: @modal-footer-padding-vertical @modal-footer-padding-horizontal;
+    text-align: right;
+    background: @modal-footer-bg;
+    border-top: @modal-footer-border-width @modal-footer-border-style
+      @modal-footer-border-color-split;
+    border-radius: 0 0 @modal-border-radius @modal-border-radius;
+
+    .@{ant-prefix}-btn + .@{ant-prefix}-btn:not(.@{ant-prefix}-dropdown-trigger) {
+      margin-bottom: 0;
+      margin-left: 8px;
+    }
+  }
+
+  &-open {
+    overflow: hidden;
+  }
+}
+
+.@{dialog-prefix-cls}-centered {
+  text-align: center;
+
+  &::before {
+    display: inline-block;
+    width: 0;
+    height: 100%;
+    vertical-align: middle;
+    content: '';
+  }
+  .@{dialog-prefix-cls} {
+    top: 0;
+    display: inline-block;
+    padding-bottom: 0;
+    text-align: left;
+    vertical-align: middle;
+  }
+}
+
+@media (max-width: @screen-sm-max) {
+  .@{dialog-prefix-cls} {
+    max-width: calc(100vw - 16px);
+    margin: 8px auto;
+  }
+  .@{dialog-prefix-cls}-centered {
+    .@{dialog-prefix-cls} {
+      flex: 1;
+    }
+  }
+}

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

@@ -0,0 +1,74 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@dialog-prefix-cls: ~'@{ant-prefix}-modal';
+@confirm-prefix-cls: ~'@{ant-prefix}-modal-confirm';
+@dialog-wrap-rtl-cls: ~'@{dialog-prefix-cls}-wrap-rtl';
+
+.@{dialog-prefix-cls} {
+  &-wrap {
+    &-rtl {
+      direction: rtl;
+    }
+  }
+
+  &-close {
+    .@{dialog-wrap-rtl-cls} & {
+      right: initial;
+      left: 0;
+    }
+  }
+
+  &-footer {
+    .@{dialog-wrap-rtl-cls} & {
+      text-align: left;
+    }
+    .@{ant-prefix}-btn + .@{ant-prefix}-btn {
+      .@{dialog-wrap-rtl-cls} & {
+        margin-right: 8px;
+        margin-left: 0;
+      }
+    }
+  }
+
+  &-confirm {
+    &-body {
+      .@{dialog-wrap-rtl-cls} & {
+        direction: rtl;
+      }
+      > .@{iconfont-css-prefix} {
+        .@{dialog-wrap-rtl-cls} & {
+          float: right;
+          margin-right: 0;
+          margin-left: 16px;
+        }
+        + .@{confirm-prefix-cls}-title + .@{confirm-prefix-cls}-content {
+          .@{dialog-wrap-rtl-cls} & {
+            margin-right: 38px;
+            margin-left: 0;
+          }
+        }
+      }
+    }
+
+    &-btns {
+      .@{dialog-wrap-rtl-cls} & {
+        text-align: left;
+      }
+      .@{ant-prefix}-btn + .@{ant-prefix}-btn {
+        .@{dialog-wrap-rtl-cls} & {
+          margin-right: 8px;
+          margin-left: 0;
+        }
+      }
+    }
+  }
+}
+
+.@{dialog-prefix-cls}-centered {
+  .@{dialog-prefix-cls} {
+    .@{dialog-wrap-rtl-cls}& {
+      text-align: right;
+    }
+  }
+}