ngx-tethys 19.1.13 → 20.0.0-next.0

package/core/index.d.ts

@@ -1,15 +1,680 @@
-export * from './behaviors';
-export * from './scroll-to.service';
-export * from './click-positioner';
-export * from './event-dispatchers/index';
-export * from './request-animation';
-export * from './scroll';
-export * from './animation';
-export * from './theme';
-export * from './overlay/index';
-export * from './update-host-class.service';
-export * from './translate';
-export * from './store';
-export * from './color';
-export * from './spacing';
-export * from './debounce-time';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, Signal, NgZone, ChangeDetectorRef, ViewContainerRef, ComponentRef, EventEmitter, EmbeddedViewRef, TemplateRef, Injector } from '@angular/core';
+import { Subject, Observable, Observer, BehaviorSubject, Subscription, SchedulerLike, MonoTypeOperatorFunction } from 'rxjs';
+import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y';
+export * from '@tethys/cdk/event';
+import { AnimationTriggerMetadata, AnimationEvent } from '@angular/animations';
+import { ConnectionPositionPair, OverlayRef, PositionStrategy, ComponentType, Overlay, ScrollStrategy, OverlayConfig } from '@angular/cdk/overlay';
+import { Platform } from '@angular/cdk/platform';
+import { SafeAny, Dictionary } from 'ngx-tethys/types';
+import { CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { Direction } from '@angular/cdk/bidi';
+import { FunctionProp } from 'ngx-tethys/util';
+
+type Constructor<T> = new (...args: any[]) => T;
+declare class AnonymousClass {
+}
+declare class MixinBase {
+}
+
+/**
+ * @deprecated Please use {transform: coerceBooleanProperty} in Input instead
+ */
+declare function InputBoolean(): PropertyDecorator;
+declare function InputCssPixel(): PropertyDecorator;
+/**
+ * @deprecated Please use {transform: numberAttribute} in Input instead
+ */
+declare function InputNumber(): PropertyDecorator;
+
+interface ThyCanDisable {
+    thyDisabled: boolean;
+}
+type ThyCanDisableCtor = Constructor<ThyCanDisable>;
+/** Mixin to augment a directive with a `disable` property. */
+declare function mixinDisabled<T extends Constructor<{}>>(base: T): ThyCanDisableCtor & T;
+
+interface ThyInitialized extends OnInit {
+    initialized: boolean;
+}
+declare function mixinInitialized<T extends Constructor<{}>>(base: T): Constructor<ThyInitialized> & T;
+
+interface ThyLoadingDone {
+    loadingDone: boolean;
+}
+declare function mixinLoadingDone<T extends Constructor<{}>>(base: T): Constructor<ThyLoadingDone> & T;
+
+interface ThyHasTabIndex {
+    tabIndex: number;
+    defaultTabIndex: number;
+}
+type HasTabIndexCtor = Constructor<ThyHasTabIndex>;
+/** Mixin to augment a directive with a `tabIndex` property. */
+declare function mixinTabIndex<T extends Constructor<ThyCanDisable>>(base: T, defaultTabIndex?: number): HasTabIndexCtor & T;
+declare const TabIndexMixinBase: Constructor<ThyHasTabIndex> & Constructor<ThyCanDisable> & typeof MixinBase;
+
+interface ThyUnsubscribe extends OnDestroy {
+    ngUnsubscribe$: Subject<void>;
+}
+/**
+ * Mixin to augment a directive with a `disableRipple` property.
+ * @deprecated please use `takeUntilDestroyed`
+ */
+declare function mixinUnsubscribe<T extends Constructor<{}>>(base: T): Constructor<ThyUnsubscribe> & T;
+
+declare class AbstractControlValueAccessor<TValue = unknown> {
+    protected onChangeFn: (value: TValue) => void;
+    protected onTouchedFn: () => void;
+    private __onBlurValidation;
+    registerOnChange(fn: (value: TValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+}
+
+declare class HostFocusControl {
+    private ngUnsubscribe$;
+    private monitorElement;
+    elementRef: ElementRef<any>;
+    focusMonitor: FocusMonitor;
+    focusChanged: (origin: FocusOrigin) => void;
+    constructor(checkChildren?: boolean, element?: HTMLElement | ElementRef<HTMLElement>);
+    focusVia(element: HTMLElement | ElementRef<HTMLElement>, origin: FocusOrigin, options?: FocusOptions): void;
+    destroy(): void;
+}
+declare function useHostFocusControl(checkChildren?: boolean, element?: HTMLElement | ElementRef<HTMLElement>): HostFocusControl;
+
+declare const TabIndexDisabledControlValueAccessorMixin: Constructor<ThyHasTabIndex> & Constructor<ThyCanDisable> & typeof AbstractControlValueAccessor;
+
+declare class ScrollToService {
+    static _customScrollToElement(targetElement: HTMLElement, containerElement: HTMLElement): void;
+    static scrollToElement(targetElement: HTMLElement, containerElement: HTMLElement): void;
+}
+
+interface ThyClickPosition {
+    x: number;
+    y: number;
+}
+declare class ThyClickPositioner {
+    private clickDispatcher;
+    private lastPosition;
+    private initialized;
+    get lastClickPosition(): ThyClickPosition | null;
+    runTaskUseLastPosition(task: (position?: ThyClickPosition) => void): void;
+    initialize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThyClickPositioner, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThyClickPositioner>;
+}
+
+declare function cancelRequestAnimationFrame(id: number): any;
+declare const reqAnimFrame: typeof requestAnimationFrame;
+
+type EasyingFn = (t: number, b: number, c: number, d: number) => number;
+declare class ThyScrollService {
+    private ngZone;
+    private document;
+    constructor();
+    /** Set the position of the scroll bar of `element`. */
+    setScrollTop(element: Element | Window, topValue?: number): void;
+    /** Get the position of the scoll bar of `element`. */
+    getScroll(element?: Element | Window, top?: boolean): number;
+    /**
+     * Scroll `element` to some position with animation.
+     *
+     * @param container container, `window` by default
+     * @param topValue Scroll to `top`, 0 by default
+     * @param easing Transition curve, `easeInOutCubic` by default
+     * @param callback callback invoked when transition is done
+     */
+    scrollTo(container: Element | Window, topValue?: number, easing?: EasyingFn, callback?: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThyScrollService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThyScrollService>;
+}
+
+declare class AnimationDuration {
+    static SLOW: string;
+    static BASE: string;
+    static FAST: string;
+}
+declare class AnimationCurves {
+    static EASE_BASE_OUT: string;
+    static EASE_BASE_IN: string;
+    static EASE_OUT: string;
+    static EASE_IN: string;
+    static EASE_IN_OUT: string;
+    static EASE_OUT_BACK: string;
+    static EASE_IN_BACK: string;
+    static EASE_IN_OUT_BACK: string;
+    static EASE_OUT_CIRC: string;
+    static EASE_IN_CIRC: string;
+    static EASE_IN_OUT_CIRC: string;
+    static EASE_OUT_QUINT: string;
+    static EASE_IN_QUINT: string;
+    static EASE_IN_OUT_QUINT: string;
+    static EASE_IN_OUT_STANDARD: string;
+}
+
+declare const fadeMotion: AnimationTriggerMetadata;
+
+declare const collapseMotion: AnimationTriggerMetadata;
+
+interface ThumbAnimationProps {
+    transform: number;
+    width: number;
+}
+declare const thumbMotion: AnimationTriggerMetadata;
+
+declare const scaleXMotion: AnimationTriggerMetadata;
+declare const scaleYMotion: AnimationTriggerMetadata;
+declare const scaleMotion: AnimationTriggerMetadata;
+
+declare function injectPanelEmptyIcon(): Signal<string>;
+
+declare const enum ThyTheme {
+    light = "light",
+    dark = "dark",
+    system = "system"
+}
+
+declare class ThyThemeStore {
+    readonly theme: i0.WritableSignal<ThyTheme>;
+    readonly isDark: Signal<boolean>;
+    constructor();
+    setTheme(theme: ThyTheme): void;
+    normalizeColor(color: string | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThyThemeStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThyThemeStore>;
+}
+
+declare const POSITION_MAP: {
+    [key: string]: ConnectionPositionPair;
+};
+declare const EXPANDED_DROPDOWN_POSITIONS: ConnectionPositionPair[];
+
+type ThyPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom' | 'right' | 'rightTop' | 'rightBottom';
+interface ConnectedPositionOffset {
+    offsetY?: number;
+    offsetX?: number;
+}
+
+declare function buildConnectedPositionOffset(placement: ThyPlacement, offset: number): ConnectedPositionOffset;
+declare function buildConnectedPositionPair(placement: ThyPlacement, offset?: number, panelClassPrefix?: string): ConnectionPositionPair;
+declare function getFallbackPlacements(placement: ThyPlacement): ThyPlacement[];
+/**
+ * get flexible positions by placement, return placement position and it's fallback connection position
+ * @example
+ * getFlexiblePositions('top', 10, 'thy-overlay')
+ * [{topPosition}, {topLeftPosition}, {topRightPosition}, {bottomPosition}, {bottomLeftPosition}, {bottomRightPosition},]
+ * @returns [ConnectionPositionPair]
+ */
+declare function getFlexiblePositions(placement: ThyPlacement, offset?: number, panelClassPrefix?: string): ConnectionPositionPair[];
+declare function getPlacementByPosition(position: ConnectionPositionPair): string;
+
+type ThyOverlayTrigger = 'hover' | 'focus' | 'click';
+declare abstract class ThyOverlayDirectiveBase {
+    protected elementRef: ElementRef;
+    private initialized;
+    /** Trigger Overlay */
+    protected _trigger: ThyOverlayTrigger;
+    get trigger(): ThyOverlayTrigger;
+    set trigger(value: ThyOverlayTrigger);
+    protected overlayRef: OverlayRef;
+    protected manualListeners: Map<string, EventListenerOrEventListenerObject>;
+    protected ngUnsubscribe$: Subject<void>;
+    protected focusMonitor: FocusMonitor;
+    protected platform: Platform;
+    protected ngZone: NgZone;
+    protected showDelay?: number;
+    protected hideDelay?: number;
+    protected touchendHideDelay?: number;
+    protected disabled: boolean;
+    protected showTimeoutId: number | null | SafeAny;
+    protected hideTimeoutId: number | null | SafeAny;
+    protected changeDetectorRef: ChangeDetectorRef;
+    protected isAutoCloseOnMobileTouch: boolean;
+    /**
+     * The overlay keep opened when the mouse moves to the overlay container
+     */
+    protected overlayPin: boolean;
+    /** create overlay, you can use popover service or overlay*/
+    abstract show(delay?: number): void;
+    abstract hide(delay?: number): void;
+    private clearEventListeners;
+    private clearTimer;
+    private touchStartTime;
+    private longPressTimeoutId;
+    private isTouchMoving;
+    constructor(elementRef: ElementRef, platform: Platform, focusMonitor: FocusMonitor, ngZone: NgZone, overlayPin?: boolean, changeDetectorRef?: ChangeDetectorRef);
+    initialize(): void;
+    private handleTouch;
+    /**
+     * Marks that the overlay needs to be checked in the next change detection run.
+     * Mainly used for rendering before positioning a overlay, which
+     * can be problematic in components with OnPush change detection.
+     */
+    markForCheck(): void;
+    dispose(): void;
+}
+
+interface ThyAbstractOverlayPosition {
+    /** Override for the overlay's top position. */
+    top?: string;
+    /** Override for the overlay's bottom position. */
+    bottom?: string;
+    /** Override for the overlay's left position. */
+    left?: string;
+    /** Override for the overlay's right position. */
+    right?: string;
+}
+declare class ThyAbstractOverlayConfig<TData = unknown> {
+    /**
+     * 当前的组件的 viewContainerRef，指定后弹出的组件的父注入器为当前组件的注入器
+     * @description.en-us Where the attached component should live in Angular's *logical* component tree.This affects what is available for injection and the change detection order for the component instantiated inside of the overlay. This does not affect where the overlay content will be rendered.
+     */
+    viewContainerRef?: ViewContainerRef;
+    /**
+     * 弹出框的唯一标识
+     * @description.en-us ID for the overlay. If omitted, a unique one will be generated.
+     */
+    id?: string;
+    /**
+     * overlay panel 类名
+     * @description.en-us Custom class for the overlay pane.
+     */
+    panelClass?: string | string[];
+    /** Custom class for the overlay component's host element. */
+    hostClass?: string | string[];
+    /**
+     * 是否有幕布
+     * @description.en-us Whether the overlay has a backdrop.
+     */
+    hasBackdrop?: boolean;
+    /**
+     * 自定义幕布的样式
+     * @description.en-us Custom class for the backdrop.
+     */
+    backdropClass?: string | string[];
+    /**
+     * @description 点击幕布或者按ESC键是否自动关闭弹出框，hasBackdrop=true 时该参数起作用
+     * @description.en-us Whether the user can use escape or clicking on the backdrop to close the overlay.
+     */
+    backdropClosable?: boolean;
+    /** Whether the user can use escape or clicking on the backdrop to close the overlay. */
+    disableClose?: boolean;
+    /**
+     * 自定义弹出框的宽度
+     * @default 660px
+     * @description.en-us Width of the overlay.
+     */
+    width?: string;
+    /**
+     * 自定义弹出框的高度
+     * @default 85vh
+     * @description.en-us Height of the overlay.
+     */
+    height?: string;
+    /**
+     * 弹出框最小宽度
+     * @description.en-us Min-width of the overlay. If a number is provided, pixel units are assumed.
+     */
+    minWidth?: number | string;
+    /**
+     * 弹出框最小高度
+     * @description.en-us Min-height of the overlay. If a number is provided, pixel units are assumed.
+     */
+    minHeight?: number | string;
+    /**
+     * 弹出框最大宽度
+     * @description.en-us Max-width of the overlay. If a number is provided, pixel units are assumed. Defaults to 80vw
+     */
+    maxWidth?: number | string;
+    /**
+     * 弹出框最大高度
+     * @default 85vh
+     * @description.en-us Max-height of the overlay. If a number is provided, pixel units are assumed.
+     */
+    maxHeight?: number | string;
+    /**
+     * 传入的初始化状态，弹出组件的变量会自动赋值，在 ngOnInit 生命周期钩子可以获取到，构造函数获取不到
+     * @description.en-us Data being injected into the child component.
+     */
+    initialState?: TData | null;
+    /** Layout direction for the overlay's content. */
+    direction?: Direction;
+    /** ID of the element that describes the overlay. */
+    ariaDescribedBy?: string | null;
+    /** Aria label to assign to the overlay element */
+    ariaLabel?: string | null;
+    /** Whether the overlay should focus the first focusable element on open. */
+    autoFocus?: boolean;
+    /**
+     * Whether the overlay should restore focus to the
+     * previously-focused element, after it's closed.
+     */
+    restoreFocus?: boolean;
+    /**
+     * Control the previously-focused element focusing process.
+     */
+    restoreFocusOptions?: FocusOptions;
+    /**
+     * 切换浏览器导航是否自动关闭弹出框
+     * @description.en-us Whether the overlay should close when the user goes backwards/forwards in history.Note that this usually doesn't include clicking on links (unless the user is using the `HashLocationStrategy`).
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * 关闭弹窗前的回调函数，返回 false 可阻止关闭弹窗
+     */
+    canClose?: (result?: unknown) => boolean;
+    /**
+     * 设置当提供的位置均不适合时是否可以将覆盖层推到屏幕上
+     * @description.en-us Sets whether the overlay can be pushed on-screen if none of the provided positions fit
+     * @default true
+     */
+    canPush?: boolean;
+    /**
+     * Projectable nodes of thy abstract overlay config, only for component
+     * @type Node[][]
+     */
+    projectableNodes?: Node[][];
+}
+interface ThyAbstractOverlayOptions {
+    /** component name, e.g. dialog | popover | slide */
+    name: string;
+    /** Whether enable animation */
+    animationEnabled: boolean;
+    /** Whether dispose cdk overlay ref when close upper overlay */
+    disposeWhenClose: boolean;
+}
+
+declare class ThyPortalOutlet extends CdkPortalOutlet {
+    /**
+     * Attach the given ComponentPortal to this PortalOutlet using the ComponentFactoryResolver.
+     *
+     * @param portal Portal to be attached to the portal outlet.
+     * @returns Reference to the created component.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThyPortalOutlet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ThyPortalOutlet, "[thyPortalOutlet]", ["thyPortalOutlet"], { "portal": { "alias": "thyPortalOutlet"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function throwPopoverContentAlreadyAttachedError(name: string): void;
+declare abstract class ThyAbstractOverlayContainer<TData = unknown> {
+    private options;
+    protected changeDetectorRef: ChangeDetectorRef;
+    id?: string;
+    animationState: string;
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    containerDestroy: Subject<void>;
+    abstract config: ThyAbstractOverlayConfig<TData>;
+    /**portal outlet */
+    abstract portalOutlet: ThyPortalOutlet;
+    /**
+     * Opening overlay animation done
+     */
+    abstract animationOpeningDone: Observable<AnimationEvent>;
+    /**
+     * Closing overlay animation done
+     */
+    abstract animationClosingDone: Observable<AnimationEvent>;
+    /** Before attach content(TemplatePortal or ComponentPortal) portal to portalOutlet*/
+    abstract beforeAttachPortal(): void;
+    /** Before detach content*/
+    beforeDetachPortal(): void;
+    constructor(options: ThyAbstractOverlayOptions, changeDetectorRef: ChangeDetectorRef);
+    /**
+     * Attach a TemplatePortal as content to this overlay container.
+     * @param portal Portal to be attached as the overlay content.
+     */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    /**
+     * Attach a ComponentPortal as content to this overlay container.
+     * @param portal Portal to be attached as the overlay content.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    startExitAnimation(): void;
+    destroy(): void;
+}
+
+declare abstract class ThyAbstractOverlayRef<TComponent = unknown, TContainer extends ThyAbstractOverlayContainer = ThyAbstractOverlayContainer, TResult = unknown> {
+    id: string;
+    componentInstance: TComponent;
+    backdropClosable: boolean;
+    disableClose: boolean;
+    containerInstance: TContainer;
+    /**
+     * 获取 OverlayRef
+     */
+    abstract getOverlayRef(): OverlayRef;
+    /**
+     * 关闭当前模态框，若force为true，则canClose无效，强制关闭
+     * @param dialogResult
+     * @param force
+     */
+    abstract close(dialogResult?: TResult, force?: boolean): void;
+    /**
+     * 模态框打开后的回调
+     */
+    abstract afterOpened(): Observable<void>;
+    /**
+     * 模态框关闭后的回调
+     */
+    abstract afterClosed(): Observable<TResult | undefined>;
+    /**
+     * 模态框关闭前的回调
+     */
+    abstract beforeClosed(): Observable<TResult | undefined>;
+    abstract keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * 点击模态框遮罩层的回调
+     */
+    abstract backdropClick(): Observable<MouseEvent>;
+    /**
+     * 更新模态框的位置
+     * @param position
+     */
+    abstract updatePosition(position?: ThyAbstractOverlayPosition): this;
+    /**
+     * 模态框置顶
+     */
+    toTop?(): void;
+}
+declare abstract class ThyAbstractInternalOverlayRef<T, TContainer extends ThyAbstractOverlayContainer, TResult = undefined, TConfig extends ThyAbstractOverlayConfig = ThyAbstractOverlayConfig> extends ThyAbstractOverlayRef<T, TContainer, TResult> {
+    /** The instance of component opened into the dialog. */
+    componentInstance: T;
+    /** Whether the user is allowed to close the dialog. */
+    backdropClosable: boolean;
+    /** Whether the user is not allowed to close the dialog. */
+    disableClose: boolean;
+    /** Subject for notifying the user that the dialog has finished opening. */
+    private readonly _afterOpened;
+    /** Subject for notifying the user that the dialog has finished closing. */
+    private readonly _afterClosed;
+    /** Subject for notifying the user that the dialog has started closing. */
+    private readonly _beforeClosed;
+    /** Result to be passed to afterClosed. */
+    private _result;
+    protected abstract get options(): ThyAbstractOverlayOptions;
+    protected overlayRef: OverlayRef;
+    protected config: TConfig;
+    /** Fetches the position strategy object from the overlay ref. */
+    protected getPositionStrategy(): PositionStrategy;
+    constructor();
+    initialize(overlayRef: OverlayRef, containerInstance: TContainer, config: TConfig, ...args: any[]): void;
+    /**
+     * Close the overlay.
+     * @param overlayResult Optional result to return to the dialog opener.
+     */
+    close(overlayResult?: TResult, force?: boolean): void;
+    /**
+     * Gets an observable that is notified when the dialog is finished opening.
+     */
+    afterOpened(): Observable<void>;
+    /**
+     * Gets an observable that is notified when the dialog is finished closing.
+     */
+    afterClosed(): Observable<TResult | undefined>;
+    /**
+     * Gets an observable that is notified when the dialog has started closing.
+     */
+    beforeClosed(): Observable<TResult | undefined>;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick(): Observable<MouseEvent>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /** Get overlay ref */
+    getOverlayRef(): OverlayRef;
+    /**
+     * Updates the overlay's position when is GlobalPositionStrategy
+     * @param position New overlay position.
+     */
+    updateGlobalPosition(position?: ThyAbstractOverlayPosition): this;
+}
+
+type ComponentTypeOrTemplateRef<T> = ComponentType<T> | TemplateRef<T>;
+declare abstract class ThyAbstractOverlayService<TConfig extends ThyAbstractOverlayConfig, TContainer extends ThyAbstractOverlayContainer> {
+    protected options: ThyAbstractOverlayOptions;
+    protected overlay: Overlay;
+    protected injector: Injector;
+    protected defaultConfig: TConfig;
+    scrollStrategy?: FunctionProp<ScrollStrategy>;
+    protected openedOverlays: ThyAbstractOverlayRef<unknown, TContainer>[];
+    private readonly _afterAllClosed;
+    private readonly _afterOpened;
+    constructor(options: ThyAbstractOverlayOptions, // component name, e.g: dialog | popover | slide
+    overlay: Overlay, injector: Injector, defaultConfig: TConfig, scrollStrategy?: FunctionProp<ScrollStrategy>);
+    /** Build cdk overlay config by config */
+    protected abstract buildOverlayConfig(config: TConfig): OverlayConfig;
+    /** Attach overlay container to overlay*/
+    protected abstract attachOverlayContainer(overlay: OverlayRef, config: TConfig): TContainer;
+    /** Create abstract overlay ref by cdk overlay, container and config  */
+    protected abstract createAbstractOverlayRef<T, TResult>(overlayRef: OverlayRef, containerInstance: TContainer, config: TConfig): ThyAbstractOverlayRef<T, TContainer, TResult>;
+    /** Create injector for component content */
+    protected abstract createInjector<T>(config: TConfig, overlayRef: ThyAbstractOverlayRef<T, TContainer>, containerInstance: TContainer): Injector;
+    /** Attach component or template ref to overlay container */
+    protected attachOverlayContent<T, TResult>(componentOrTemplateRef: ComponentTypeOrTemplateRef<T>, containerInstance: TContainer, overlayRef: OverlayRef, config: TConfig): ThyAbstractOverlayRef<T, TContainer, TResult>;
+    protected removeOpenedOverlay(overlayRef: ThyAbstractOverlayRef<any, TContainer>): void;
+    protected getAbstractOverlayById(id: string): ThyAbstractOverlayRef<any, TContainer> | undefined;
+    protected getAbstractOverlays(): ThyAbstractOverlayRef<any, TContainer>[];
+    protected buildBaseOverlayConfig(config: TConfig, defaultPanelClass?: string | string[]): OverlayConfig;
+    protected openOverlay<T, TResult = unknown>(componentOrTemplateRef: ComponentTypeOrTemplateRef<T>, config?: TConfig): ThyAbstractOverlayRef<T, TContainer, TResult>;
+    /**
+     * 所有弹出框完全关闭后的回调
+     * @returns
+     */
+    afterAllClosed(): Subject<void>;
+    /**
+     * 打开弹出框之后的回调
+     * @returns
+     */
+    afterOpened(): Subject<ThyAbstractOverlayRef<any, TContainer, unknown>>;
+    /**
+     * 关闭弹出框，若force为true，则canClose无效，强制关闭
+     * @param result
+     * @param force
+     */
+    close<T>(result?: T, force?: boolean): void;
+    /**
+     * 关闭所有打开的弹出框
+     */
+    closeAll(): void;
+    dispose(): void;
+}
+
+declare class UpdateHostClassService {
+    private renderer;
+    private _classNames;
+    private _hostElement;
+    initializeElement(element: HTMLElement | ElementRef<HTMLElement>): this;
+    updateClass(classNames: string[]): this;
+    updateClassByMap(classMap: Dictionary<boolean>): void;
+    addClass(className: string): this;
+    removeClass(className: string): this;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateHostClassService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateHostClassService>;
+}
+
+declare class ThyTranslate {
+    instant(key: string | Array<string>, interpolateParams?: object): string | any;
+    get(key: string | Array<string>, interpolateParams?: object): Observable<string | any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThyTranslate, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThyTranslate>;
+}
+
+declare class MiniStore<T = unknown> implements Observer<T>, OnDestroy {
+    initialStateCache: any;
+    state$: BehaviorSubject<T>;
+    reduxToolEnabled: boolean;
+    private _defaultStoreInstanceId;
+    initialize(initialState: any): void;
+    get snapshot(): T;
+    dispatch(type: string, payload?: any): Observable<any>;
+    private _dispatch;
+    select<TResult>(selector: (state: T) => TResult): Observable<TResult> | Observable<TResult>;
+    next(state: T): void;
+    error(error: any): void;
+    complete(): void;
+    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
+    /**
+     * set store new state
+     *
+     * @example
+     * this.setState(newState);
+     * this.setState({ users: produce(this.snapshot.users).add(user) });
+     * this.setState((state) => {
+     *    return {
+     *        users: produce(state.users).add(user)
+     *    }
+     * });
+     * @param fn
+     */
+    setState(fn: Partial<T> | ((newState: T) => Partial<T>)): void;
+    getState(): T;
+    clearState(): void;
+    ngOnDestroy(): void;
+    /**
+     * You can override this method if you want to give your container instance a custom id.
+     * The returned id must be unique in the application.
+     */
+    getStoreInstanceId(): string;
+    private _getClassName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniStore<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MiniStore<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class MiniActionState {
+    private static actionName;
+    static changeAction(actionName: string): void;
+    static getActionName(): string;
+}
+
+/**
+ * Decorates a method with a action information.
+ */
+declare function MiniAction(): (target: any, name: string, descriptor: TypedPropertyDescriptor<any>) => void;
+
+declare const presetThemeColors: readonly ["primary", "success", "info", "warning", "danger", "default", "light"];
+type ThyThemeColor = (typeof presetThemeColors)[number];
+declare function isThemeColor(color: ThyThemeColor | string): boolean;
+declare const presetTextColors: readonly ["primary", "success", "info", "warning", "danger", "default", "light", "secondary", "muted", "desc", "placeholder", "white", "body"];
+type ThyTextColor = (typeof presetTextColors)[number];
+declare function isTextColor(color: ThyTextColor | string): boolean;
+declare const presetBgColors: readonly ["primary", "success", "info", "warning", "danger", "default", "light", "secondary", "dark", "lighter", "bright", "content", "white", "transparent"];
+type ThyBgColor = (typeof presetBgColors)[number];
+declare function isBgColor(color: ThyBgColor | string): boolean;
+
+type ThySpacingSize = 'zero' | 'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xlg' | number;
+declare function getNumericSize(size: ThySpacingSize, defaultSize?: ThySpacingSize): number;
+
+/**
+ * for issue: https://github.com/angular/angular/issues/44351
+ * only for test mock debounceTime
+ */
+declare class DebounceTimeWrapper {
+    static debounceTime<T>(dueTime: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
+}
+
+export { AbstractControlValueAccessor, AnimationCurves, AnimationDuration, AnonymousClass, DebounceTimeWrapper, EXPANDED_DROPDOWN_POSITIONS, InputBoolean, InputCssPixel, InputNumber, MiniAction, MiniActionState, MiniStore, MixinBase, POSITION_MAP, ScrollToService, TabIndexDisabledControlValueAccessorMixin, TabIndexMixinBase, ThyAbstractInternalOverlayRef, ThyAbstractOverlayConfig, ThyAbstractOverlayContainer, ThyAbstractOverlayRef, ThyAbstractOverlayService, ThyClickPositioner, ThyOverlayDirectiveBase, ThyPortalOutlet, ThyScrollService, ThyTheme, ThyThemeStore, ThyTranslate, UpdateHostClassService, buildConnectedPositionOffset, buildConnectedPositionPair, cancelRequestAnimationFrame, collapseMotion, fadeMotion, getFallbackPlacements, getFlexiblePositions, getNumericSize, getPlacementByPosition, injectPanelEmptyIcon, isBgColor, isTextColor, isThemeColor, mixinDisabled, mixinInitialized, mixinLoadingDone, mixinTabIndex, mixinUnsubscribe, presetBgColors, presetTextColors, presetThemeColors, reqAnimFrame, scaleMotion, scaleXMotion, scaleYMotion, throwPopoverContentAlreadyAttachedError, thumbMotion, useHostFocusControl };
+export type { ComponentTypeOrTemplateRef, ConnectedPositionOffset, Constructor, EasyingFn, ThumbAnimationProps, ThyAbstractOverlayOptions, ThyAbstractOverlayPosition, ThyBgColor, ThyCanDisable, ThyCanDisableCtor, ThyClickPosition, ThyHasTabIndex, ThyInitialized, ThyLoadingDone, ThyOverlayTrigger, ThyPlacement, ThySpacingSize, ThyTextColor, ThyThemeColor, ThyUnsubscribe };