@ethlete/cdk 4.28.0 → 4.28.2

package/lib/components/overlay/components/overlay/partials/overlay-router-link/overlay-router-link.directive.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { OverlayRouterNavigationDirection, OverlayRouterService } from '../../utils';
+import * as i0 from "@angular/core";
+export declare const OVERLAY_ROUTER_LINK_TOKEN: InjectionToken<OverlayRouterLinkDirective>;
+export declare class OverlayRouterLinkDirective {
+    router: OverlayRouterService;
+    path: import("@angular/core").InputSignal<string | (string | number)[]>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    navigationDirection: import("@angular/core").InputSignal<OverlayRouterNavigationDirection | null>;
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayRouterLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlayRouterLinkDirective, "[etOverlayRouterLink]", never, { "path": { "alias": "etOverlayRouterLink"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "navigationDirection": { "alias": "navigationDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-router-outlet/overlay-router-outlet.component.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef, InjectionToken, TemplateRef } from '@angular/core';
+import { AnimatedLifecycleState } from '@ethlete/core';
+import { OverlayRouterService } from '../../utils';
+import * as i0 from "@angular/core";
+export declare const OVERLAY_ROUTER_OUTLET_TOKEN: InjectionToken<OverlayRouterOutletComponent>;
+export declare class OverlayRouterOutletComponent {
+    readonly hasSidebar: boolean;
+    router: OverlayRouterService;
+    sharedRouteTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    outletDisabledTemplate: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    pageWrappers: import("@angular/core").Signal<readonly ElementRef<HTMLElement>[]>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    wasDisabled: import("@angular/core").WritableSignal<boolean>;
+    keepDisabledTransition: import("@angular/core").Signal<boolean>;
+    activePageElement: import("@angular/core").Signal<HTMLElement | null>;
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    scrollActivePageTo(options?: ScrollToOptions | undefined): void;
+    disabledPageAnimationStateChange(state: AnimatedLifecycleState): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayRouterOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlayRouterOutletComponent, "et-overlay-router-outlet", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["sharedRouteTemplate", "outletDisabledTemplate"], ["*"], true, never>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-router-outlet-disabled-template/overlay-router-outlet-disabled-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const OVERLAY_ROUTER_OUTLET_DISABLED_TEMPLATE_TOKEN: InjectionToken<OverlayRouterOutletDisabledTemplateDirective>;
+export declare class OverlayRouterOutletDisabledTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayRouterOutletDisabledTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlayRouterOutletDisabledTemplateDirective, "ng-template[etOverlayRouterOutletDisabledTemplate]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-shared-route-template/overlay-shared-route-template.directive.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const OVERLAY_SHARED_ROUTE_TEMPLATE_TOKEN: InjectionToken<OverlaySharedRouteTemplateDirective>;
+export declare class OverlaySharedRouteTemplateDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlaySharedRouteTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlaySharedRouteTemplateDirective, "ng-template[etOverlaySharedRouteTemplate]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-shared-route-template-outlet/overlay-shared-route-template-outlet.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class OverlaySharedRouteTemplateOutletComponent {
+    routerOutlet: import("../overlay-router-outlet").OverlayRouterOutletComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlaySharedRouteTemplateOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlaySharedRouteTemplateOutletComponent, "et-overlay-shared-route-template-outlet", never, {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-sidebar/overlay-sidebar.component.d.ts

@@ -0,0 +1,21 @@
+import { TemplateRef } from '@angular/core';
+import { OverlayRouterService, SidebarOverlayService } from '../../utils';
+import { OverlayBodyDividerType } from '../overlay-body';
+import * as i0 from "@angular/core";
+export declare class OverlaySidebarComponent {
+    sidebarContent: import("@angular/core").Signal<TemplateRef<unknown>>;
+    sidebarHeaderContent: import("@angular/core").Signal<import("../overlay-header-template").OverlayHeaderTemplateDirective | undefined>;
+    sidebar: SidebarOverlayService;
+    router: OverlayRouterService;
+    pageDividers: import("@angular/core").InputSignal<OverlayBodyDividerType>;
+    hostClassBindings: {
+        remove: (tokens: string) => void;
+        removeMany: (tokens: string[]) => void;
+        has: (tokens: string) => boolean;
+        push: (tokens: string, signal: import("@angular/core").Signal<unknown>) => void;
+        pushMany: (map: Record<string, import("@angular/core").Signal<unknown>>) => void;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlaySidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlaySidebarComponent, "et-overlay-sidebar", never, { "pageDividers": { "alias": "pageDividers"; "required": false; "isSignal": true; }; }, {}, ["sidebarHeaderContent"], ["*"], true, never>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-sidebar-page/overlay-sidebar-page.component.d.ts

@@ -0,0 +1,12 @@
+import { TemplateRef } from '@angular/core';
+import { OverlayBodyDividerType } from '../overlay-body';
+import { OverlayHeaderTemplateDirective } from '../overlay-header-template';
+import * as i0 from "@angular/core";
+import * as i1 from "../overlay-main/overlay-main.directive";
+export declare class OverlaySidebarPageComponent {
+    headerTemplate: import("@angular/core").InputSignal<OverlayHeaderTemplateDirective | null>;
+    bodyTemplate: import("@angular/core").InputSignal<TemplateRef<unknown> | null>;
+    pageDividers: import("@angular/core").InputSignal<OverlayBodyDividerType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlaySidebarPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlaySidebarPageComponent, "et-overlay-sidebar-page", never, { "headerTemplate": { "alias": "headerTemplate"; "required": true; "isSignal": true; }; "bodyTemplate": { "alias": "bodyTemplate"; "required": true; "isSignal": true; }; "pageDividers": { "alias": "pageDividers"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.OverlayMainDirective; inputs: {}; outputs: {}; }]>;
+}

package/lib/components/overlay/components/overlay/partials/overlay-title/overlay-title.directive.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class OverlayTitleDirective implements OnInit {
+    private _overlayRef;
+    private readonly _elementRef;
+    private readonly _overlayService;
+    id: string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OverlayTitleDirective, "[et-overlay-title], [etOverlayTitle]", ["etOverlayTitle"], { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/overlay/services/overlay.service.d.ts

@@ -0,0 +1,31 @@
+import { ComponentType } from '@angular/cdk/overlay';
+import { OnDestroy, TemplateRef } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { OverlayConfig } from '../types';
+import { OverlayPositionBuilder, OverlayRef } from '../utils';
+import * as i0 from "@angular/core";
+export declare class OverlayService implements OnDestroy {
+    private readonly _destroy$;
+    private readonly _defaultOptions;
+    private readonly _scrollStrategy;
+    private readonly _parentOverlayService;
+    private readonly _dialog;
+    private readonly _viewportService;
+    private readonly _openOverlaysAtThisLevel;
+    private readonly _afterAllClosedAtThisLevel;
+    private readonly _afterOpenedAtThisLevel;
+    readonly positions: OverlayPositionBuilder;
+    readonly afterAllClosed: Observable<void>;
+    get openOverlays(): OverlayRef[];
+    get afterOpened(): Subject<OverlayRef>;
+    ngOnDestroy(): void;
+    open<T, D = unknown, R = unknown>(component: ComponentType<T>, config: OverlayConfig<D>): OverlayRef<T, R>;
+    open<T, D = unknown, R = unknown>(template: TemplateRef<T>, config: OverlayConfig<D>): OverlayRef<T, R>;
+    open<T, D = unknown, R = unknown>(template: ComponentType<T> | TemplateRef<T>, config: OverlayConfig<D>): OverlayRef<T, R>;
+    closeAll(): void;
+    getOverlayById(id: string): OverlayRef | undefined;
+    private _closeOverlays;
+    private _getAfterAllClosed;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayService>;
+}

package/lib/components/overlay/components/overlay/types/overlay.types.d.ts

@@ -0,0 +1,196 @@
+import { Direction } from '@angular/cdk/bidi';
+import { PositionStrategy, ScrollStrategy } from '@angular/cdk/overlay';
+import { Injector, StaticProvider, ViewContainerRef } from '@angular/core';
+import { Breakpoint } from '@ethlete/core';
+/** Options for where to set focus to automatically on overlay open */
+export type OverlayAutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Valid ARIA roles for a overlay element. */
+export type OverlayRole = 'dialog' | 'alertdialog';
+/** Possible overrides for a overlay's position. */
+export interface OverlayPosition {
+    /** 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;
+}
+export declare const OVERLAY_STATE: {
+    readonly OPEN: "open";
+    readonly CLOSING: "closing";
+    readonly CLOSED: "closed";
+};
+export type OverlayState = (typeof OVERLAY_STATE)[keyof typeof OVERLAY_STATE];
+export interface OverlayDragToDismissConfig {
+    /** Direction in which the overlay can be dragged. */
+    direction: 'to-top' | 'to-bottom' | 'to-left' | 'to-right';
+    /**
+     * The minimum distance in pixels that the user must swipe to dismiss the overlay.
+     *
+     * @default 150 // 150px
+     */
+    minDistanceToDismiss?: number;
+    /**
+     * The minimum velocity in pixels per second that the user must swipe to dismiss the overlay.
+     *
+     * @default 150 // 150px/s
+     */
+    minVelocityToDismiss?: number;
+}
+export interface OverlayBreakpointConfig {
+    /** Min-width of the overlay. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Max-width of the overlay. If a number is provided, assumes pixel units. */
+    maxWidth?: number | string;
+    /** Min-height of the overlay. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-height of the overlay. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+    /** Width of the overlay. */
+    width?: number | string;
+    /** Height of the overlay. */
+    height?: number | string;
+    /** Position strategy to be used for the overlay. */
+    positionStrategy?: () => PositionStrategy;
+    /** Custom class for the overlay container. */
+    containerClass?: string | string[];
+    /** Custom class for the overlay pane. */
+    paneClass?: string | string[];
+    /** Extra CSS classes to be added to the overlay overlay container. */
+    overlayClass?: string | string[];
+    /** Custom class for the backdrop. */
+    backdropClass?: string | string[];
+    /** Custom class for the document (`<html>` element). */
+    documentClass?: string | string[];
+    /** Custom class for the `<body>` element */
+    bodyClass?: string | string[];
+    /** Position overrides. */
+    position?: OverlayPosition;
+    /** Determine if and in what direction the overlay should be able to be dragged to dismiss it. */
+    dragToDismiss?: OverlayDragToDismissConfig;
+    /**
+     * Whether the transform origin should be set using the config's `origin` property value.
+     *
+     * @default false
+     */
+    applyTransformOrigin?: boolean;
+}
+export interface OverlayBreakpointConfigEntry {
+    /**
+     * Breakpoint to apply the config for. If a number is provided, it will be used as a pixel value.
+     * Always uses the min-width media query.
+     *
+     * @default 'xs' // 0px
+     */
+    breakpoint?: Breakpoint | number;
+    /**
+     * Overlay configuration to be applied when the breakpoint is active.
+     */
+    config: OverlayBreakpointConfig;
+}
+export interface OverlayConfig<D = unknown> {
+    /**
+     * Conditionally applied overlay configurations based on breakpoints.
+     */
+    positions: OverlayBreakpointConfigEntry[];
+    /**
+     * 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;
+    /**
+     * Injector used for the instantiation of the component to be attached. If provided,
+     * takes precedence over the injector indirectly provided by `ViewContainerRef`.
+     */
+    injector?: Injector;
+    /** ID for the overlay. If omitted, a unique one will be generated. */
+    id?: string;
+    /**
+     * The ARIA role of the overlay element.
+     * @default 'dialog'
+     */
+    role?: OverlayRole;
+    /**
+     * Whether the overlay has a backdrop.
+     * @default true
+     */
+    hasBackdrop?: boolean;
+    /**
+     * Whether the user can use escape or clicking on the backdrop to close the modal.
+     * @default false
+     */
+    disableClose?: boolean;
+    /**
+     * Data being injected into the child component.
+     * @default null
+     */
+    data?: D | null;
+    /** Layout direction for the overlay's content. */
+    direction?: Direction;
+    /**
+     * ID of the element that describes the overlay.
+     * @default null
+     */
+    ariaDescribedBy?: string | null;
+    /**
+     * ID of the element that labels the overlay.
+     * @default null
+     */
+    ariaLabelledBy?: string | null;
+    /**
+     * Aria label to assign to the overlay element.
+     * @default null
+     */
+    ariaLabel?: string | null;
+    /**
+     * Whether this is a modal overlay. Used to set the `aria-modal` attribute.
+     * @default true
+     */
+    ariaModal?: boolean;
+    /**
+     * Whether the overlay uses a custom animation.
+     * @default false
+     */
+    customAnimated?: boolean;
+    /**
+     * Where the overlay should focus on open.
+     * Can be one of AutoFocusTarget, or a css selector string.
+     * @default 'first-tabbable'
+     */
+    autoFocus?: OverlayAutoFocusTarget | string;
+    /**
+     * Whether the overlay should restore focus to the
+     * previously-focused element, after it's closed.
+     * @default true
+     */
+    restoreFocus?: boolean;
+    /**
+     * Whether to wait for the opening animation to finish before trapping focus.
+     * @default true
+     */
+    delayFocusTrap?: boolean;
+    /** Scroll strategy to be used for the overlay. */
+    scrollStrategy?: ScrollStrategy;
+    /**
+     * 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`). Will be automatically set to false if the overlay contains a overlay router.
+     * @default true
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * Extra providers to be made available to the overlay.
+     *
+     * **WARNING**: Avoid providing `@Injectable()` classes such as services here, as they will never be destroyed.
+     * This could lead to memory leaks over time.
+     */
+    providers?: StaticProvider[];
+    /**
+     * The origin element that triggered the overlay's opening.
+     */
+    origin?: HTMLElement | MouseEvent | TouchEvent | KeyboardEvent | PointerEvent;
+}

package/lib/components/overlay/components/overlay/utils/filter-overlay.d.ts

@@ -0,0 +1,64 @@
+import { ComponentType } from '@angular/cdk/portal';
+import { InjectionToken, Provider } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { AnyQuery, QueryResponseOf, QueryState } from '@ethlete/query';
+import { OverlayRef } from './overlay-ref';
+import * as i0 from "@angular/core";
+export declare const FILTER_OVERLAY_CONFIG: InjectionToken<FilterOverlayConfig<FormGroup<any>, AnyQuery>>;
+export type FilterOverlayConfig<F extends FormGroup<any> = FormGroup<any>, Q extends AnyQuery = AnyQuery> = {
+    /**
+     * The form to use.
+     */
+    form: F;
+    /**
+     * The default form value. Used when the form is reset.
+     */
+    defaults?: ReturnType<F['getRawValue']>;
+    /**
+     * A function to create a query based on the form value.
+     */
+    searchPreviewQueryFn?: (formValue: ReturnType<F['getRawValue']>) => Q;
+    /**
+     * A function to extract the total hits from the response.
+     * @default `response.totalHits`
+     */
+    totalHitsExtractorFn?: (response: QueryResponseOf<Q>) => number;
+    /**
+     * A function to create the submit button config based on the query state and the total hits.
+     * If a german translation is needed, manually provide the `defaultSubmitButtonConfigFn` and set the locale to `de`.
+     * @default defaultSubmitButtonConfigFn()
+     */
+    submitButtonConfigFn?: (config: DefaultSubmitButtonConfigFnConfig<QueryResponseOf<Q>>) => FilterOverlaySubmitButtonConfig;
+};
+export type FilterOverlaySubmitButtonConfig = {
+    label: string;
+    disabled: boolean;
+};
+export type DefaultSubmitButtonConfigFnConfig<ResponseType = unknown> = {
+    queryState: QueryState<ResponseType> | null;
+    totalHits: number | null;
+    locale?: 'en' | 'de';
+};
+export declare const defaultSubmitButtonConfigFn: (config: DefaultSubmitButtonConfigFnConfig) => FilterOverlaySubmitButtonConfig;
+export type FilterOverlayResult<FormValue = unknown> = {
+    didUpdate: false;
+} | {
+    didUpdate: true;
+    formValue: FormValue;
+};
+export declare class FilterOverlayService<F extends FormGroup, C extends ComponentType<unknown> | unknown = unknown> {
+    config: FilterOverlayConfig<F, AnyQuery>;
+    overlayRef: OverlayRef<C, FilterOverlayResult<unknown>>;
+    form: F;
+    formValue: import("@angular/core").Signal<ReturnType<NonNullable<F extends import("@angular/core").Signal<infer I> ? I : F>["getRawValue"]> | null>;
+    searchPreviewQuery: import("@angular/core").Signal<AnyQuery | null>;
+    searchPreviewQueryState: import("@angular/core").Signal<QueryState<any> | null>;
+    searchPreviewTotalHits: import("@angular/core").Signal<number | null>;
+    submitButtonConfig: import("@angular/core").Signal<FilterOverlaySubmitButtonConfig>;
+    submit(): void;
+    reset(): void;
+    close(data?: FilterOverlayResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterOverlayService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterOverlayService<any, any>>;
+}
+export declare const provideFilterOverlayConfig: <F extends FormGroup<any> = FormGroup<any>, Q extends AnyQuery = AnyQuery>(config: FilterOverlayConfig<F, Q>) => Provider[];

package/lib/components/overlay/components/overlay/utils/overlay-config.d.ts

@@ -0,0 +1,2 @@
+import { OverlayConfig } from '../types';
+export declare const createOverlayConfig: <D = unknown>(globalConfig?: Partial<OverlayConfig<D>> | null | undefined, localConfig?: Partial<OverlayConfig<D>> | null | undefined) => OverlayConfig<D>;

package/lib/components/overlay/components/overlay/utils/overlay-position-builder.d.ts

@@ -0,0 +1,111 @@
+import { Breakpoint } from '@ethlete/core';
+import { OverlayBreakpointConfig, OverlayBreakpointConfigEntry } from '../types';
+export declare const ET_OVERLAY_LEFT_SHEET_CLASS = "et-overlay--left-sheet";
+export declare const ET_OVERLAY_RIGHT_SHEET_CLASS = "et-overlay--right-sheet";
+export declare const ET_OVERLAY_TOP_SHEET_CLASS = "et-overlay--top-sheet";
+export declare const ET_OVERLAY_BOTTOM_SHEET_CLASS = "et-overlay--bottom-sheet";
+export declare const ET_OVERLAY_DIALOG_CLASS = "et-overlay--dialog";
+export declare const ET_OVERLAY_FULL_SCREEN_DIALOG_CLASS = "et-overlay--full-screen-dialog";
+export declare const ET_OVERLAY_CONFIG_CLASS_KEYS: Set<string>;
+export declare const ET_OVERLAY_LAYOUT_CLASSES: Set<string>;
+export declare class OverlayPositionBuilder {
+    private readonly _overlay;
+    readonly DEFAULTS: {
+        dialog: {
+            width: undefined;
+            height: undefined;
+            maxHeight: string;
+            maxWidth: string;
+            minHeight: undefined;
+            minWidth: undefined;
+            containerClass: string;
+            positionStrategy: () => import("@angular/cdk/overlay").GlobalPositionStrategy;
+        };
+        fullScreenDialog: {
+            width: string;
+            height: string;
+            maxHeight: undefined;
+            maxWidth: undefined;
+            minHeight: undefined;
+            minWidth: undefined;
+            containerClass: string;
+            positionStrategy: () => import("@angular/cdk/overlay").GlobalPositionStrategy;
+            documentClass: string;
+            applyTransformOrigin: true;
+        };
+        bottomSheet: {
+            width: string;
+            height: undefined;
+            maxHeight: string;
+            maxWidth: string;
+            minHeight: undefined;
+            minWidth: undefined;
+            containerClass: string;
+            positionStrategy: () => import("@angular/cdk/overlay").GlobalPositionStrategy;
+            dragToDismiss: {
+                direction: "to-bottom";
+            };
+        };
+        topSheet: {
+            width: string;
+            height: undefined;
+            maxHeight: string;
+            maxWidth: string;
+            minHeight: undefined;
+            minWidth: undefined;
+            containerClass: string;
+            positionStrategy: () => import("@angular/cdk/overlay").GlobalPositionStrategy;
+            dragToDismiss: {
+                direction: "to-top";
+            };
+        };
+        leftSheet: {
+            width: string;
+            height: string;
+            maxHeight: undefined;
+            maxWidth: string;
+            minHeight: undefined;
+            minWidth: undefined;
+            containerClass: string;
+            positionStrategy: () => import("@angular/cdk/overlay").GlobalPositionStrategy;
+            dragToDismiss: {
+                direction: "to-left";
+            };
+        };
+        rightSheet: {
+            width: string;
+            height: string;
+            maxHeight: undefined;
+            maxWidth: string;
+            minHeight: undefined;
+            minWidth: undefined;
+            containerClass: string;
+            positionStrategy: () => import("@angular/cdk/overlay").GlobalPositionStrategy;
+            dragToDismiss: {
+                direction: "to-right";
+            };
+        };
+    };
+    transformingBottomSheetToDialog(customConfig?: {
+        bottomSheet?: OverlayBreakpointConfig;
+        dialog?: OverlayBreakpointConfig;
+        breakpoint?: Breakpoint | number;
+    }): OverlayBreakpointConfigEntry[];
+    transformingFullScreenDialogToRightSheet(customConfig?: {
+        fullScreenDialog?: OverlayBreakpointConfig;
+        rightSheet?: OverlayBreakpointConfig;
+        breakpoint?: Breakpoint | number;
+    }): OverlayBreakpointConfigEntry[];
+    transformingFullScreenDialogToDialog(customConfig?: {
+        fullScreenDialog?: OverlayBreakpointConfig;
+        dialog?: OverlayBreakpointConfig;
+        breakpoint?: Breakpoint | number;
+    }): OverlayBreakpointConfigEntry[];
+    dialog(customConfig?: OverlayBreakpointConfig): OverlayBreakpointConfigEntry[];
+    fullScreenDialog(customConfig?: OverlayBreakpointConfig): OverlayBreakpointConfigEntry[];
+    bottomSheet(customConfig?: OverlayBreakpointConfig): OverlayBreakpointConfigEntry[];
+    topSheet(customConfig?: OverlayBreakpointConfig): OverlayBreakpointConfigEntry[];
+    leftSheet(customConfig?: OverlayBreakpointConfig): OverlayBreakpointConfigEntry[];
+    rightSheet(customConfig?: OverlayBreakpointConfig): OverlayBreakpointConfigEntry[];
+    mergeConfigs(...configs: OverlayBreakpointConfig[]): OverlayBreakpointConfig;
+}

package/lib/components/overlay/components/overlay/utils/overlay-ref.d.ts

@@ -0,0 +1,70 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { DialogRef as CdkDialogRef } from '@angular/cdk/dialog';
+import { ComponentRef, TemplateRef } from '@angular/core';
+import { OverlayContainerComponent } from '../components/overlay-container';
+import { OverlayConfig, OverlayPosition, OverlayState } from '../types';
+export interface OverlayCloseCallEvent<R = any> {
+    result: R | undefined;
+    forced: boolean;
+}
+export interface OverlayLayout {
+    hasHeader: boolean;
+    hasBody: boolean;
+    hasFooter: boolean;
+}
+export interface OverlayHeaderTemplates {
+    current: TemplateRef<unknown> | null;
+    previous: TemplateRef<unknown> | null;
+}
+export declare class OverlayRef<T = any, R = any> {
+    private _ref;
+    config: OverlayConfig;
+    _containerInstance: OverlayContainerComponent;
+    componentInstance: T | null;
+    readonly componentRef: ComponentRef<T> | null;
+    disableClose: boolean | undefined;
+    id: string;
+    private readonly _afterOpened;
+    private readonly _beforeClosed;
+    private readonly _closeCalled;
+    private _result;
+    private _state;
+    /**
+     * @internal
+     */
+    _closeInteractionType: FocusOrigin | undefined;
+    /**
+     * @internal
+     */
+    _isEscCloseControlledExternally: boolean;
+    /**
+     * @internal
+     */
+    _isBackdropCloseControlledExternally: boolean;
+    /**
+     * @internal
+     */
+    _isCloseFnCloseControlledExternally: boolean;
+    private _disableCloseFromInternalInitiators;
+    get _internalDisableClose(): boolean;
+    get _cdkRef(): CdkDialogRef<R, T>;
+    headerTemplate: import("@angular/core").WritableSignal<TemplateRef<unknown> | null>;
+    constructor(_ref: CdkDialogRef<R, T>, config: OverlayConfig, _containerInstance: OverlayContainerComponent);
+    close(result?: R, force?: boolean): void;
+    afterOpened(): import("rxjs").Observable<void>;
+    afterClosed(): import("rxjs").Observable<R | undefined>;
+    beforeClosed(): import("rxjs").Observable<R | undefined>;
+    backdropClick(): import("rxjs").Observable<MouseEvent>;
+    keydownEvents(): import("rxjs").Observable<KeyboardEvent>;
+    closeCalled(): import("rxjs").Observable<OverlayCloseCallEvent<R>>;
+    updatePosition(position?: OverlayPosition): this;
+    updateSize(width?: string, height?: string): this;
+    addPanelClass(classes: string | string[]): this;
+    removePanelClass(classes: string | string[]): this;
+    getState(): OverlayState;
+    private _finishOverlayClose;
+    _closeOverlayVia(interactionType: FocusOrigin, result?: R, force?: boolean): void;
+    _addInternalBackdropCloseInitiator(initiatorId: string | number): void;
+    _removeInternalBackdropCloseInitiator(initiatorId: string | number): void;
+    _setCurrentHeaderTemplate(template: TemplateRef<unknown> | null): void;
+}