`. The class lands on the * same `[forDrawer]` host as {@link class}. Falls back to * `provideForDrawerDefaults({ animateEnter })`. */ animateEnter?: string; /** * CSS class applied to the overlay root when `close()` is called. The manager * keeps the host mounted with this class until its CSS animations / * transitions finish, then tears the drawer down — so a programmatic drawer * plays an exit animation. `close()` still resolves its promise and flips * `isClosed()` immediately; only the visual teardown waits. With no class (or * no animation, or under `prefers-reduced-motion`), close is immediate. Falls * back to `provideForDrawerDefaults({ animateLeave })`. */ animateLeave?: string; /** * Exit-animation class for the portaled `[forDrawerBackdrop]`: the manager * adds it when `close()` is called and keeps the backdrop mounted until the * animation finishes, so the backdrop fades out in lockstep with the host. * * The split with the enter animation is intentional, not an oversight. * Declare the backdrop's **enter** with `animate.enter="…"` on the element * itself — it fires on mount, which Angular runs normally even inside the * manager's `ngComponentOutlet` — and declare only its **leave** here. A * template `animate.leave` on the backdrop never fires under the manager: * Angular does not run leave animations across the `ngComponentOutlet` the * opened component is mounted through. (The host sheet is symmetric — both * `animateEnter` and `animateLeave` are config, since the manager owns that * element.) Falls back to `provideForDrawerDefaults({ backdropAnimateLeave })`. */ backdropAnimateLeave?: string; /** When true (default), pointer drag past `closeThreshold` dismisses. */ swipeToDismiss?: boolean; /** Fraction of dimension past which a release dismisses. Default `0.25`. */ closeThreshold?: number; /** When true, swipe only arms on a registered handle element. Default `false`. */ handleOnly?: boolean; /** * When true, asks the registered `[forDrawerWrapper]` to scale and translate * behind this drawer (the "scale background" effect). No effect under * `prefers-reduced-motion: reduce`, and a no-op if no wrapper is mounted. */ scaleBackground?: boolean; /** * When true (default) and `scaleBackground` is active, paints `` with * `scaleBackgroundColor` so the gap between the scaled wrapper and the * viewport edge does not show through. */ setBackgroundColorOnScale?: boolean; /** Snap points. Optional. */ snapPoints?: ReadonlyArray; /** Initial snap point at open time. Defaults to `snapPoints?.[0]`. */ defaultSnapPoint?: ForDrawerSnapPoint; /** First snap-point index from which the backdrop reflects `data-fade-from-active`. */ fadeFromIndex?: number; /** * Consumer CSS class(es) applied to the overlay root (the `[forDrawer]` * host). Pass a single class (`'my-drawer'`) or a space-separated string. * Merged with the directive's own host attributes — it never clobbers * `data-side` / `data-state` / the `--for-drawer-swipe-movement-x` / `-y` * custom properties. * * Use this to carry design-system classes onto a programmatic drawer, * including positioning CSS keyed on `data-side` (e.g. * `.my-drawer[data-side='bottom']`). It replaces the * `inject(FOR_DRAWER_CONTEXT).hostElement.classList.add(...)` workaround. * For multiple classes as an array, prefer {@link classList}. */ class?: string; /** * Consumer CSS class(es) applied to the overlay root, as an array * (`['my-drawer', 'my-drawer--lg']`) or a space-separated string. Merged * with {@link class} and with the directive's own host attributes. */ classList?: string | readonly string[]; /** Extra providers for the opened component's injector. */ providers?: Provider[]; /** * Caller scope for this `open()`. When supplied, `ForDrawerManager` resolves * `provideForDrawerDefaults` from this injector (instead of the root injector * it was constructed in) and parents the opened component on it — so a scoped * defaults configuration and any other scoped providers (a lazy route, a * component `providers`) reach the programmatic drawer. Per-`open()` config * values still win over the resolved scoped defaults. Omit it to keep today's * root-scope behavior. Pass the ambient `inject(Injector)` from the caller — * `open()` is normally invoked outside an injection context, so an explicit * handle is the predictable contract. */ injector?: Injector; /** * Fires just before the drawer moves focus into itself on mount. * Call `event.preventDefault()` to skip the imperative focus move. */ autoFocusOnOpen?: (event: VetoableEvent) => void; /** * Fires just before focus returns to the previously focused element * on unmount. Call `event.preventDefault()` to skip the return-focus. */ autoFocusOnClose?: (event: VetoableEvent) => void; /** * Per-channel dismiss hook mirroring the declarative `(escapeKeyDown)` * output. Fires when Escape is pressed while this drawer is the topmost * dismissible layer. Call `event.preventDefault()` on the veto to suppress * the implicit close while keeping the other dismiss channels live. The * original `KeyboardEvent` is on `.event`. */ escapeKeyDown?: (event: VetoableNativeEvent) => void; /** * Per-channel dismiss hook mirroring the declarative `(pointerDownOutside)` * output. Fires when a pointer goes down outside the drawer. Call * `event.preventDefault()` on the veto to suppress the implicit close. The * native `PointerEvent` is on `.event`. */ pointerDownOutside?: (event: VetoableNativeEvent) => void; /** * Per-channel dismiss hook mirroring the declarative `(focusOutside)` * output. Fires when focus moves outside the drawer. Call * `event.preventDefault()` on the veto to suppress the implicit close. The * native `FocusEvent` is on `.event`. */ focusOutside?: (event: VetoableNativeEvent) => void; /** * Composite dismiss hook mirroring the declarative `(interactOutside)` * output. Fires alongside `pointerDownOutside` / `focusOutside` and shares * their veto state — `event.preventDefault()` on either suppresses the * implicit close. Use this to keep a programmatic floater open on outside * interaction while leaving Escape live (set `dismissible: true` and veto * here). The native `PointerEvent | FocusEvent` is on `.event`. */ interactOutside?: (event: VetoableNativeEvent) => void; /** * Mirrors the declarative `(swipeStart)` output: invoked once when the * gesture arms, with `progress` `0`. */ swipeStart?: (event: ForDrawerSwipeEvent) => void; /** * Mirrors the declarative `(swipeMove)` output: invoked on every pointer-move * frame with `progress` ∈ `[0, 1]`. Lets a programmatic consumer drive * bespoke swipe visualizations the way the directive consumer can. */ swipeMove?: (event: ForDrawerSwipeEvent) => void; /** * Mirrors the declarative `(swipeEnd)` output: invoked on pointer-up, after * the directive has resolved the next snap point / close decision. Read * `willClose` and `nextSnapPoint` from the payload. */ swipeEnd?: (event: ForDrawerSwipeEndEvent) => void; /** * Mirrors the declarative `(swipeCancel)` output: invoked on `pointercancel` * or a mid-gesture direction abort. */ swipeCancel?: (event: ForDrawerSwipeEvent) => void; /** * Mirrors the declarative `(activeSnapPointChange)` output: invoked with * the landed snap point whenever the drawer transitions internally * (mount-time default and drag release). Use this to read back the active * snap that the declarative API exposes via `[(activeSnapPoint)]`. */ activeSnapPointChange?: (snapPoint: ForDrawerSnapPoint | null) => void; } /** * Programmatic drawer opener — symmetric with `ForDialogManager`. Inject * anywhere, call `open(MyComponent, { data, side, ... })` and get a * `ForDrawerRef` back. `animate.leave` on the opened component runs before * the node leaves the DOM, identical to the declarative * `@if (open()) {

}` path. * * Inside the opened component the usual drawer pieces work without any extra * wiring: `[forDrawerTitle]`, `[forDrawerDescription]`, `[forDrawerBackdrop]`, * `[forDrawerHandle]`, `[forDrawerClose]`. `[forDrawerClose] [closeWith]` * propagates through to `ForDrawerRef.close(value)`. * * Inject `ForDrawerRef` to drive close imperatively and `FOR_DRAWER_DATA` (or * `injectDrawerData()`) for the payload. * * **When the overlay DOM is available.** In the common case the drawer mounts * synchronously, so a `document.querySelector('[role="dialog"]')` right after * `open()` finds it. When `open()` is called from within change detection — an * `effect`, `ngOnInit`, or an `afterNextRender` callback — the synchronous * mount is deferred to the next render (a nested change-detection tick is * illegal), so query the DOM after the next render. The returned * `ForDrawerRef` is usable immediately in both cases. */ declare class ForDrawerManager extends OverlayManagerCore { #private; constructor(); open(component: Type, config?: ForDrawerOpenConfig): ForDrawerRef; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Defaults inherited by descendant drawers in the surrounding injector * scope. Configure with `provideForDrawerDefaults`. Keys map 1:1 to the * directive inputs of the same name; the directive picks * `consumerInput ?? defaults[key] ?? hardcoded fallback` per key. * * **Scope caveat (declarative vs. programmatic).** Declarative `[forDrawer]` * instances read this token from their own injector, so a scoped * `provideForDrawerDefaults` (a lazy route, a component `providers`) reaches * every drawer rendered under that scope. `ForDrawerManager` is * `providedIn: 'root'` and resolves the token **once, from the root injector**, * so by default only application-root `provideForDrawerDefaults` affects * `ForDrawerManager.open()` — a scoped override does not. To honor a caller's * scope, pass its injector on the `open()` config * (`open(Cmp, { injector: inject(Injector) })`): the manager then resolves * these defaults from that injector. Either way, a per-`open()` config value * always wins. */ interface ForDrawerDefaults { /** Default `'bottom'`. */ side?: ForDrawerSide; /** Default `true`. Modal locks scroll, traps focus, applies `aria-modal`. */ modal?: boolean; /** Default `true`. Whether dismiss interactions (Escape, backdrop, swipe) close. */ dismissible?: boolean; /** Default `true`. Pointer drag gesture toward the anchored edge dismisses. */ swipeToDismiss?: boolean; /** * Default `0.25`. Fraction past which a release dismisses instead of * snapping back: of the full dimension without snap points, of the lowest * snap's extent with them (see * `_internal/snap-points/resolveSnapTarget`). */ closeThreshold?: number; /** Default `'first'`. Where to send focus on mount. */ initialFocus?: 'first' | 'container'; /** Default `true`. Restore focus to the previously focused element on close. */ returnFocus?: boolean; /** * Default `false`. When `true` the swipe gesture only arms on the * registered `[forDrawerHandle]` element instead of the whole surface. */ handleOnly?: boolean; /** * Default `false`. When `true`, an open drawer asks * `[forDrawerWrapper]` to scale + translate behind it (the "scale * background" effect). Suppressed under * `prefers-reduced-motion: reduce`. */ scaleBackground?: boolean; /** * Default `true`. When `scaleBackground` is active, paints the body * with `scaleBackgroundColor` so the sliver of viewport between the * scaled wrapper and the screen edge does not show through. */ setBackgroundColorOnScale?: boolean; /** Default `0.95`. Scale factor applied to the wrapper. */ scaleAmount?: number; /** * Default `14`. Vertical translation (in CSS pixels) added to * `env(safe-area-inset-top)` while the wrapper is scaled. */ scaleTranslateYpx?: number; /** Default `8`. Border radius applied to the wrapper while scaled. */ scaleBorderRadiusPx?: number; /** * Default `'black'`. Body background colour applied while * `setBackgroundColorOnScale` is active. */ scaleBackgroundColor?: string; /** * Default `0.93`. Scale factor applied to a parent drawer while a * nested child drawer is active. Composes with the wrapper-level * `scaleBackground` effect when both opt in. Suppressed under * `prefers-reduced-motion: reduce`. */ nestedScaleAmount?: number; /** * Default `8`. Pixels of additional translation applied to a parent * drawer while a nested child is active, in the direction *away* from * the parent's anchored edge (so a `bottom` drawer slides up by this * amount when its child opens). */ nestedTranslateYpx?: number; /** * CSS class applied (via `animate.enter`) to the programmatic overlay host * when it mounts, so it plays an enter animation. The class lands on the * `[forDrawer]` host that also carries the consumer `class`. No default. */ animateEnter?: string; /** * CSS class applied to the programmatic overlay host when `close()` is * called, kept on the still-mounted host until its CSS animations finish so * an exit transition plays before teardown. No default (close is immediate). */ animateLeave?: string; /** * CSS class applied to the portaled `[forDrawerBackdrop]` when `close()` is * called, so the backdrop plays an exit animation in lockstep with the * host. Needed because a backdrop declared inside the opened component plays * its `animate.enter` on mount but cannot run its template `animate.leave` — * Angular does not process leave animations across the `ngComponentOutlet` * boundary the manager mounts the component through. No default. */ backdropAnimateLeave?: string; } /** Token holding the resolved drawer defaults for the current scope. */ declare const FOR_DRAWER_DEFAULTS: _angular_core.InjectionToken; /** * Configures forty-cdk drawer defaults for this injector scope. Partial * overrides inherit unspecified keys from the parent scope (or library * defaults at the root). * * Declarative `[forDrawer]` reads the nearest scope; `ForDrawerManager.open()` * (root-provided) only sees an application-root configuration unless the caller * passes its `injector` on the `open()` config — see the scope caveat on * {@link ForDrawerDefaults}. */ declare function provideForDrawerDefaults(defaults?: Partial): Provider[]; export { FOR_DRAWER_CONTEXT, FOR_DRAWER_DATA, FOR_DRAWER_DEFAULTS, ForDrawer, ForDrawerBackdrop, ForDrawerClose, ForDrawerDescription, ForDrawerHandle, ForDrawerManager, ForDrawerRef, ForDrawerTitle, ForDrawerTrigger, ForDrawerWrapper, injectDrawerData, provideForDrawerDefaults }; export type { ForDrawerCloseReason, ForDrawerContext, ForDrawerDefaults, ForDrawerOpenConfig, ForDrawerSnapPoint, ForDrawerSwipeEndEvent, ForDrawerSwipeEvent };