@breadstone/mosaik-elements-foundation 0.1.50 → 0.1.51

package/Controls/Components/Overlays/MessageBox/Themes/MessageBoxElement.Memphis.js

@@ -201,6 +201,7 @@ export function messageBoxElementMemphisStyle() {
   align-items: center;
   gap: var(--message-box-gap);
   flex-direction: row;
+  flex: 0;
   display: flex;
   position: relative;
 }

package/Controls/Components/Overlays/MessageBox/Themes/MessageBoxElement.Memphis.js.map

@@ -1 +1 @@
-{"version":3,"file":"MessageBoxElement.Memphis.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Overlays/MessageBox/Themes/MessageBoxElement.Memphis.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,mBAAmB;AACnB,yCAAyC;AACzC,qGAAqG;AACrG,oBAAoB;AACpB,iFAAiF;AAEjF,kBAAkB;AAElB,OAAO,EAAE,GAAG,EAAkB,MAAM,wBAAwB,CAAC;AAE7D,aAAa;AAEb;;GAEG;AACH,MAAM,UAAU,6BAA6B;IACzC,OAAO,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsNT,CAAC;AACN,CAAC"}
+{"version":3,"file":"MessageBoxElement.Memphis.js","sourceRoot":"","sources":["../../../../../../src/Controls/Components/Overlays/MessageBox/Themes/MessageBoxElement.Memphis.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,mBAAmB;AACnB,yCAAyC;AACzC,qGAAqG;AACrG,oBAAoB;AACpB,iFAAiF;AAEjF,kBAAkB;AAElB,OAAO,EAAE,GAAG,EAAkB,MAAM,wBAAwB,CAAC;AAE7D,aAAa;AAEb;;GAEG;AACH,MAAM,UAAU,6BAA6B;IACzC,OAAO,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuNT,CAAC;AACN,CAAC"}

package/Controls/Components/Overlays/Sheet/ISheetElementProps.d.ts

@@ -1,16 +1,107 @@
 import type { CssLength } from '@breadstone/mosaik-themes';
+import type { ISlottableProps } from '../../../Behaviors/Slottable';
+import { SheetDragMode } from '../../../Types/SheetDragMode';
+import { SheetPosition } from '../../../Types/SheetPosition';
+import type { SheetSnap } from '../../../Types/SheetSnap';
+import { IOverlayElementProps } from '../Abstracts/OverlayElement';
 /**
  * Represents the `ISheetElementProps` interface.
  *
  * @public
  */
-export interface ISheetElementProps {
+export interface ISheetElementProps extends IOverlayElementProps, ISlottableProps {
     /**
-     * Gets or sets the `height` property.
-     * Defines the maximum height of the sheet element.
+     * The width of the sheet surface.
+     * Accepts any valid Mosaik CSS length and remains constrained by the viewport and the theme's maximum width.
      *
-     * @public
+     * @default '100%'
+     */
+    width: CssLength;
+    /**
+     * The maximum visible extent of the sheet.
+     * Accepts any valid Mosaik CSS length, including `auto` for the measured content height.
+     *
+     * @default '60dvh'
      */
     height: CssLength;
+    /**
+     * The viewport edge from which the sheet opens.
+     *
+     * @default 'bottom'
+     */
+    position: SheetPosition;
+    /**
+     * The visible extents at which the sheet can settle.
+     * Values are resolved, clamped to `height`, sorted from smallest to largest and de-duplicated.
+     * The special value `content` uses the measured sheet content height.
+     * An empty array creates one snap at the maximum sheet extent.
+     *
+     * @default []
+     */
+    snaps: Array<SheetSnap>;
+    /**
+     * The active index in the resolved, ascending snap list.
+     * Invalid indices are clamped. The largest snap is selected initially unless an index is set explicitly.
+     *
+     * @default 0
+     */
+    activeSnapIndex: number;
+    /**
+     * The fraction of the maximum sheet extent below which a released gesture requests closing.
+     * Values are clamped to the range from `0` to `1`.
+     *
+     * @default 0.25
+     */
+    closeThreshold: number;
+    /**
+     * Determines whether dragging beyond the legal sheet range uses elastic resistance.
+     *
+     * @default true
+     */
+    elastic: boolean;
+    /**
+     * Determines whether release velocity influences the selected landing snap.
+     *
+     * @default true
+     */
+    inertia: boolean;
+    /**
+     * Determines whether dragging can start on the sheet surface or only on its handle.
+     * Interactive controls never start a sheet gesture.
+     *
+     * @default 'sheet'
+     */
+    dragMode: SheetDragMode;
+    /**
+     * Determines whether the built-in drag handle is rendered.
+     *
+     * @default true
+     */
+    hasHandle: boolean;
+    /**
+     * Determines whether indicators for the resolved snaps are rendered.
+     *
+     * @default false
+     */
+    hasSnapIndicator: boolean;
+    /**
+     * Determines whether the open sheet traps focus, restores focus and locks document scrolling.
+     *
+     * @default false
+     */
+    isModal: boolean;
+}
+/**
+ * Default values for `SheetElement` properties.
+ *
+ * @public
+ */
+export declare namespace ISheetElementProps {
+    /**
+     * The default property values used by `SheetElement`.
+     *
+     * @public
+     */
+    const DEFAULTS: ISheetElementProps;
 }
 //# sourceMappingURL=ISheetElementProps.d.ts.map

package/Controls/Components/Overlays/Sheet/ISheetElementProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ISheetElementProps.d.ts","sourceRoot":"","sources":["../../../../../src/Controls/Components/Overlays/Sheet/ISheetElementProps.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI3D;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAE/B;;;;;OAKG;IACH,MAAM,EAAE,SAAS,CAAC;CAErB"}
+{"version":3,"file":"ISheetElementProps.d.ts","sourceRoot":"","sources":["../../../../../src/Controls/Components/Overlays/Sheet/ISheetElementProps.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAInE;;;;GAIG;AACH,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB,EAAE,eAAe;IAI7E;;;;;OAKG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;;;;OAKG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;;;OAIG;IACH,QAAQ,EAAE,aAAa,CAAC;IAExB;;;;;;;OAOG;IACH,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAExB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;OAKG;IACH,QAAQ,EAAE,aAAa,CAAC;IAExB;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAIpB;AAED;;;;GAIG;AACH,yBAAiB,kBAAkB,CAAC;IAEhC;;;;OAIG;IACI,MAAM,QAAQ,EAAE,kBActB,CAAC;CAEL"}

package/Controls/Components/Overlays/Sheet/ISheetElementProps.js

@@ -1,3 +1,33 @@
 // #region Imports
-export {};
+import { SheetDragMode } from '../../../Types/SheetDragMode';
+import { SheetPosition } from '../../../Types/SheetPosition';
+import { IOverlayElementProps } from '../Abstracts/OverlayElement';
+/**
+ * Default values for `SheetElement` properties.
+ *
+ * @public
+ */
+export var ISheetElementProps;
+(function (ISheetElementProps) {
+    /**
+     * The default property values used by `SheetElement`.
+     *
+     * @public
+     */
+    ISheetElementProps.DEFAULTS = {
+        ...IOverlayElementProps.DEFAULTS,
+        width: '100%',
+        height: '60dvh',
+        position: SheetPosition.Bottom,
+        snaps: [],
+        activeSnapIndex: 0,
+        closeThreshold: 0.25,
+        elastic: true,
+        inertia: true,
+        dragMode: SheetDragMode.Sheet,
+        hasHandle: true,
+        hasSnapIndicator: false,
+        isModal: false
+    };
+})(ISheetElementProps || (ISheetElementProps = {}));
 //# sourceMappingURL=ISheetElementProps.js.map

package/Controls/Components/Overlays/Sheet/ISheetElementProps.js.map

@@ -1 +1 @@
-{"version":3,"file":"ISheetElementProps.js","sourceRoot":"","sources":["../../../../../src/Controls/Components/Overlays/Sheet/ISheetElementProps.ts"],"names":[],"mappings":"AAAA,kBAAkB"}
+{"version":3,"file":"ISheetElementProps.js","sourceRoot":"","sources":["../../../../../src/Controls/Components/Overlays/Sheet/ISheetElementProps.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAIlB,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA6GnE;;;;GAIG;AACH,MAAM,KAAW,kBAAkB,CAuBlC;AAvBD,WAAiB,kBAAkB;IAE/B;;;;OAIG;IACU,2BAAQ,GAAuB;QACxC,GAAG,oBAAoB,CAAC,QAAQ;QAChC,KAAK,EAAE,MAAM;QACb,MAAM,EAAE,OAAO;QACf,QAAQ,EAAE,aAAa,CAAC,MAAM;QAC9B,KAAK,EAAE,EAAE;QACT,eAAe,EAAE,CAAC;QAClB,cAAc,EAAE,IAAI;QACpB,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE,aAAa,CAAC,KAAK;QAC7B,SAAS,EAAE,IAAI;QACf,gBAAgB,EAAE,KAAK;QACvB,OAAO,EAAE,KAAK;KACjB,CAAC;AAEN,CAAC,EAvBgB,kBAAkB,KAAlB,kBAAkB,QAuBlC"}

package/Controls/Components/Overlays/Sheet/SheetElement.d.ts

@@ -1,14 +1,20 @@
+import { type IEventEmitter } from '@breadstone/mosaik-elements';
 import { CssLength } from '@breadstone/mosaik-themes';
 import { type ISlottable } from '../../../Behaviors/Slottable';
+import type { IActiveSnapChangedEventDetail, IDragEndEventDetail, IDraggingEventDetail, IDragStartEventDetail } from '../../../events';
+import { SheetDragMode } from '../../../Types/SheetDragMode';
+import { SheetPosition } from '../../../Types/SheetPosition';
+import { SheetSnap } from '../../../Types/SheetSnap';
 import { OverlayElement } from '../Abstracts/OverlayElement';
 import { ISheetElementProps } from './ISheetElementProps';
 declare const SheetElement_base: (abstract new (...args: Array<any>) => import("../../../Behaviors/Themeable").IThemeableProps) & (abstract new (...args: Array<any>) => import("../../../Behaviors/Slottable").ISlottableProps & ISlottable) & typeof OverlayElement & import("../../../Behaviors/Themeable").IThemeableCtor;
 /**
- * Sheet - A bottom-sheet overlay element that slides up from the bottom of the viewport.
+ * Sheet - A mobile-first, snap-based overlay entering from the top or bottom edge.
  *
  * @description
- * A gesture-driven bottom sheet that supports drag to open, close, and partial states.
- * Use the `height` attribute to control the initial expanded height.
+ * Supports pointer gestures, velocity-based snap selection, scroll handoff and optional modal behavior.
+ * Runtime state is exposed through `data-state`, `data-dragging`, `data-snap-index` and `data-max-snap`.
+ * The `root` part publishes `--sheet-progress` from `0` to `1` and `--sheet-resolved-height` in CSS pixels.
  *
  * @name Sheet
  * @element mosaik-sheet
@@ -19,13 +25,21 @@ declare const SheetElement_base: (abstract new (...args: Array<any>) => import("
  * @slot header - The header slot for `SheetHeaderElement`.
  *
  * @csspart backdrop - The backdrop part.
- * @csspart heading - The heading part.
- * @csspart root - The root part.
- * @csspart thumb - The thumb part.
+ * @csspart body - The body part.
+ * @csspart content-slot - The slot that projects the scrollable sheet content.
+ * @csspart footer-slot - The slot that projects the sheet footer.
+ * @csspart handle - The visual drag handle.
+ * @csspart header-slot - The slot that projects the sheet header.
+ * @csspart heading - The sheet heading and gesture affordance.
+ * @csspart root - The movable sheet surface.
+ * @csspart snap-indicator - Container for snap indicators.
+ * @csspart snap-indicator-item - An individual snap indicator.
  *
  * @cssprop {String} --sheet-background-color - The background color CSS custom property.
  * @cssprop {String} --sheet-border-color - The border color CSS custom property.
+ * @cssprop {String} --sheet-border-radius - The border radius CSS custom property.
  * @cssprop {String} --sheet-border-width - The border width CSS custom property.
+ * @cssprop {String} --sheet-edge-offset - The edge offset CSS custom property.
  * @cssprop {String} --sheet-font-family - The font family CSS custom property.
  * @cssprop {String} --sheet-font-letter-spacing - The font letter spacing CSS custom property.
  * @cssprop {String} --sheet-font-line-height - The font line height CSS custom property.
@@ -35,6 +49,12 @@ declare const SheetElement_base: (abstract new (...args: Array<any>) => import("
  * @cssprop {String} --sheet-font-weight - The font weight CSS custom property.
  * @cssprop {String} --sheet-foreground-color - The foreground color CSS custom property.
  * @cssprop {String} --sheet-gap - The gap CSS custom property.
+ * @cssprop {String} --sheet-handle-background-color - The handle background color CSS custom property.
+ * @cssprop {String} --sheet-handle-border-radius - The handle border radius CSS custom property.
+ * @cssprop {String} --sheet-handle-height - The handle height CSS custom property.
+ * @cssprop {String} --sheet-handle-margin - The handle margin CSS custom property.
+ * @cssprop {String} --sheet-handle-width - The handle width CSS custom property.
+ * @cssprop {String} --sheet-max-width - The max width CSS custom property.
  * @cssprop {String} --sheet-padding-bottom - The padding bottom CSS custom property.
  * @cssprop {String} --sheet-padding-left - The padding left CSS custom property.
  * @cssprop {String} --sheet-padding-right - The padding right CSS custom property.
@@ -45,48 +65,88 @@ declare const SheetElement_base: (abstract new (...args: Array<any>) => import("
  * @cssprop {String} --sheet-shadow-offset-x - The shadow offset x CSS custom property.
  * @cssprop {String} --sheet-shadow-offset-y - The shadow offset y CSS custom property.
  * @cssprop {String} --sheet-shadow-spread - The shadow spread CSS custom property.
+ * @cssprop {String} --sheet-snap-indicator-active-background-color - The snap indicator active background color CSS custom property.
+ * @cssprop {String} --sheet-snap-indicator-background-color - The snap indicator background color CSS custom property.
+ * @cssprop {String} --sheet-snap-indicator-border-radius - The snap indicator border radius CSS custom property.
+ * @cssprop {String} --sheet-snap-indicator-gap - The snap indicator gap CSS custom property.
+ * @cssprop {String} --sheet-snap-indicator-size - The snap indicator size CSS custom property.
  * @cssprop {String} --sheet-transition-duration - The transition duration CSS custom property.
  * @cssprop {String} --sheet-transition-mode - The transition mode CSS custom property.
  * @cssprop {String} --sheet-transition-property - The transition property CSS custom property.
  * @cssprop {String} --sheet-translate - The translate CSS custom property.
  * @cssprop {String} --sheet-translate-y - The translate y CSS custom property.
+ * @cssprop {String} --sheet-z-index - The stacking order CSS custom property.
+ *
+ * @fires activeSnapChanged {ActiveSnapChangedEvent} - Fired after the active snap changes.
+ * @fires dragStart {DragStartEvent} - Fired when a vertical sheet gesture starts.
+ * @fires dragging {DraggingEvent} - Fired while the sheet is dragged.
+ * @fires dragEnd {DragEndEvent} - Fired when a sheet gesture ends.
  *
  * @dependency mosaik-backdrop - The Backdrop element.
  *
  * @example
- * Basic bottom sheet:
+ * Mobile checkout summary with three selectable snap extents:
  * ```html
- * <mosaik-sheet></mosaik-sheet>
+ * <mosaik-sheet snaps="25% 55% 90%" active-snap-index="1" is-modal>
+ *   <mosaik-sheet-header slot="header">Order summary</mosaik-sheet-header>
+ *   <mosaik-sheet-content slot="content">Checkout details</mosaik-sheet-content>
+ *   <mosaik-sheet-footer slot="footer">Checkout actions</mosaik-sheet-footer>
+ * </mosaik-sheet>
  * ```
  *
  * @example
- * Bottom sheet with custom height:
+ * Search filters that expand from the top and adapt to their content:
  * ```html
- * <mosaik-sheet height="50vh"></mosaik-sheet>
+ * <mosaik-sheet position="top" height="100dvh" snaps="content 90%" drag-mode="handle">
+ *   <mosaik-sheet-header slot="header">Filters</mosaik-sheet-header>
+ *   <mosaik-sheet-content slot="content">Filter controls</mosaik-sheet-content>
+ * </mosaik-sheet>
  * ```
  *
  * @public
  */
 export declare class SheetElement extends SheetElement_base implements ISheetElementProps, ISlottable {
-    private readonly _bounceOffset;
+    private readonly _activeSnapChanged;
+    private readonly _dragStart;
+    private readonly _dragging;
+    private readonly _dragEnd;
+    private readonly _modalController;
+    private _width;
     private _height;
-    private _dragOffset;
-    private _positionY;
-    private _isPartial;
-    private _mouseDownSubscription;
-    private _touchStartSubscription;
-    private _mouseUpSubscription;
-    private _touchEndSubscription;
-    private _mouseMoveSubscription;
-    private _touchMoveSubscription;
-    private _clickSubscription;
+    private _position;
+    private _snaps;
+    private _activeSnapIndex;
+    private _activeSnapIndexExplicit;
+    private _closeThreshold;
+    private _elastic;
+    private _inertia;
+    private _dragMode;
+    private _hasHandle;
+    private _hasSnapIndicator;
+    private _isModal;
+    private _resolvedSnaps;
+    private _visibleExtent;
+    private _maxExtent;
+    private _pointerId;
+    private _startX;
+    private _startY;
+    private _lastY;
+    private _startExtent;
+    private _isDragging;
+    private _axisRejected;
+    private _samples;
+    private _resizeObserver;
+    private _observedRoot;
+    private _visualViewportHandler;
+    private _measureFrame;
     /**
+     * Constructs a new instance of the `SheetElement` class.
+     *
      * @public
      */
     constructor();
     /**
-     * Returns the `is` property.
-     * The `is` property represents natural name of this element.
+     * Returns the natural name of this element.
      *
      * @public
      * @static
@@ -94,82 +154,290 @@ export declare class SheetElement extends SheetElement_base implements ISheetEle
      */
     static get is(): string;
     /**
-     * Gets or sets the `height` property.
+     * Gets or sets the width of the sheet surface.
+     * The width remains constrained by the viewport and the theme's maximum width.
+     *
+     * @public
+     * @attr
+     * @default '100%'
+     */
+    get width(): CssLength;
+    set width(value: CssLength);
+    /**
+     * Gets or sets the maximum visible extent of the sheet.
+     * The `auto` value uses the measured content height.
      *
      * @public
      * @attr
+     * @default '60dvh'
      */
     get height(): CssLength;
     set height(value: CssLength);
     /**
-     * Opens the `SheetElement`.
+     * Gets or sets the viewport edge from which the sheet opens.
+     *
+     * @public
+     * @attr
+     * @default 'bottom'
+     */
+    get position(): SheetPosition;
+    set position(value: SheetPosition);
+    /**
+     * Gets or sets the sheet's snap extents.
+     * Values are resolved, clamped to `height`, sorted and de-duplicated.
+     * The `content` value uses the measured content height.
+     * In plain HTML, provide a space-separated list such as `snaps="25% content 90dvh"`.
+     * Invalid values and the unsupported `auto` value throw a descriptive error.
+     *
+     * @public
+     * @attr
+     * @default []
+     */
+    get snaps(): Array<SheetSnap>;
+    set snaps(value: Array<SheetSnap>);
+    /**
+     * Gets or sets the active index in the resolved, ascending snap list.
+     * Invalid values are clamped to an available index.
+     *
+     * @public
+     * @attr
+     * @default 0
+     */
+    get activeSnapIndex(): number;
+    set activeSnapIndex(value: number);
+    /**
+     * Gets or sets the close threshold as a fraction of the maximum extent.
+     * Values are clamped to the range from `0` to `1`.
+     *
+     * @public
+     * @attr
+     * @default 0.25
+     */
+    get closeThreshold(): number;
+    set closeThreshold(value: number);
+    /**
+     * Gets or sets whether dragging beyond the legal range uses elastic resistance.
+     *
+     * @public
+     * @attr
+     * @default true
+     */
+    get elastic(): boolean;
+    set elastic(value: boolean);
+    /**
+     * Gets or sets whether release velocity influences the landing snap.
+     *
+     * @public
+     * @attr
+     * @default true
+     */
+    get inertia(): boolean;
+    set inertia(value: boolean);
+    /**
+     * Gets or sets the area from which a sheet gesture may start.
+     * Interactive controls never start a sheet gesture.
+     *
+     * @public
+     * @attr
+     * @default 'sheet'
+     */
+    get dragMode(): SheetDragMode;
+    set dragMode(value: SheetDragMode);
+    /**
+     * Gets or sets whether the built-in drag handle is rendered.
+     *
+     * @public
+     * @attr
+     * @default true
+     */
+    get hasHandle(): boolean;
+    set hasHandle(value: boolean);
+    /**
+     * Gets or sets whether indicators for the resolved snaps are rendered.
+     *
+     * @public
+     * @attr
+     * @default false
+     */
+    get hasSnapIndicator(): boolean;
+    set hasSnapIndicator(value: boolean);
+    /**
+     * Gets or sets whether the open sheet traps focus, restores focus and locks document scrolling.
+     *
+     * @public
+     * @attr
+     * @default false
+     */
+    get isModal(): boolean;
+    set isModal(value: boolean);
+    /**
+     * Called after the active snap changes.
+     * Provides `IActiveSnapChangedEventDetail` as event detail.
+     *
+     * @public
+     * @readonly
+     * @eventProperty
+     */
+    get activeSnapChanged(): IEventEmitter<IActiveSnapChangedEventDetail>;
+    /**
+     * Called when a vertical sheet gesture starts.
+     * Provides `IDragStartEventDetail` as event detail.
+     *
+     * @public
+     * @readonly
+     * @eventProperty
+     */
+    get dragStart(): IEventEmitter<IDragStartEventDetail>;
+    /**
+     * Called while the sheet is moved by a vertical pointer gesture.
+     * Provides `IDraggingEventDetail` as event detail.
+     *
+     * @public
+     * @readonly
+     * @eventProperty
+     */
+    get dragging(): IEventEmitter<IDraggingEventDetail>;
+    /**
+     * Called when a vertical sheet gesture ends.
+     * Provides `IDragEndEventDetail` as event detail.
+     *
+     * @public
+     * @readonly
+     * @eventProperty
+     */
+    get dragEnd(): IEventEmitter<IDragEndEventDetail>;
+    /**
+     * @inheritdoc
+     * @public
+     * @override
+     */
+    connectedCallback(): void;
+    /**
+     * @inheritdoc
+     * @public
+     * @override
+     */
+    disconnectedCallback(): void;
+    /**
+     * Opens the sheet at its active snap.
      *
      * @public
      * @override
+     * @returns A promise that resolves after the sheet has opened.
      */
     open(): Promise<void>;
     /**
-     * Closes the `SheetElement`.
+     * Closes the sheet through the normal overlay lifecycle.
      *
      * @public
      * @override
+     * @returns A promise resolving to whether the sheet was closed.
      */
     close(): Promise<boolean>;
     /**
-     * Sets the sheet to a partial (peek) state, showing only the heading area.
+     * Moves the open sheet to a configured snap.
+     * Invalid indices are clamped to the resolved snap range.
      *
      * @public
+     * @param index - The target index in the resolved, ascending snap list.
      */
-    partial(): void;
+    snapTo(index: number): void;
     /**
-     * Toggles between open and partial states.
+     * Handles open-state changes without overriding the overlay's internal state hook.
      *
-     * @public
+     * @protected
+     */
+    protected onApplyTemplate(): void;
+    /**
+     * Keeps dialog semantics on the sheet surface instead of the custom-element host.
+     *
+     * @protected
      */
-    toggle(): Promise<void>;
+    protected onIsOpenPropertyChanged(_previous: boolean, next: boolean): void;
     /**
+     * @inheritdoc
      * @protected
      * @override
      */
-    protected onApplyTemplate(): void;
+    protected onSheetHasBackdropPropertyChanged(_previous: boolean, _next: boolean): void;
     /**
-     * Handles the backdrop click event.
-     * Only closes the sheet if `clickOutsideToClose` is enabled.
+     * Re-measures the sheet after its maximum height changes.
      *
-     * @public
-     * @template
+     * @protected
      */
-    onBackdrop(): void;
+    protected onHeightPropertyChanged(_previous: CssLength, _next: CssLength): void;
     /**
-     * @private
+     * Re-measures the sheet after its opening edge changes.
+     *
+     * @protected
      */
-    private dragMouseDown;
+    protected onPositionPropertyChanged(_previous: SheetPosition, _next: SheetPosition): void;
     /**
-     * @private
+     * Synchronizes the default active snap and schedules snap resolution.
+     *
+     * @protected
      */
-    private dragMouseUp;
+    protected onSnapsPropertyChanged(_previous: Array<SheetSnap>, next: Array<SheetSnap>): void;
     /**
-     * @private
+     * Moves an open sheet after its controlled snap index changes.
+     *
+     * @protected
      */
-    private dragMouseMove;
+    protected onActiveSnapIndexPropertyChanged(previous: number, next: number): void;
     /**
-     * @private
+     * Activates or deactivates modal behavior while the sheet is open.
+     *
+     * @protected
      */
-    private moveDragElement;
+    protected onIsModalPropertyChanged(_previous: boolean, next: boolean): void;
     /**
-     * @private
+     * Synchronizes the optional snap indicator after its visibility changes.
+     *
+     * @protected
      */
-    private getYCoord;
+    protected onHasSnapIndicatorPropertyChanged(_previous: boolean, next: boolean): void;
+    private activateInteractionResources;
+    private deactivateInteractionResources;
+    private attachPointerListeners;
+    private detachPointerListeners;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private consumeScrollableMovement;
+    private findScrollable;
+    private cleanupPointer;
+    private getVelocity;
+    private createDragDetail;
+    private measure;
+    private measureCssLength;
+    private moveToSnap;
+    private setVisibleExtent;
+    private setTransition;
+    private setState;
+    private clampSnapIndex;
+    private queueMeasurement;
+    private handleViewportResize;
+    private observeRoot;
+    private waitForMotion;
+    private parseMotionTime;
+    private setBooleanProperty;
+    private renderSnapIndicators;
+    private updateSnapIndicatorState;
 }
 /**
+ * Contains public types associated with `SheetElement`.
+ *
  * @public
  */
 export declare namespace SheetElement {
+    /**
+     * The public properties of `SheetElement`.
+     *
+     * @public
+     */
     type Props = ISheetElementProps;
 }
-/**
- * @public
- */
 declare global {
     interface HTMLElementTagNameMap {
         'mosaik-sheet': SheetElement;