@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-drawer.d.ts

@@ -0,0 +1,532 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, DrawerMessages } from '@slotted/core/i18n';
+import * as _slotted_core_extent from '@slotted/core/extent';
+import { ExtentSide } from '@slotted/core/extent';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, ElementRef, OnDestroy } from '@angular/core';
+
+/**
+ * Whether the drawer is a layer over the page or a box beside it.
+ *
+ * One axis rather than two components, because the switch is the point: an
+ * application binds it to its own breakpoint, and swapping one element for
+ * another there would destroy the view — taking the panel's scroll position,
+ * focus and every uncontrolled control inside it.
+ */
+type DrawerMode = 'overlay' | 'inline';
+/**
+ * Which edge the panel comes from. Logical, so the whole layout mirrors in a
+ * right-to-left document without a second stylesheet.
+ */
+type DrawerSide = ExtentSide;
+/**
+ * The panel's resting measure. Five named steps rather than a pixel string: a
+ * theme retunes a step and cannot retune `width: 400px`.
+ */
+type DrawerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'content';
+/** When the panel exists. */
+/**
+ * What a hand moves an overlay sheet from the bottom by. `panel` lets a touch
+ * anywhere on it move it and hand itself to the scroll of what it holds;
+ * `resizer` leaves the separator the only target. Only a bottom overlay sheet
+ * reads it.
+ */
+type DrawerDrag = 'panel' | 'resizer';
+type DrawerMount = 'active' | 'lazy' | 'eager';
+/** Whether a dismissal source closes the drawer. */
+type DrawerDismissPolicy = 'close' | 'none';
+/** Where focus goes when an overlay drawer opens. */
+type DrawerInitialFocus = 'first' | 'container' | HTMLElement | (() => HTMLElement | null) | false;
+/** Where focus goes when the drawer closes. Defaults to the trigger. */
+type DrawerFinalFocus = HTMLElement | false;
+/** Why the drawer opened or closed. */
+type DrawerOpenReason = 'pointer' | 'keyboard' | 'dismiss' | 'escape' | 'outsidePress' | 'back' | 'programmatic';
+/** Why the panel's measure moved. */
+type DrawerExtentReason = 'pointer' | 'keyboard' | 'programmatic';
+interface Request<Value, Reason> {
+    readonly value: Value;
+    readonly previous: Value;
+    readonly reason: Reason;
+    readonly source?: unknown;
+    readonly cancelled: boolean;
+    cancel(): void;
+}
+/**
+ * The request the family emits before the drawer moves, with the result the
+ * close carried. `result` is what the platform calls `returnValue` and what
+ * Angular Material returns from `afterClosed()`; it rides on the request rather
+ * than declaring a second state model, because nothing about it is controlled.
+ */
+interface DrawerChangeRequest extends Request<boolean, DrawerOpenReason> {
+    readonly result?: string | undefined;
+}
+/** The request the separator emits before the measure moves. */
+/**
+ * `undefined` is a value of this state and not the absence of one: it is the
+ * panel back on the measure its size step gives it, which is where it starts
+ * and where a double click on the separator puts it again.
+ */
+type DrawerExtentRequest = Request<number | undefined, DrawerExtentReason>;
+interface DrawerDefaults {
+    /** The platform's way back — a phone's gesture, a browser's button — closes a modal layer. */
+    back: DrawerDismissPolicy;
+    escape: DrawerDismissPolicy;
+    mode: DrawerMode;
+    modal: boolean;
+    mount: DrawerMount;
+    outsidePress: DrawerDismissPolicy;
+    side: DrawerSide;
+    /**
+     * Unset, the size the side gives: `content` on `top` and `bottom`, where
+     * every native sheet measures what it holds, and `md` on `start` and `end`.
+     */
+    size: DrawerSize | undefined;
+    drag: DrawerDrag;
+}
+declare const DRAWER_DEFAULTS: InjectionToken<DrawerDefaults>;
+/**
+ * An application decides once how its drawers behave and look, rather than
+ * repeating the same seven inputs on every one in a product. Ant reaches the
+ * same place through `ConfigProvider`; no React drawer in the surveyed set has
+ * an equivalent, and React gets one here too rather than being levelled down.
+ */
+declare function provideDrawerDefaults(defaults: Partial<DrawerDefaults>): {
+    provide: InjectionToken<DrawerDefaults>;
+    useFactory: () => DrawerDefaults;
+};
+/** What a drawer renders as here, before it states anything of its own. */
+declare function injectDrawerDefaults(): DrawerDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * a module-level counter produces colliding sequences when two applications
+ * render in one server process, and the server and the client sequences must
+ * match for hydration.
+ */
+declare class SlDrawerIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * A panel that comes in from an edge, and either covers the page or stands
+ * beside it.
+ *
+ * The layer is composed from `packages/core` and rewritten nowhere: `portal`
+ * decides where it lives and keeps the theme of the region that opened it,
+ * `dismissable-layer` owns Escape, outside press, `inert`, the scroll lock and
+ * the single z-index stack, `presence` keeps it mounted long enough to leave,
+ * `focus` contains the keyboard and gives it back to the trigger, and `extent`
+ * holds the arithmetic the separator's pointer and keyboard share.
+ *
+ * **The host is not the layer.** `<sl-drawer>` renders `display: contents` and
+ * stays exactly where the consumer wrote it; the layer is the `div` in the
+ * template. Under `mode="overlay"` that `div` is moved into the portal and
+ * given back before it is destroyed; under `mode="inline"` it never moves,
+ * which is what makes the host's own parent the drawer's place in the layout.
+ * Either way the host is the portal's *origin*, so the layer keeps the scheme,
+ * density, theme and direction of the region it was written in whether or not
+ * a trigger exists — React has to use the trigger for that, and
+ * `docs/history/designs/2026-09-04-drawer-design.md` §11 records the
+ * asymmetry rather than levelling both down.
+ */
+declare class SlDrawer implements OnInit {
+    /** Whether the drawer is open. Two-way, so a template may bind it directly. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * How much of the box the panel is measured in it takes, in `[0, 1]`. Unset
+     * means the `size` step decides. It is a fraction rather than a length so
+     * that the separator's three ARIA values, the limits and the snap points are
+     * all the same kind of number.
+     */
+    readonly extent: _angular_core.ModelSignal<number | undefined>;
+    readonly mode: _angular_core.InputSignal<DrawerMode | undefined>;
+    readonly side: _angular_core.InputSignal<_slotted_core_extent.ExtentSide | undefined>;
+    readonly size: _angular_core.InputSignal<DrawerSize | undefined>;
+    readonly mount: _angular_core.InputSignal<DrawerMount | undefined>;
+    readonly escape: _angular_core.InputSignal<DrawerDismissPolicy | undefined>;
+    readonly outsidePress: _angular_core.InputSignal<DrawerDismissPolicy | undefined>;
+    /**
+     * The platform's way back — a phone's gesture, a browser's button — closes
+     * the layer instead of leaving the page, while the layer is modal.
+     */
+    readonly back: _angular_core.InputSignal<DrawerDismissPolicy | undefined>;
+    /**
+     * Whether the background is inert, the scroll is locked and focus is
+     * contained. Fixed at `false` under `mode="inline"`: a panel in the flow that
+     * claimed `aria-modal` while the page around it stayed reachable is the
+     * failure the APG calls severe.
+     */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the panel's content is still on its way. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Words laid over the catalog of the language in force, key by key: the close control's name (`close`). */
+    readonly messages: _angular_core.InputSignal<PartialMessages<DrawerMessages> | undefined>;
+    /** What a hand moves an overlay sheet from the bottom by. */
+    readonly drag: _angular_core.InputSignal<DrawerDrag | undefined>;
+    /**
+     * Below this fraction the scrim is not painted and a press reaches the page:
+     * the sheet over a map. It pairs with `[modal]="false"` and
+     * `outsidePress="none"`, because a page left undimmed and inert would promise
+     * something it does not do.
+     */
+    readonly scrimFrom: _angular_core.InputSignal<number>;
+    /** The smallest the reader may make it. A drag released below it asks to close. */
+    readonly minExtent: _angular_core.InputSignal<number>;
+    readonly maxExtent: _angular_core.InputSignal<number>;
+    /** The stops the separator lands on. Empty means the range is continuous. */
+    readonly snapPoints: _angular_core.InputSignal<readonly number[]>;
+    /** A parent for this layer alone, instead of the shared portal root. */
+    readonly container: _angular_core.InputSignal<Element | null | undefined>;
+    readonly initialFocus: _angular_core.InputSignal<DrawerInitialFocus | undefined>;
+    readonly finalFocus: _angular_core.InputSignal<DrawerFinalFocus | undefined>;
+    /** One output per transition, each carrying its reason and its event. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<DrawerChangeRequest>;
+    readonly extentChangeRequest: _angular_core.OutputEmitterRef<DrawerExtentRequest>;
+    /**
+     * What `afterClosed()` is in Angular Material, as an output. It fires once
+     * the drawer has actually closed, with the result the close carried.
+     */
+    readonly closed: _angular_core.OutputEmitterRef<string | undefined>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this drawer's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<DrawerMessages>;
+    private readonly host;
+    /** The server lays nothing out, and its DOM cannot be measured. */
+    private readonly browser;
+    private readonly destroyRef;
+    private readonly baseId;
+    /** The element the consumer wrote us beside, recorded before anything moves. */
+    private readonly origin;
+    /**
+     * A consumer's own `aria-label` on `<sl-drawer>`, read before the host
+     * bindings are written and moved to the panel, which is the element the role
+     * is on. Without this a label written on the host would name a box with
+     * `display: contents` and no role at all.
+     */
+    private readonly writtenLabel;
+    protected readonly layerRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly panelRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** The parts that have said they exist, so only what was rendered is wired. */
+    readonly hasTitle: _angular_core.WritableSignal<boolean>;
+    readonly hasDescription: _angular_core.WritableSignal<boolean>;
+    readonly triggerNode: _angular_core.WritableSignal<HTMLElement | null>;
+    /** Whether the reader has the separator under the pointer. */
+    readonly dragging: _angular_core.WritableSignal<boolean>;
+    /**
+     * Where the hand is holding the panel while the body is dragged, which may be
+     * past the highest stop. `null` outside a gesture: the request is made once,
+     * on release, rather than once per move.
+     */
+    readonly live: _angular_core.WritableSignal<number | null>;
+    /**
+     * What the panel measures at rest — the height of its content under
+     * `size="content"` — as a fraction, measured while `extent` is unset.
+     */
+    readonly rest: _angular_core.WritableSignal<number | undefined>;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    readonly panelId: string;
+    readonly triggerId: string;
+    /**
+     * The status rather than a boolean. `entering` is one frame long and it is
+     * the whole reason it exists: a panel that appears already open gives its CSS
+     * transition no closed style to start from.
+     */
+    private readonly status;
+    private readonly presence;
+    /** Whether this drawer has ever been open, which is what `lazy` reads. */
+    private readonly seen;
+    private readonly result;
+    /** The measured length the stylesheet reads, kept in step by an observer. */
+    private readonly measured;
+    readonly resolvedMode: _angular_core.Signal<DrawerMode>;
+    readonly resolvedSide: _angular_core.Signal<_slotted_core_extent.ExtentSide>;
+    /**
+     * A sheet measures what it holds and a side panel takes a named step: every
+     * native sheet sizes to its content, and Ant, Fluent and MUI all give a side
+     * panel a width. The side decides only when nothing else has.
+     */
+    readonly resolvedSize: _angular_core.Signal<DrawerSize>;
+    readonly resolvedDrag: _angular_core.Signal<DrawerDrag>;
+    /** An overlay sheet from the bottom, which is the only panel a body drag moves. */
+    readonly sheet: _angular_core.Signal<boolean>;
+    /** The measure right now: the hand's while a body drag holds it, the state otherwise. */
+    readonly currentExtent: _angular_core.Signal<number | undefined>;
+    protected readonly undimmed: _angular_core.Signal<boolean>;
+    readonly resolvedMount: _angular_core.Signal<DrawerMount>;
+    readonly resolvedModal: _angular_core.Signal<boolean>;
+    readonly resolvedEscape: _angular_core.Signal<DrawerDismissPolicy>;
+    readonly resolvedBack: _angular_core.Signal<DrawerDismissPolicy>;
+    readonly resolvedOutsidePress: _angular_core.Signal<DrawerDismissPolicy>;
+    /**
+     * The limits are the first and last stop when there are stops, because a
+     * range whose ends no stop can reach has two values nothing produces.
+     */
+    readonly bounds: _angular_core.Signal<{
+        min: number;
+        max: number;
+    }>;
+    /**
+     * An inline drawer is always in the document: its own measure is what opens
+     * and closes, and a box that left the layout would take the page's columns
+     * with it every time the reader closed the panel.
+     */
+    readonly mounted: _angular_core.Signal<boolean>;
+    /** What the stylesheet keys on, which is a frame behind what was asked. */
+    readonly visible: _angular_core.Signal<boolean>;
+    /**
+     * Whether the layer takes focus and the pointer. `entering` counts: the
+     * focus scope enters in that frame, and a layer still `inert` then refuses
+     * the initial focus and leaves it on `body`.
+     */
+    readonly interactive: _angular_core.Signal<boolean>;
+    /**
+     * The scrim belongs to the layer, not to the dismissal policy: `modal`
+     * decides what happens to the page behind it and never what is painted.
+     * `dialog` draws it the same way, and a consumer who wants none sets
+     * `--slotted-drawer-scrim: transparent`.
+     */
+    protected readonly showBackdrop: _angular_core.Signal<boolean>;
+    protected readonly extentLength: _angular_core.Signal<string | null>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly label: _angular_core.Signal<string | null>;
+    /**
+     * Under `inline` the panel is a region of the page rather than a window over
+     * it, so it writes no role: a navigation drawer is a navigation landmark and
+     * a filter panel is complementary, and a family that cannot know which one
+     * guesses wrong half the time. A consumer names it on their own element.
+     */
+    protected readonly role: _angular_core.Signal<"dialog" | null>;
+    private portal;
+    private layer;
+    private scope;
+    /**
+     * What the consumer's own binding said before the reader moved anything.
+     *
+     * Read in `ngOnInit` and not in the field initializer: Angular creates every
+     * directive in a template before it binds any input, so a measure read at
+     * construction is always the model's own default and never the consumer's.
+     */
+    private initialExtent;
+    ngOnInit(): void;
+    constructor();
+    /** The stops a sheet rests on and the rest among them, measured now. */
+    measureStops(panel: HTMLElement, span: number): {
+        rest: number | undefined;
+        stops: number[];
+    };
+    /**
+     * What a settled fraction is asked as: the content stop is `undefined`, so
+     * the sheet follows its content again when the content grows.
+     */
+    asRequest(fraction: number, rest: number | undefined): number | undefined;
+    /**
+     * The box the panel's measure is a fraction of: the layer under `overlay`,
+     * which is fixed to the viewport, and the drawer's own parent under `inline`,
+     * where the drawer is what is being sized and cannot measure itself.
+     */
+    measuringBox(): HTMLElement | null;
+    /**
+     * The layer element is given back to the host before the portal goes, so
+     * Angular removes a node that is where its own view expects it to be.
+     */
+    private releasePortal;
+    /** Asks to open or close, carrying the reason, the result and the event. */
+    request(next: boolean, reason: DrawerOpenReason, result: string | undefined, source: unknown): void;
+    /**
+     * Asks to move the measure. While the pointer is down the floor is not
+     * enforced — a sheet the reader is pulling down has to follow the hand — and
+     * the separator decides on release whether that means a smaller panel or a
+     * closed one.
+     */
+    requestExtent(next: number | undefined, reason: DrawerExtentReason, source: unknown): void;
+    /**
+     * Back to the measure the size step gives it, which is where the panel
+     * started. Angular has one model rather than a controlled and an
+     * uncontrolled input, so the measure to restore is the one the model held
+     * before anything moved it, read once.
+     */
+    restoreExtent(reason: DrawerExtentReason, source: unknown): void;
+    /** Opens the drawer from code, carrying `programmatic`. */
+    openDrawer(): void;
+    /** Closes it from code, carrying `programmatic` and the result given. */
+    close(result?: string): void;
+    /**
+     * The panel, once it is in the document — what React's handle calls
+     * `panel`. A family that composes the drawer reads it to hand the panel a
+     * value only it knows, as `action-sheet` hands it its measure.
+     */
+    get panel(): HTMLElement | null;
+    /** Moves focus into the panel, as opening an overlay drawer does. */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDrawer, "sl-drawer", ["slDrawer"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "extent": { "alias": "extent"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "escape": { "alias": "escape"; "required": false; "isSignal": true; }; "outsidePress": { "alias": "outsidePress"; "required": false; "isSignal": true; }; "back": { "alias": "back"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "drag": { "alias": "drag"; "required": false; "isSignal": true; }; "scrimFrom": { "alias": "scrimFrom"; "required": false; "isSignal": true; }; "minExtent": { "alias": "minExtent"; "required": false; "isSignal": true; }; "maxExtent": { "alias": "maxExtent"; "required": false; "isSignal": true; }; "snapPoints": { "alias": "snapPoints"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "finalFocus": { "alias": "finalFocus"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "extent": "extentChange"; "openChangeRequest": "openChangeRequest"; "extentChangeRequest": "extentChangeRequest"; "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The control that opens a drawer.
+ *
+ * It is the consumer's own element, which is what this ecosystem composes with:
+ * `<button slButton [slDrawerTrigger]="d">` is the library's own button and
+ * this adds the wiring to it. React reaches the same place with `render`,
+ * because there the component owns the tag.
+ *
+ * The trigger is also an overlay layer's *branch*: a press on it is inside the
+ * layer as far as `dismissable-layer` is concerned, or opening would
+ * immediately be read as an outside press and close what it just opened.
+ *
+ * `aria-haspopup` is written only under `mode="overlay"`. An inline drawer is a
+ * disclosure, not a popup, and the property would promise a layer that never
+ * arrives.
+ */
+declare class SlDrawerTrigger implements OnInit, OnDestroy {
+    /** The drawer this control opens, reached with a template reference variable. */
+    readonly drawer: _angular_core.InputSignal<SlDrawer>;
+    private readonly native;
+    /**
+     * `trigger` names the control when it belongs to no family of its own. On
+     * `slButton` the element is that family's root, and the part stays `root`:
+     * two directives write one attribute, and the family the element is drawn by
+     * keeps it, as React's `render` does by spreading the button's props last.
+     */
+    protected readonly part: string | null;
+    protected readonly controls: _angular_core.Signal<string | null>;
+    protected readonly haspopup: _angular_core.Signal<"dialog" | null>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDrawerTrigger, "[slDrawerTrigger]", ["slDrawerTrigger"], { "drawer": { "alias": "slDrawerTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SlDrawerHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDrawerHeader, "[slDrawerHeader]", ["slDrawerHeader"], {}, {}, never, never, true, never>;
+}
+/**
+ * The visible name, which `aria-labelledby` points at — on the panel and, as
+ * the Window Splitter pattern requires, on the separator that sizes it.
+ */
+declare class SlDrawerTitle implements OnInit, OnDestroy {
+    protected readonly drawer: SlDrawer;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDrawerTitle, "[slDrawerTitle]", ["slDrawerTitle"], {}, {}, never, never, true, never>;
+}
+/** The sentence that says what the drawer is about. */
+declare class SlDrawerDescription implements OnInit, OnDestroy {
+    protected readonly drawer: SlDrawer;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDrawerDescription, "[slDrawerDescription]", ["slDrawerDescription"], {}, {}, never, never, true, never>;
+}
+/**
+ * The one row that scrolls, and the row `aria-busy` belongs to while the
+ * content is still on its way — the header, the close button, Escape and the
+ * separator all stay operable, because a drawer a reader cannot leave is the
+ * worse failure of the two.
+ */
+declare class SlDrawerBody {
+    protected readonly drawer: SlDrawer;
+    /** `none` drops the body's own padding, for content that brings its own inset — a page, a list on the panel's edges. */
+    readonly inset: _angular_core.InputSignal<"none" | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDrawerBody, "[slDrawerBody]", ["slDrawerBody"], { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SlDrawerFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlDrawerFooter, "[slDrawerFooter]", ["slDrawerFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * The ✕ in the corner. It carries `dismiss`, which is the word the closed
+ * vocabulary in `docs/state-and-events.md` already has for what a close button
+ * means, and its `value` rides out on the request as the result.
+ */
+declare class SlDrawerClose {
+    /** The result the close carries out, which is the platform's `returnValue`. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    private readonly drawer;
+    /** A consumer's own `aria-label`, which wins over the catalog. */
+    private readonly ownLabel;
+    protected readonly label: _angular_core.Signal<string>;
+    protected press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDrawerClose, "[slDrawerClose]", ["slDrawerClose"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class SlDrawerResizer {
+    /**
+     * How far one arrow press moves the separator, **in pixels**, when there are
+     * no snap points. A distance and not a proportion: a reader adjusting a pane
+     * is placing an edge against the content beside it, and a proportion of a
+     * wide layer is a jump.
+     */
+    readonly step: _angular_core.InputSignal<number>;
+    /** How far `Shift` and an arrow move it, in pixels. */
+    readonly largeStep: _angular_core.InputSignal<number>;
+    protected readonly drawer: SlDrawer;
+    private readonly native;
+    /** Where the pointer last was, which is what decides a dismissal on release. */
+    private dragged;
+    /** Where the pointer has been, for the velocity the release reads. */
+    private samples;
+    /**
+     * Where the press began and how far the panel's edge was from the pointer
+     * then. The panel follows the pointer from that offset rather than jumping
+     * its edge under it, so a press that does not move is a tap and moves nothing.
+     */
+    private press;
+    /** What `Enter` restores to once it has collapsed the panel. */
+    private collapsed;
+    /** What the document looked like before the drag, and how to put it back. */
+    private gesture;
+    protected readonly orientation: _angular_core.Signal<"vertical" | "horizontal">;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly floor: _angular_core.Signal<number>;
+    protected readonly valueNow: _angular_core.Signal<number>;
+    protected percent(value: number): number;
+    private current;
+    private isRtl;
+    private span;
+    /**
+     * The stops the keyboard, the release and a tap share. Without snap points
+     * the range is continuous and there are none — the content stop joins only a
+     * list the consumer started, or a separator with no stops would stop moving.
+     */
+    private stopsNow;
+    private fractionAt;
+    protected pointerDown(event: PointerEvent): void;
+    protected pointerMove(event: PointerEvent): void;
+    /**
+     * A tap walks the stops upward and wraps from the highest to the lowest,
+     * which is what the grabber of a native sheet does and what Ionic calls
+     * `handleBehavior="cycle"`. A separator with no stops has nowhere to walk.
+     */
+    private cycle;
+    /**
+     * Where the release lands. With stops it is `settleExtent`, the same rule
+     * the sheet's body answers: the closed position is the stop `0`, a fling goes
+     * to the next stop, anything slower to the nearest to where it was heading.
+     * Without stops the range is continuous — resizing is what a separator does
+     * on a desktop screen — and only the floor, or a fling toward the edge, asks
+     * to close. A close the consumer cancels leaves the panel at the floor.
+     */
+    protected endDrag(event: PointerEvent): void;
+    /**
+     * Back to the measure the size step gives it, which is what `undefined`
+     * means for this state. It is the one gesture in the family that restores
+     * rather than moves, and every desktop pane divider answers a double click
+     * with it.
+     */
+    protected restore(event: MouseEvent): void;
+    protected keyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlDrawerResizer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlDrawerResizer, "[slDrawerResizer]", ["slDrawerResizer"], { "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DRAWER_DEFAULTS, SlDrawer, SlDrawerBody, SlDrawerClose, SlDrawerDescription, SlDrawerFooter, SlDrawerHeader, SlDrawerIdFactory, SlDrawerResizer, SlDrawerTitle, SlDrawerTrigger, injectDrawerDefaults, provideDrawerDefaults };
+export type { DrawerChangeRequest, DrawerDefaults, DrawerDismissPolicy, DrawerDrag, DrawerExtentReason, DrawerExtentRequest, DrawerFinalFocus, DrawerInitialFocus, DrawerMode, DrawerMount, DrawerOpenReason, DrawerSide, DrawerSize };
+//# sourceMappingURL=slotted-angular-drawer.d.ts.map

package/types/slotted-angular-drawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-drawer.d.ts","sources":["../../drawer/src/drawer-defaults.ts","../../drawer/src/drawer.ts","../../drawer/src/drawer-parts.ts"],"mappings":"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","names":[]}