@koobiq/components 20.4.2 → 21.0.0

package/types/koobiq-components-sidebar.d.ts

@@ -0,0 +1,152 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, OnDestroy, AfterContentInit, SimpleChanges } from '@angular/core';
+import * as i1 from '@koobiq/components/core';
+
+declare enum SidebarPositions {
+    Left = "left",
+    Right = "right"
+}
+interface KbqSidebarParams {
+    openedStateMinWidth: string;
+    openedStateWidth: string;
+    openedStateMaxWidth: string;
+    closedStateWidth: string;
+}
+declare class KbqSidebarOpened {
+    readonly minWidth: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly maxWidth: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqSidebarOpened, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqSidebarOpened, "[kbq-sidebar-opened]", ["kbqSidebarOpened"], { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class KbqSidebarClosed {
+    readonly width: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqSidebarClosed, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqSidebarClosed, "[kbq-sidebar-closed]", ["kbqSidebarClosed"], { "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The persisted state of a sidebar — whether it was open, and the width it was last left at. */
+interface KbqSidebarState {
+    opened: boolean;
+    /** Absent while the sidebar has never been resized away from the width its content declares. */
+    width?: string;
+}
+declare class KbqSidebar implements OnChanges, OnDestroy, AfterContentInit {
+    private ngZone;
+    private elementRef;
+    /**
+     * @docs-private
+     */
+    protected readonly document: Document;
+    private readonly renderer;
+    private readonly isBrowser;
+    private readonly injector;
+    /**
+     * Whether the sidebar opens and closes without motion.
+     *
+     * @docs-private
+     */
+    protected readonly animationsDisabled: boolean;
+    /**
+     * Whether the sidebar moves between the opened and closed states: only then is its width transitioned, so
+     * the first render and a width written from outside, such as by a splitter, apply at once.
+     *
+     * @docs-private
+     */
+    protected readonly toggling: _angular_core.WritableSignal<boolean>;
+    private stateAnimation?;
+    /**
+     * Persistence of the opened state and width, applied as a host directive. `useStateSaving` and
+     * `stateSavingKey` are its inputs, forwarded onto the sidebar.
+     */
+    private readonly stateSaving;
+    get opened(): boolean;
+    set opened(value: boolean);
+    private readonly openedState;
+    /**
+     * Whether anything has assigned `opened`. Snapshotted while initializing, where only an input binding
+     * can have done so — `toggle()` needs a view query and the bracket shortcut is registered later — so
+     * it reads as "the application drives this sidebar" and suppresses persistence.
+     */
+    private openedWritten;
+    private controlled;
+    readonly position: _angular_core.InputSignal<SidebarPositions>;
+    /**
+     * @docs-private
+     */
+    get params(): KbqSidebarParams;
+    /** @docs-private */
+    set params(value: KbqSidebarParams);
+    private readonly paramsState;
+    readonly stateChanged: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * @docs-private
+     */
+    readonly openedContent: _angular_core.Signal<KbqSidebarOpened | undefined>;
+    /**
+     * @docs-private
+     */
+    readonly closedContent: _angular_core.Signal<KbqSidebarClosed | undefined>;
+    /**
+     * @docs-private
+     */
+    get internalState(): boolean;
+    /** @docs-private */
+    set internalState(value: boolean);
+    private readonly internalStateSignal;
+    private unbindKeydownListener;
+    /** @docs-private */
+    readonly openedInput: _angular_core.InputSignal<boolean | undefined>;
+    ngOnChanges(changes: SimpleChanges): void;
+    constructor();
+    ngAfterContentInit(): void;
+    /**
+     * Reads the persisted state and applies it. Runs while initializing, and again on a key change.
+     * Returns whether it changed the opened state.
+     */
+    private restoreState;
+    ngOnDestroy(): void;
+    /**
+     * Persists whether the sidebar is open and the width it was last left at.
+     *
+     * Called whenever `opened` changes. The width is only captured as the sidebar closes, so dragging it
+     * wider and reloading without closing it keeps the previous width — the same as before persistence.
+     */
+    saveState(): void;
+    /**
+     * Removes the state persisted for this sidebar.
+     *
+     * Persistence itself stays on — the next change is written again. Unset `useStateSaving` to stop it.
+     */
+    clearSavedState(): void;
+    /**
+     * Whether state is currently persisted for this sidebar — restored on init, or written since.
+     * Always `false` while `useStateSaving` is unset, and `false` again after `clearSavedState()`.
+     */
+    get hasSavedState(): boolean;
+    toggle(): void;
+    private setOpened;
+    /**
+     * Switches the content and reports the state once rendered, after the width transition when `animated`:
+     * the initial state has none.
+     */
+    private waitForStateAnimation;
+    private registerKeydownListener;
+    private unRegisterKeydownListener;
+    private handleKeydown;
+    /** Whether this sidebar reads and writes its state at all. */
+    private get persists();
+    /** The whole state, with the width left out while it is the one the content declares. */
+    private snapshot;
+    private saveWidth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqSidebar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqSidebar, "kbq-sidebar", ["kbqSidebar"], { "position": { "alias": "position"; "required": false; "isSignal": true; }; "openedInput": { "alias": "opened"; "required": false; "isSignal": true; }; }, { "stateChanged": "stateChanged"; }, ["openedContent", "closedContent"], ["[kbq-sidebar-opened]", "[kbq-sidebar-closed]"], true, [{ directive: typeof i1.KbqStateSaving; inputs: { "useStateSaving": "useStateSaving"; "stateSavingKey": "stateSavingKey"; }; outputs: {}; }]>;
+}
+
+declare class KbqSidebarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqSidebarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqSidebarModule, never, [typeof KbqSidebarClosed, typeof KbqSidebarOpened, typeof KbqSidebar], [typeof KbqSidebarClosed, typeof KbqSidebarOpened, typeof KbqSidebar]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqSidebarModule>;
+}
+
+export { KbqSidebar, KbqSidebarClosed, KbqSidebarModule, KbqSidebarOpened, SidebarPositions };
+export type { KbqSidebarState };

package/types/koobiq-components-sidepanel.d.ts

@@ -0,0 +1,436 @@
+import * as i1$1 from '@angular/cdk/overlay';
+import { ScrollStrategy, OverlayRef } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injector, OnDestroy, ComponentRef, EmbeddedViewRef, TemplateRef } from '@angular/core';
+import * as i2$1 from '@angular/cdk/portal';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, ComponentType } from '@angular/cdk/portal';
+import { Subject, Observable } from 'rxjs';
+import * as i1 from '@koobiq/components/core';
+import { KbqOverflowShadowState } from '@koobiq/components/core';
+import * as i2 from '@koobiq/components/scrollbar';
+import * as i3 from '@koobiq/components/button';
+import * as i4 from '@koobiq/components/icon';
+import * as i5 from '@koobiq/components/title';
+import * as i6 from '@angular/cdk/a11y';
+
+/** Injection token that can be used to access the data that was passed in to a sidepanel. */
+declare const KBQ_SIDEPANEL_DATA: InjectionToken<any>;
+declare enum KbqSidepanelPosition {
+    Right = "right",
+    Left = "left",
+    Top = "top",
+    Bottom = "bottom"
+}
+declare enum KbqSidepanelSize {
+    Small = "small",
+    Medium = "medium",
+    Large = "large"
+}
+declare class KbqSidepanelConfig<D = any> {
+    /** ID for the sidepanel. If omitted, a unique one will be generated. */
+    id?: string;
+    /**
+     * Persists whether this sidepanel is open, under this key, so the application can bring it back on
+     * the next visit — see `KbqSidepanelService.wasOpen()`.
+     *
+     * Omit it and nothing is persisted. The key is the opt-in because there is nothing else stable to
+     * persist under: a sidepanel lives in an overlay, and `id` falls back to a counter that means
+     * something different on every load.
+     */
+    stateSavingKey?: string;
+    /** Whether the focus trap is active. Defaults to whether the sidepanel has a backdrop. */
+    trapFocus?: boolean;
+    /** capture focus on initialization. This option sets cdkTrapFocusAutoCapture. Defaults to `true`. */
+    trapFocusAutoCapture?: boolean;
+    /**
+     * Accessible name of the sidepanel, used when no `kbq-sidepanel-header` names it and no
+     * `ariaLabelledBy` is given.
+     */
+    ariaLabel?: string;
+    /**
+     * Id of the element that labels the sidepanel. When omitted, `kbq-sidepanel-header` labels the
+     * sidepanel with its own title.
+     */
+    ariaLabelledBy?: string;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    position?: KbqSidepanelPosition;
+    size?: KbqSidepanelSize;
+    /** Whether the sidepanel has a backdrop. */
+    hasBackdrop?: boolean;
+    backdropClass?: string;
+    /** Whether the user can use escape or clicking outside to close the sidepanel. */
+    disableClose?: boolean;
+    /** Custom class for the overlay pane. */
+    overlayPanelClass?: string | string[];
+    /**
+     * Injector used for the instantiation of the component to be attached.
+     * Allows to pass a custom injector to provide a dependency injection hierarchy for the sidepanel content.
+     */
+    injector?: Injector;
+    /**
+     * Scroll strategy of the sidepanel overlay, resolved once when the sidepanel opens.
+     * Defaults to blocking the page scroll for sidepanels with a backdrop and to repositioning for the rest.
+     */
+    scrollStrategy?: () => ScrollStrategy;
+}
+
+declare const KBQ_SIDEPANEL_WITH_INDENT: InjectionToken<boolean>;
+declare class KbqSidepanelContainerComponent extends BasePortalOutlet implements OnDestroy {
+    private elementRef;
+    private changeDetectorRef;
+    private readonly injector;
+    sidepanelConfig: KbqSidepanelConfig<any>;
+    /** Whether the sidepanel moves without motion. */
+    protected readonly animationsDisabled: boolean;
+    /** Whether the panel exposes the clickable indent strip of the sidepanel stacked underneath it. */
+    get withIndent(): boolean;
+    set withIndent(value: boolean);
+    private readonly _withIndent;
+    /** ID for the container DOM element. */
+    id: string;
+    /**
+     * Id of the element naming the sidepanel. Comes from the config, or from `kbq-sidepanel-header`.
+     *
+     * @docs-private
+     */
+    get ariaLabelledBy(): string | null;
+    /** @docs-private */
+    set ariaLabelledBy(value: string | null);
+    private readonly _ariaLabelledBy;
+    /** The portal outlet inside of this container into which the content will be loaded. */
+    readonly portalOutlet: i0.Signal<CdkPortalOutlet>;
+    /** The transition in progress, ended early by the next one. */
+    private pendingTransition?;
+    /** Transition events held until the render that applies the state, in the order they happened. */
+    private readonly unreportedEvents;
+    /** Reports the held events once the next render is over. */
+    private reportAfterRender?;
+    /** @docs-private */
+    get size(): string;
+    /**
+     * Defaults to `true` in both modalities: it is what moves focus into the panel on open and returns
+     * it to the trigger on close, and `CdkTrapFocus` restores focus only when it captured it.
+     *
+     * @docs-private
+     */
+    get trapFocusAutoCapture(): boolean;
+    /** @docs-private */
+    get trapFocus(): boolean;
+    /** @docs-private */
+    protected readonly indentClickEmitter: Subject<MouseEvent>;
+    /** Whether the component has been destroyed. */
+    private destroyed;
+    ngOnDestroy(): void;
+    /**
+     * Gets an observable that emits when the indent has been clicked.
+     *
+     * @docs-private
+     */
+    indentClick(): Observable<MouseEvent>;
+    /** Attach a component portal as content to this sidepanel container. */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /** Attach a template portal as content to this sidepanel container. */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    /** Begin animation of the sidepanel entrance into view. */
+    enter(): void;
+    /** Begin animation of the sidepanel exiting from view. */
+    exit(): void;
+    /**
+     * Recomputes whether this panel exposes an indent strip, after the stack it belongs to changed.
+     *
+     * @docs-private
+     */
+    setWithIndent(withIndent: boolean): void;
+    /**
+     * Names the sidepanel after the title of its header. A name given through the config wins.
+     *
+     * @docs-private
+     */
+    setAriaLabelledBy(id: string): void;
+    /**
+     * Reports the transition to `state` starting, and ending once its CSS transition has.
+     *
+     * Both are reported after the render that applies the state, as the animation engine did, and never inside
+     * `open()` or `close()`: a subscriber that opens another sidepanel would otherwise do so before the stack the
+     * call is changing is complete, and one that subscribes right after the call would miss the start.
+     */
+    private startTransition;
+    private holdEvent;
+    private reportEvents;
+    private setPanelClass;
+    private get position();
+    private validatePortalAttached;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqSidepanelContainerComponent, "kbq-sidepanel-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqSidepanelRef<T = any, R = any> {
+    readonly containerInstance: KbqSidepanelContainerComponent;
+    readonly overlayRef: OverlayRef;
+    readonly config: KbqSidepanelConfig;
+    readonly id: string;
+    /**
+     * Vertical scroll overflow state of the sidepanel body.
+     * Updated on scroll and used for visual adjustments.
+     */
+    readonly bodyOverflow: i0.WritableSignal<KbqOverflowShadowState>;
+    /** Instance of the component making up the content of the sidepanel. */
+    instance: T;
+    /** Subject for notifying the user that the sidepanel has been closed and dismissed. */
+    private readonly afterClosed$;
+    /** Subject for notifying the user that the sidepanel starting closing. */
+    private readonly beforeClosed$;
+    /** Subject for notifying the user that the sidepanel has opened and appeared. */
+    private readonly afterOpened$;
+    /** Result to be passed down to the `afterDismissed` stream. */
+    private result;
+    /** Whether `close()` has already started the closing animation. */
+    private closing;
+    constructor(containerInstance: KbqSidepanelContainerComponent, overlayRef: OverlayRef, config: KbqSidepanelConfig);
+    close(result?: R): void;
+    /** Body of `close()`. */
+    private startClosing;
+    /** Gets an observable that is notified when the sidepanel is started closing. */
+    beforeClosed(): Observable<void>;
+    /** Gets an observable that is notified when the sidepanel is finished closing. */
+    afterClosed(): Observable<R | undefined>;
+    /** Gets an observable that is notified when the sidepanel has opened and appeared. */
+    afterOpened(): Observable<void>;
+    /**
+     * A pointer event outside this overlay closes the sidepanel only when it lands in a sidepanel of the
+     * same stack — that is the exposed strip of a panel opened over this one. Panels at other edges do
+     * not overlap this one and must not close it.
+     */
+    private isClickInsideSamePositionStack;
+}
+
+/**
+ * Button that will close the current sidepanel.
+ */
+declare class KbqSidepanelClose {
+    readonly sidepanelRef: KbqSidepanelRef<any, any>;
+    private readonly elementRef;
+    private readonly renderer;
+    /** Value handed to `KbqSidepanelRef.close()`, under the hyphenated spelling of the selector. */
+    readonly sidepanelResult: i0.InputSignal<any>;
+    /** The same value, under the camel-case spelling. */
+    readonly kbqSidepanelClose: i0.InputSignal<any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqSidepanelClose, "button[kbq-sidepanel-close], button[kbqSidepanelClose]", never, { "sidepanelResult": { "alias": "kbq-sidepanel-close"; "required": false; "isSignal": true; }; "kbqSidepanelClose": { "alias": "kbqSidepanelClose"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Header of a sidepanel.
+ */
+declare class KbqSidepanelHeader {
+    /** Accessible name for the icon-only close button. */
+    protected readonly a11yLocaleConfiguration: i0.Signal<i1.KbqA11yLocaleConfiguration>;
+    /** Add button for close sidepanel. Default false */
+    readonly closeable: i0.InputSignalWithTransform<boolean, unknown>;
+    /** Enables text truncation. Default true */
+    readonly truncateText: i0.InputSignalWithTransform<boolean, unknown>;
+    /** @docs-private */
+    protected sidepanelRef: KbqSidepanelRef<any, any>;
+    /** Id of the title element, which is what names the sidepanel to assistive technology. */
+    protected readonly titleId: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqSidepanelHeader, "kbq-sidepanel-header", never, { "closeable": { "alias": "closeable"; "required": false; "isSignal": true; }; "truncateText": { "alias": "truncateText"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.KbqLocaleOverridesDirective; inputs: { "kbqLocaleOverrides": "localeOverrides"; }; outputs: {}; }]>;
+}
+/**
+ * Scrollable content container of a sidepanel.
+ */
+declare class KbqSidepanelBody {
+    private readonly sidepanelRef;
+    private readonly overflowContainer;
+    private readonly scrollbarViewport;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqSidepanelBody, "kbq-sidepanel-body, [kbq-sidepanel-body], kbqSidepanelBody", never, {}, {}, never, never, true, [{ directive: typeof i1.KbqOverflowShadowContainer; inputs: {}; outputs: {}; }, { directive: typeof i2.KbqScrollbarViewport; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * Footer of a sidepanel.
+ */
+declare class KbqSidepanelFooter {
+    /** @docs-private */
+    protected sidepanelRef: KbqSidepanelRef<any, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqSidepanelFooter, "kbq-sidepanel-footer, [kbq-sidepanel-footer], kbqSidepanelFooter", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Actions block of a sidepanel footer.
+ */
+declare class KbqSidepanelActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqSidepanelActions, "kbq-sidepanel-actions, [kbq-sidepanel-actions], kbqSidepanelActions", never, {}, {}, never, never, true, never>;
+}
+
+declare class KbqSidepanelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqSidepanelModule, never, [typeof i1$1.OverlayModule, typeof i2$1.PortalModule, typeof i3.KbqButtonModule, typeof i4.KbqIconModule, typeof i5.KbqTitleModule, typeof i6.A11yModule, typeof KbqSidepanelContainerComponent, typeof KbqSidepanelClose, typeof KbqSidepanelHeader, typeof KbqSidepanelBody, typeof KbqSidepanelFooter, typeof KbqSidepanelActions], [typeof KbqSidepanelContainerComponent, typeof KbqSidepanelClose, typeof KbqSidepanelHeader, typeof KbqSidepanelBody, typeof KbqSidepanelFooter, typeof KbqSidepanelActions]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqSidepanelModule>;
+}
+
+/** Injection token that can be used to specify default sidepanel options. */
+declare const KBQ_SIDEPANEL_DEFAULT_OPTIONS: InjectionToken<KbqSidepanelConfig<any>>;
+/** The persisted state of a sidepanel — whether it was open. */
+interface KbqSidepanelState {
+    opened: boolean;
+}
+declare class KbqSidepanelService implements OnDestroy {
+    private overlay;
+    private overlayContainer;
+    private injector;
+    private defaultOptions;
+    private parentSidepanelService;
+    /** Sidepanels opened through this very instance, closed when this injector level is destroyed. */
+    private readonly openedSidepanelsAtThisLevel;
+    /** The shared stack. Only the root-most instance ever holds it; the rest reach it through the getter. */
+    private readonly rootOpenedSidepanels;
+    /** Sidepanels that hid the rest of the page from assistive technology when they opened. */
+    private readonly modalSidepanels;
+    /** Elements outside the overlay container that were hidden from assistive technology, and their previous state. */
+    private readonly ariaHiddenElements;
+    private readonly stateStore;
+    private readonly stateSavingService;
+    /**
+     * One entry per `stateSavingKey` this service has seen, so `KbqStateSavingService` reports what is
+     * stored as claimed. Without it a closed sidepanel's entry has nothing live behind it, and
+     * `clearOrphans()` would sweep away exactly what the next visit is meant to restore.
+     */
+    private readonly stateSavingRefs;
+    private readonly bulkClosedAtThisLevel;
+    /** Keeps track of the currently-open sidepanels. */
+    get openedSidepanels(): KbqSidepanelRef[];
+    /** The instance holding the shared stack and the assistive-technology bookkeeping. */
+    private get rootService();
+    /**
+     * The sidepanels being closed as a group rather than one at a time, whose close is not recorded.
+     *
+     * Shared up the chain like `openedSidepanels`: `closeAll()` reaches panels another instance opened,
+     * and it is that instance's subscription that would record the close.
+     */
+    private get bulkClosed();
+    ngOnDestroy(): void;
+    open<T, D = any>(componentOrTemplateRef: ComponentType<T> | TemplateRef<T>, config?: KbqSidepanelConfig<D>): KbqSidepanelRef<T>;
+    /** Body of `open()`. */
+    private openSidepanel;
+    /**
+     * Closes all of the currently-open sidepanels.
+     *
+     * Closing as a group is not recorded — see `wasOpen()`.
+     */
+    closeAll(): void;
+    /**
+     * Whether the sidepanel persisted under `key` was open when it was last recorded, so the
+     * application can open it again:
+     *
+     * ```ts
+     * if (sidepanel.wasOpen('filters')) this.openFilters();
+     * ```
+     *
+     * A sidepanel cannot restore itself the way the components that persist do. It exists only while it
+     * is open, so at the point the state would be read there is nothing left to read it — and what to
+     * reopen is a component class or a `TemplateRef` and its `data`, none of which survives being
+     * written to storage. This service keeps the flag; the application keeps the rest.
+     *
+     * What is recorded is a sidepanel opened and closed on its own. Closing a group — `closeAll()`, or
+     * this service being destroyed — leaves the flag alone, so a panel that was open when the page went
+     * away comes back whether the page was reloaded or navigated away from.
+     *
+     * Reading claims the key: from here on `KbqStateSavingService` reports the entry as this service's
+     * rather than orphaned. It has to happen on read, because for a sidepanel that is not open this is
+     * the only call there is.
+     */
+    wasOpen(key: string): boolean;
+    /**
+     * Removes what is persisted under `key`.
+     *
+     * Persistence itself stays on: a sidepanel opened under that key again is recorded again.
+     */
+    clearSavedState(key: string): void;
+    /**
+     * Finds an open sidepanel by its id.
+     *
+     * @param id ID to use when looking up the sidepanel.
+     */
+    getSidepanelById(id: string): KbqSidepanelRef | undefined;
+    /**
+     * Attaches the sidepanel container component to the overlay.
+     */
+    private attachContainer;
+    /**
+     * Creates a custom injector to be used inside the sidepanel. This allows a component loaded inside
+     * of a sidepanel to close itself and, optionally, to return a value.
+     *
+     * @param config Config object that is used to construct the sidepanel.
+     * @param sidepanelRef Reference to the sidepanel.
+     * @param sidepanelContainer Sidepanel container element that wraps all of the contents.
+     * @returns The custom injector that can be used inside the sidepanel.
+     */
+    private createInjector;
+    /**
+     * Creates a new overlay and places it in the correct location.
+     *
+     * @param config The user-specified sidepanel config.
+     */
+    private createOverlay;
+    /**
+     * `block()` pins the document with `position: fixed`, which is exactly what the non-modal mode
+     * promises not to do, so only a backdropped sidepanel gets it.
+     */
+    private resolveScrollStrategy;
+    /**
+     * `BlockScrollStrategy` refuses to engage while the page is already blocked, so in a stack the block
+     * belongs to the bottom-most backdropped sidepanel and has to be handed over when that one closes.
+     *
+     * @param closedIndex Index the closed sidepanel held in the stack, before it was removed.
+     */
+    private restoreScrollBlock;
+    private closeSidepanels;
+    /** Whether an already-open sidepanel persists under this key. */
+    private isStateSavingKeyInUse;
+    /** Records whether the sidepanel persisting under `key` is open. A sidepanel without a key is not. */
+    private writeState;
+    /** Reports the key to `KbqStateSavingService`, registering it the first time it is seen. */
+    private trackState;
+    private getOpenedSidepanelsWithSamePosition;
+    private updateAnimationState;
+    /**
+     * Moves a sidepanel into `state`, unless it is closing already.
+     *
+     * The exit animation is what disposes the overlay, so interrupting it with another state leaves the
+     * sidepanel in the DOM and in `openedSidepanels` for good — which is what closing a stack of them as
+     * a group used to do to the panels underneath.
+     */
+    private setAnimationState;
+    /**
+     * Removes a sidepanel from the array of open sidepanels.
+     *
+     * @param sidepanelRef Sidepanel to be removed.
+     */
+    private removeOpenSidepanel;
+    /**
+     * Only the top sidepanel of a position stack carries the indent, however deep the stack is — the strip
+     * is what reveals the panel underneath, and one per level is the visual noise the docs rule out.
+     *
+     * The flag belongs to the stack rather than to the panel that had one when it opened, so it is
+     * recomputed on both ends: opening demotes the panel that was on top, and closing a *lower* sidepanel
+     * would otherwise leave the top one exposing a strip of a panel that is no longer there.
+     */
+    private updateIndents;
+    /**
+     * A focus trap constrains Tab, not the virtual cursor, so everything outside the overlay stays
+     * reachable to a screen reader while a modal sidepanel is open unless it is hidden explicitly.
+     */
+    private hideContentFromAssistiveTechnology;
+    private revealContentForAssistiveTechnology;
+    private restoreContentForAssistiveTechnology;
+    private getLowerSidepanelsWithSamePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqSidepanelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KbqSidepanelService>;
+}
+
+export { KBQ_SIDEPANEL_DATA, KBQ_SIDEPANEL_DEFAULT_OPTIONS, KBQ_SIDEPANEL_WITH_INDENT, KbqSidepanelActions, KbqSidepanelBody, KbqSidepanelClose, KbqSidepanelConfig, KbqSidepanelContainerComponent, KbqSidepanelFooter, KbqSidepanelHeader, KbqSidepanelModule, KbqSidepanelPosition, KbqSidepanelRef, KbqSidepanelService, KbqSidepanelSize };
+export type { KbqSidepanelState };