@progress/kendo-angular-popup 24.2.2 → 25.0.0-develop.1

package/index.d.ts

@@ -2,16 +2,684 @@
 * Copyright © 2026 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-export { Align } from './models/align.interface';
-export { Collision } from './models/collision.interface';
-export { Offset } from './models/offset.interface';
-export { Margin } from './models/margin.interface';
-export { PopupSettings } from './models/popup-settings';
-export { PopupRef } from './models/popup-ref';
-export { PositionMode } from './models/position-mode';
-export { PopupAnimation, AnimationType, AnimationDirection } from './models/popup-animation.interface';
-export { PopupService, POPUP_CONTAINER } from './popup.service';
-export { PopupComponent } from './popup.component';
-export { PopupModule } from './popup.module';
-export { SCALE } from './scale';
-export * from './directives';
+import { AlignStrategy, OffsetPosition, MarginSettings, ElementRect, ScrollInfo, AlignSettings, BoundingRect, PositionSettings, ViewPort, CollisionStrategy } from '@progress/kendo-popup-common';
+import * as i0 from '@angular/core';
+import { ElementRef, ViewContainerRef, TemplateRef, NgZone, OnDestroy, EventEmitter, AfterViewInit, OnInit, OnChanges, Renderer2, ComponentRef, InjectionToken, ApplicationRef, Injector } from '@angular/core';
+import { AnimationBuilder } from '@angular/animations';
+import * as i1 from '@progress/kendo-angular-common';
+import { ResizeSensorComponent } from '@progress/kendo-angular-common';
+
+/**
+ * Specifies the horizontal and vertical align points for the component.
+ */
+interface Align extends AlignStrategy {
+    /**
+     * Specifies the horizontal point relative to the anchor or the Popup.
+     *
+     * The available options are:
+     * - `left`—Uses the leftmost point of the `anchor` element.
+     * - `center`—Uses the center point of the `anchor` element.
+     * - `right`—Uses the rightmost point of the `anchor` element.
+     */
+    horizontal: 'left' | 'center' | 'right';
+    /**
+     * Specifies the vertical point relative to the anchor or the Popup.
+     *
+     * The available options are:
+     * - `top`—Uses the top point of the `anchor` element.
+     * - `center`—Uses the center point of the `anchor` element.
+     * - `bottom`—Uses the bottom point of the `anchor` element.
+     */
+    vertical: 'top' | 'center' | 'bottom';
+}
+
+/**
+ * Defines the possible collision behavior when the Popup is not fully visible.
+ *
+ * - `fit`—Moves the Popup horizontally until it is fully displayed in the viewport.
+ * - `flip`—Flips the Popup position based on the origin and the position properties.
+ */
+type CollisionType = 'fit' | 'flip';
+
+/**
+ * Defines the horizontal and vertical collision behavior for the component.
+ */
+interface Collision {
+    /**
+     * Sets the horizontal collision behavior for the component.
+     */
+    horizontal: CollisionType;
+    /**
+     * Sets the vertical collision behavior for the component.
+     */
+    vertical: CollisionType;
+}
+
+/**
+ * Defines the offset position of the Popup.
+ */
+interface Offset extends OffsetPosition {
+    /**
+     * Sets the top position of the Popup.
+     */
+    top: number;
+    /**
+     * Sets the left position of the Popup.
+     */
+    left: number;
+}
+
+/**
+ * Defines the horizontal and vertical margin offsets of the component.
+ */
+interface Margin extends MarginSettings {
+    /**
+     * Sets the horizontal margin value.
+     */
+    horizontal: number;
+    /**
+     * Sets the vertical margin value.
+     */
+    vertical: number;
+}
+
+/**
+ * Defines all possible values for the `positionMode` property of the Popup.
+ */
+type PositionMode = 'absolute' | 'fixed';
+
+/**
+ * The animation settings for the Popup component.
+ */
+interface PopupAnimation {
+    /**
+     * Sets the type of the animation.
+     * @default 'slide'
+     */
+    type?: AnimationType;
+    /**
+     * Sets the animation duration in milliseconds.
+     * @default 100
+     */
+    duration: number;
+    /**
+     * Sets the animation direction. Applies if the type is `slide` or `expand`.
+     * @default 'down'
+     */
+    direction: AnimationDirection;
+}
+/**
+ * Defines the possible animation types for the Popup.
+ */
+type AnimationType = 'slide' | 'expand' | 'zoom' | 'fade';
+/**
+ * Defines the possible animation directions for the Popup.
+ */
+type AnimationDirection = 'down' | 'up' | 'left' | 'right';
+
+/**
+ * Defines the settings for the Popup when you open it through `PopupService` ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/api/popupservice#open)).
+ */
+interface PopupSettings {
+    /**
+     * Controls the Popup animation. By default, the open and close animations are enabled ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/animations)).
+     */
+    animate?: boolean | PopupAnimation;
+    /**
+     * Sets the element to use as an anchor. The Popup opens next to this element.
+     */
+    anchor?: ElementRef | HTMLElement;
+    /**
+     * Sets the container to which the Popup appends.
+     */
+    appendTo?: ViewContainerRef;
+    /**
+     * Sets the anchor pivot point ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning)).
+     */
+    anchorAlign?: Align;
+    /**
+     * Sets the content of the Popup.
+     */
+    content?: TemplateRef<any> | Function;
+    /**
+     * Sets the collision behavior of the Popup ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/viewport-boundary-detection)).
+     */
+    collision?: Collision;
+    /**
+     * Sets the margin value in pixels. Adds blank space between the Popup and the anchor.
+     */
+    margin?: Margin;
+    /**
+     * Sets the position mode of the component. By default, the Popup uses fixed positioning. To use absolute positioning, set this option to `absolute`.
+     *
+     * To support mobile browsers with the zoom option, use the `absolute` positioning of the Popup.
+     */
+    positionMode?: PositionMode;
+    /**
+     * Sets the pivot point of the Popup ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning)).
+     */
+    popupAlign?: Align;
+    /**
+     * Sets a list of CSS classes to add to the internal animated element ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/styling)).
+     *
+     * > To style the content of the Popup, use this property binding.
+     */
+    popupClass?: string | Array<string> | object | Set<string>;
+    /**
+     * Sets the absolute position of the element ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning#aligning-to-absolute-points)).
+     * The Popup opens next to this point. The pivot point of the Popup is defined by the `popupAlign` option. The boundary detection uses the window viewport.
+     */
+    offset?: Offset;
+}
+
+/**
+ * @hidden
+ */
+interface Position {
+    flipped: boolean;
+    flip: any;
+    offset: OffsetPosition;
+}
+
+/**
+ * @hidden
+ */
+declare class DOMService {
+    private _dummy;
+    addOffset(current: OffsetPosition, addition: OffsetPosition): OffsetPosition;
+    addScroll(rect: ElementRect, scroll: ScrollInfo): ElementRect;
+    align(settings: AlignSettings): OffsetPosition;
+    boundingOffset(el: HTMLElement): BoundingRect;
+    getFontStyles(el: HTMLElement): any;
+    getWindow(): Window | null;
+    hasOffsetParent(el: ElementRef): boolean;
+    offset(el: HTMLElement): ElementRect | null;
+    offsetAtPoint(el: ElementRef, currentLocation: OffsetPosition): ElementRect | null;
+    nativeElement(el: any): HTMLElement | null;
+    position(element: HTMLElement, popup: ElementRef, scale?: number): ElementRect | null;
+    removeScroll(rect: ElementRect, scroll: ScrollInfo): ElementRect;
+    restrictToView(settings: PositionSettings): Position;
+    scrollPosition(el: ElementRef): ScrollInfo;
+    scrollableParents(el: HTMLElement): Array<HTMLElement>;
+    stackingElementOffset(el: ElementRef): ElementRect;
+    stackingElementScroll(el: ElementRef): ScrollInfo;
+    getRelativeContextElement(el: ElementRef): HTMLElement;
+    useRelativePosition(el: ElementRef): boolean;
+    windowViewPort(el: ElementRef): ViewPort;
+    zIndex(anchor: HTMLElement, container: ElementRef): number;
+    zoomLevel(): number;
+    isZoomed(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DOMService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DOMService>;
+}
+
+/**
+ * @hidden
+ */
+interface AlignElementSettings {
+    anchor?: HTMLElement;
+    anchorAlign: AlignStrategy;
+    element: ElementRef;
+    elementAlign: AlignStrategy;
+    margin?: MarginSettings;
+    offset?: OffsetPosition;
+    positionMode?: PositionMode;
+}
+
+/**
+ * @hidden
+ */
+declare class AlignService {
+    private _dom;
+    private scale;
+    constructor(_dom: DOMService, scale?: number);
+    alignElement(settings: AlignElementSettings): OffsetPosition;
+    private absoluteRect;
+    private elementScrollPosition;
+    private relativeRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlignService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlignService>;
+}
+
+/**
+ * @hidden
+ */
+interface PositionElementSettings {
+    anchor?: HTMLElement;
+    anchorAlign: AlignStrategy;
+    collisions: CollisionStrategy;
+    currentLocation: OffsetPosition;
+    element: ElementRef;
+    elementAlign: AlignStrategy;
+    margin: MarginSettings;
+    positionMode?: PositionMode;
+    viewPort?: ViewPort;
+}
+
+/**
+ * @hidden
+ */
+declare class PositionService {
+    private _dom;
+    private scale;
+    constructor(_dom: DOMService, scale?: number);
+    positionElement(settings: PositionElementSettings): Position;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PositionService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PositionService>;
+}
+
+/**
+ * @hidden
+ */
+declare class ResizeService {
+    private _dom;
+    private _zone;
+    private subscription;
+    constructor(_dom: DOMService, _zone: NgZone);
+    subscribe(callback: () => void): void;
+    unsubscribe(): void;
+    isUnsubscribed(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeService>;
+}
+
+/**
+ * @hidden
+ */
+declare class ScrollableService {
+    private _dom;
+    private _zone;
+    private element;
+    private subscription;
+    constructor(_dom: DOMService, _zone: NgZone);
+    forElement(element: HTMLElement): ScrollableService;
+    subscribe(callback: (visible: boolean) => void): void;
+    unsubscribe(): void;
+    isVisible(elem: HTMLElement, container: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollableService>;
+}
+
+/**
+ * @hidden
+ */
+declare class AnimationService implements OnDestroy {
+    private animationBuilder;
+    start: EventEmitter<any>;
+    end: EventEmitter<any>;
+    private flip;
+    private player;
+    constructor(animationBuilder: AnimationBuilder);
+    play(element: any, options: any, flip: any): void;
+    ngOnDestroy(): void;
+    private playStates;
+    private getDirection;
+    private stopPlayer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationService>;
+}
+
+/**
+ * Represents the [Kendo UI Popup component for Angular](https://www.telerik.com/kendo-angular-ui/components/popup).
+ *
+ * @example
+ * ```html
+ * <button #anchor (click)="show = !show">Toggle</button>
+ * @if (show) {
+ *   <kendo-popup [anchor]="anchor">
+ *     <strong>Popup content!</strong>
+ *   </kendo-popup>
+ * }
+ * ```
+ */
+declare class PopupComponent implements AfterViewInit, OnInit, OnChanges, OnDestroy {
+    container: ElementRef;
+    private _alignService;
+    domService: DOMService;
+    private _positionService;
+    private _resizeService;
+    private _scrollableService;
+    private animationService;
+    private _renderer;
+    private _zone;
+    /**
+     * Controls the Popup animation. By default, the opening and closing animations are enabled ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/animations)).
+     * @default true
+     */
+    animate: boolean | PopupAnimation;
+    /**
+     * Sets the element to use as an anchor. The Popup opens next to this element. ([See example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning#aligning-to-components)).
+     */
+    anchor: ElementRef | HTMLElement;
+    /**
+     * Sets the anchor pivot point ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning#positioning)).
+     * @default '{ horizontal: "left", vertical: "bottom" }'
+     */
+    anchorAlign: Align;
+    /**
+     * Sets the collision behavior of the Popup ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/viewport-boundary-detection)).
+     * @default '{ horizontal: "fit", vertical: "flip" }'
+     */
+    collision: Collision;
+    /**
+     * Sets the pivot point of the Popup ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning#positioning)).
+     * @default '{ horizontal: "left", vertical: "top" }'
+     */
+    popupAlign: Align;
+    /**
+     * Controls whether the component copies the `anchor` font styles.
+     * @default false
+     */
+    copyAnchorStyles: boolean;
+    /**
+     * Sets a list of CSS classes to add to the internal animated element ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/styling)).
+     *
+     * > To style the content of the Popup, use this property binding.
+     */
+    popupClass: string | Array<string> | object | Set<string>;
+    /**
+     * Sets the position mode of the component. By default, the Popup uses fixed positioning. To use absolute positioning, set this option to `absolute`.
+     *
+     * To support mobile browsers with the zoom option, use the `absolute` positioning of the Popup.
+     * @default 'fixed'
+     */
+    positionMode: PositionMode;
+    /**
+     * Sets the absolute position of the element ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning#aligning-to-absolute-points)).
+     * The Popup opens next to this point. The Popup pivot point is defined by the `popupAlign` option. The boundary detection uses the window viewport.
+     * @default '{ left: -10000, top: 0 }'
+     */
+    offset: Offset;
+    /**
+     * Sets the margin value in pixels. Adds blank space between the Popup and the anchor ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/aligning-positioning#adding-a-margin)).
+     */
+    margin: Margin;
+    /**
+     * Fires when the anchor scrolls outside the screen boundaries. ([See example](https://www.telerik.com/kendo-angular-ui/components/popup/closing)).
+     */
+    anchorViewportLeave: EventEmitter<any>;
+    /**
+     * Fires after the component closes.
+     */
+    close: EventEmitter<any>;
+    /**
+     * Fires after the component opens and the opening animation ends.
+     */
+    open: EventEmitter<any>;
+    /**
+     * Fires after the component is opened and the Popup is positioned.
+     */
+    positionChange: EventEmitter<any>;
+    /**
+     * @hidden
+     */
+    contentContainer?: ElementRef;
+    /**
+     * @hidden
+     */
+    resizeSensor: ResizeSensorComponent;
+    /**
+     * @hidden
+     */
+    content?: TemplateRef<any>;
+    /**
+     * @hidden
+     */
+    renderDefaultClass: boolean;
+    private resolvedPromise;
+    private _currentOffset?;
+    private animationSubscriptions;
+    private repositionSubscription;
+    private initialCheck;
+    constructor(container: ElementRef, _alignService: AlignService, domService: DOMService, _positionService: PositionService, _resizeService: ResizeService, _scrollableService: ScrollableService, animationService: AnimationService, _renderer: Renderer2, _zone: NgZone);
+    ngOnInit(): void;
+    ngOnChanges(changes: any): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /**
+     * @hidden
+     */
+    onResize(): void;
+    private onAnimationStart;
+    private onAnimationEnd;
+    private get currentOffset();
+    private set currentOffset(value);
+    private setZIndex;
+    private reposition;
+    private position;
+    private onScroll;
+    private copyFontStyles;
+    private updateFixedClass;
+    private setContainerStyle;
+    private unsubscribeReposition;
+    private get hasCustomOffset();
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopupComponent, "kendo-popup", ["kendo-popup"], { "animate": { "alias": "animate"; "required": false; }; "anchor": { "alias": "anchor"; "required": false; }; "anchorAlign": { "alias": "anchorAlign"; "required": false; }; "collision": { "alias": "collision"; "required": false; }; "popupAlign": { "alias": "popupAlign"; "required": false; }; "copyAnchorStyles": { "alias": "copyAnchorStyles"; "required": false; }; "popupClass": { "alias": "popupClass"; "required": false; }; "positionMode": { "alias": "positionMode"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; }, { "anchorViewportLeave": "anchorViewportLeave"; "close": "close"; "open": "open"; "positionChange": "positionChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Holds references to the object instance of the Popup.
+ * Controls Popups opened through `PopupService` ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/api/popupservice#open)).
+ */
+interface PopupRef {
+    /**
+     * Provides a reference to the Popup instance.
+     */
+    popup: ComponentRef<PopupComponent>;
+    /**
+     * Provides a reference to the HTML element of the Popup.
+     */
+    popupElement: HTMLElement;
+    /**
+     * Provides a reference to the child component of the Popup. Available when the Popup opens with [`content`](https://www.telerik.com/kendo-angular-ui/components/popup/service#using-components).
+     */
+    content: ComponentRef<any>;
+    /**
+     * Closes and destroys the Popup.
+     */
+    close: Function;
+    /**
+     * Fires when the anchor scrolls outside the screen boundaries ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/closing)).
+     */
+    popupAnchorViewportLeave: EventEmitter<any>;
+    /**
+     * Fires after the component closes.
+     */
+    popupClose: EventEmitter<any>;
+    /**
+     * Fires after the component opens and the opening animation ends.
+     */
+    popupOpen: EventEmitter<any>;
+    /**
+     * Fires after the component opens and the Popup is positioned.
+     */
+    popupPositionChange: EventEmitter<any>;
+}
+
+/**
+ * Injects the Popup container. If not set, uses the first root component of the application ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/rendering-container)).
+ *
+ * > Use `POPUP_CONTAINER` only with the `PopupService` class ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/service)).
+ *
+ * In standalone components:
+ *
+ * @example
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { KENDO_POPUP, PopupService } from '@progress/kendo-angular-popup';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [KENDO_POPUP],
+ *   providers: [PopupService, {
+ *     provide: POPUP_CONTAINER,
+ *       useFactory: () => {
+ *         //return the container ElementRef, where the popup will be injected
+ *         return { nativeElement: document.body } as ElementRef;
+ *       }
+ *   }],
+ *   selector: 'app-root',
+ *   templateUrl: './app.component.html',
+ * })
+ * export class AppComponent {}
+ * ```
+ *
+ * In NgModule-based applications:
+ *
+ * @example
+ * ```ts
+ * import { PopupModule, POPUP_CONTAINER } from '@progress/kendo-angular-popup';
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ * import { ElementRef, NgModule } from '@angular/core';
+ * import { AppComponent } from './app.component';
+ *
+ * _@NgModule({
+ *     declarations: [AppComponent],
+ *     imports:      [BrowserModule, PopupModule],
+ *     bootstrap:    [AppComponent],
+ *     providers: [{
+ *       provide: POPUP_CONTAINER,
+ *       useFactory: () => {
+ *          //return the container ElementRef, where the popup will be injected
+ *          return { nativeElement: document.body } as ElementRef;
+ *       }
+ *     }]
+ * })
+ * export class AppModule {}
+ *
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ * ```
+ */
+declare const POPUP_CONTAINER: InjectionToken<ElementRef<any>>;
+/**
+ * Provides a service for opening Popup components dynamically ([see example](https://www.telerik.com/kendo-angular-ui/components/popup/angular-service)).
+ *
+ * @export
+ * @class PopupService
+ */
+declare class PopupService {
+    private applicationRef;
+    private injector;
+    private container;
+    /**
+     * Gets the root view container for injecting the component.
+     *
+     * @returns {ComponentRef<any>} The root view container reference.
+     */
+    private get rootViewContainer();
+    /**
+     * Gets the HTML element of the root component container.
+     *
+     * @returns {HTMLElement} The root container HTML element.
+     */
+    get rootViewContainerNode(): HTMLElement;
+    constructor(applicationRef: ApplicationRef, injector: Injector, container: ElementRef);
+    /**
+     * Opens a Popup component. The Popup mounts in the DOM under the root application component.
+     *
+     * @param {PopupSettings} options - The options for the Popup.
+     * @returns {ComponentRef<PopupComponent>} A reference to the Popup object.
+     */
+    open(options?: PopupSettings): PopupRef;
+    private appendPopup;
+    /**
+     * Gets the HTML element for a component reference.
+     *
+     * @param {ComponentRef<any>} componentRef The component reference.
+     * @returns {HTMLElement} The root HTML element of the component.
+     */
+    private getComponentRootNode;
+    /**
+     * Creates a component reference from a `Component` class.
+     *
+     * @param {*} componentClass The component class.
+     * @param {*} nodes The nodes to project.
+     * @param {ViewContainerRef} container The container to use.
+     * @returns {ComponentRef<any>} The created component reference.
+     */
+    private createComponent;
+    /**
+     * Projects the input options onto the component instance.
+     *
+     * @param {ComponentRef<any>} component The component reference.
+     * @param {*} options The options to project.
+     * @returns {ComponentRef<any>} The updated component reference.
+     */
+    private projectComponentInputs;
+    /**
+     * Gets the component and nodes to append from the `content` option.
+     *
+     * @param {*} content The content to use.
+     * @returns {any} The component and nodes for projection.
+     */
+    private contentFrom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupService, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PopupService>;
+}
+
+/**
+ * Required for adding all Popup features in NgModule-based Angular applications.
+ *
+ * @example
+ * ```ts-no-run
+ * // Import the Popup module
+ * import { PopupModule } from '@progress/kendo-angular-popup';
+ *
+ * // The browser platform with a compiler
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ *
+ * import { NgModule } from '@angular/core';
+ *
+ * // Import the app component
+ * import { AppComponent } from './app.component';
+ *
+ * // Define the app module
+ * _@NgModule({
+ *     declarations: [AppComponent], // declare app component
+ *     imports:      [BrowserModule, PopupModule], // import Popup module
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * // Compile and launch the module
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+declare class PopupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PopupModule, never, [typeof i1.ResizeSensorComponent, typeof PopupComponent], [typeof PopupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PopupModule>;
+}
+
+/**
+ * Use the `SCALE` injection token to set the document scale when you use a [scale transform](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale).
+ *
+ * The document or container scale is required to compute the popup position correctly. Set the value for `SCALE` to ensure correct positioning. See [Support for Document Scale](https://www.telerik.com/kendo-angular-ui/components/popup/document-scale).
+ *
+ * > You do not need to use this token for user-applied browser zoom.
+ */
+declare const SCALE: InjectionToken<number>;
+
+/**
+ * Use this utility array to access all `@progress/kendo-angular-popup`-related components and directives in a standalone Angular component.
+ *
+ * @example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ * import { KENDO_POPUP } from '@progress/kendo-angular-popup';
+ *
+ * @Component({
+ *   selector: 'my-app',
+ *   standalone: true,
+ *   imports: [KENDO_POPUP],
+ *   template: `<kendo-popup>Popup content.</kendo-popup>`
+ * })
+ * export class AppComponent {}
+ * ```
+ */
+declare const KENDO_POPUP: readonly [typeof PopupComponent];
+
+export { KENDO_POPUP, POPUP_CONTAINER, PopupComponent, PopupModule, PopupService, SCALE };
+export type { Align, AnimationDirection, AnimationType, Collision, Margin, Offset, PopupAnimation, PopupRef, PopupSettings, PositionMode };