@pacem/pacem-ui 1.0.0-bernoulli → 1.0.0-binet

package/typings/index.d.ts

@@ -7,15 +7,18 @@ import { PacemEventTarget } from '@pacem/pacem-core';
 import { Point } from '@pacem/pacem-foundation';
 import { PropertyConverter } from '@pacem/pacem-core';
 
+/** Orientation used by a {@link PacemAdapterElement} to interpret arrow-key navigation. */
 declare enum AdapterOrientation {
     Vertical = "vertical",
     Horizontal = "horizontal"
 }
 
+/** Event dispatched by {@link PacemAdapterElement} whenever a page/dashboard button needs to (re)compute its visible state or content. */
 declare class AdapterPageButtonRefreshEvent extends CustomEvent<AdapterPageButtonRefreshEventArgs> {
     constructor(args: AdapterPageButtonRefreshEventArgs);
 }
 
+/** Payload of the {@link AdapterPageButtonRefreshEvent}, mutable so listeners can override how a page button is rendered. */
 declare interface AdapterPageButtonRefreshEventArgs {
     index: number;
     hide: boolean;
@@ -25,6 +28,7 @@ declare interface AdapterPageButtonRefreshEventArgs {
 
 declare const AdapterPageButtonRefreshEventName = "pagerefresh";
 
+/** Cross-axis alignment of a {@link PacemBalloonElement} relative to its `target`. */
 declare enum BalloonAlignment {
     Start = "start",
     Center = "center",
@@ -32,12 +36,14 @@ declare enum BalloonAlignment {
     Auto = "auto"
 }
 
+/** How a {@link PacemBalloonElement} behaves once popped up: a dismissible menu, a tooltip, or non-interactive. */
 declare enum BalloonBehavior {
     Menu = "menu",
     Tooltip = "tooltip",
     Inert = "inert"
 }
 
+/** Configuration bag accepted by {@link PacemBalloonElement}'s `options` property. */
 declare type BalloonOptions = {
     trigger?: BalloonTrigger;
     position?: BalloonPosition;
@@ -57,10 +63,13 @@ declare type BalloonOptions = {
     autoAdjust?: boolean;
 };
 
+/** Event name fired by {@link PacemBalloonElement} once it has finished popping out (after the hide transition). */
 declare const BalloonPopoutEventName = "popout";
 
+/** Event name fired by {@link PacemBalloonElement} once it has finished popping up (after the show transition). */
 declare const BalloonPopupEventName = "popup";
 
+/** Side of `target` a {@link PacemBalloonElement} is anchored to (with automatic variants that pick the side with the most room). */
 declare enum BalloonPosition {
     Top = "top",
     Left = "left",
@@ -71,11 +80,13 @@ declare enum BalloonPosition {
     VerticalAuto = "y"
 }
 
+/** Whether a {@link PacemBalloonElement} sizes itself freely or matches its `target`'s size along the anchored axis. */
 declare enum BalloonSizing {
     Auto = "auto",
     Match = "match"
 }
 
+/** The user interaction on `target` that pops a {@link PacemBalloonElement} up. */
 declare enum BalloonTrigger {
     Hover = "hover",
     Click = "click",
@@ -83,6 +94,7 @@ declare enum BalloonTrigger {
     Focus = "focus"
 }
 
+/** Edge (or center) of an element a {@link PacemBinderElement} curve attaches to. */
 declare enum BinderAnchor {
     Auto = "auto",
     Left = "left",
@@ -92,6 +104,7 @@ declare enum BinderAnchor {
     Center = "center"
 }
 
+/** Decoration drawn at either end of a {@link PacemBinderElement} curve. */
 declare enum BinderEnd {
     Default = "default",
     Arrow = "arrow",
@@ -99,12 +112,15 @@ declare enum BinderEnd {
     None = "none"
 }
 
+/** Event dispatched by a {@link PacemBinderElement} wrapping the original user-interaction event on its path. */
 declare class BinderInteractionEvent extends CustomUIEvent<null> {
     constructor(orig: MouseEvent | KeyboardEvent | TouchEvent);
 }
 
+/** Event name fired by a {@link PacemBinderElement} when its connecting path is interacted with (click, hover, etc.). */
 declare const BinderInteractionEventName = "interact";
 
+/** How a {@link PacemBinderElement} computes its Bezier control points: from the elements' mass (size) or from the path direction. */
 declare enum BinderTension {
     Mass = "mass",
     Path = "path"
@@ -132,14 +148,17 @@ declare type CalendarEventEventArgs = {
     element: HTMLElement;
 };
 
+/** Event dispatched when a {@link PacemCalendarEventElement} rendering gains focus/selection within its host calendar. */
 declare class CalendarEventSelectEvent extends CustomTypedEvent<CalendarEventEventArgs> {
     constructor(args: CalendarEventEventArgs);
 }
 
+/** Event dispatched when a {@link PacemCalendarEventElement} rendering loses focus/selection within its host calendar. */
 declare class CalendarEventUnselectEvent extends CustomTypedEvent<CalendarEventEventArgs> {
     constructor(args: CalendarEventEventArgs);
 }
 
+/** Granularity of a calendar/schedule/agenda view. */
 declare enum CalendarZoom {
     Month = "month",
     Week = "week",
@@ -152,15 +171,18 @@ export declare namespace Components {
     }
 }
 
+/** A (half-open) date interval, e.g. used to describe a disabled range in a calendar/agenda. */
 declare type DateRange = {
     from?: Date;
     to?: Date;
 };
 
+/** Event dispatched (and bubbling) when a day is selected on a {@link PacemCalendarElement}, carrying the selected date. */
 declare class DateSelectEvent extends CustomTypedEvent<Date> {
     constructor(date: Date);
 }
 
+/** Single button a dialog can be committed/closed with. */
 declare enum DialogButton {
     Yes = "yes",
     No = "no",
@@ -168,6 +190,7 @@ declare enum DialogButton {
     Ok = "ok"
 }
 
+/** Set of buttons shown by a dialog (e.g. {@link PacemDialogBase}), controlling which {@link DialogButton}s are visible. */
 declare enum DialogButtons {
     YesNo = "yesno",
     YesNoCancel = "yesnocancel",
@@ -175,42 +198,53 @@ declare enum DialogButtons {
     OkCancel = "okcancel"
 }
 
+/** Event dispatched by a {@link PacemDialogBase} when it is committed/closed via one of its buttons; also the resolution value of `open()`'s promise. */
 declare class DialogResultEvent extends CustomTypedEvent<DialogResultEventArgs> {
     constructor(args: DialogResultEventArgs);
 }
 
+/** Payload of a {@link DialogResultEvent}: which button committed the dialog, plus its `state` at commit time. */
 declare type DialogResultEventArgs = {
     button: DialogButton;
     state?: any;
 };
 
+/** Event name dispatched by a {@link PacemDialogBase} when it is committed/closed via one of its buttons. */
 declare const DialogResultEventName = "commit";
 
+/** Either a DOM `Element` or a plain `{x,y}` `Point`. */
 declare type ElementOrPoint = Element | Point;
 
+/** Converts an attribute value into an `Element` (resolved via `querySelector`) or, failing that, a parsed `Point`/JSON value. */
 declare const ElementOrPointPropertyConverter: PropertyConverter;
 
+/** Minimal contract for a show/hide overlay element (implemented by {@link PacemLightboxElement}), used by consumers such as {@link PacemDialogBase} that only need to toggle visibility. */
 declare interface Lightbox {
     show: boolean;
     behavior: LightboxBehavior;
 }
 
+/** How a {@link Lightbox} reacts to a click outside its content. */
 declare enum LightboxBehavior {
     ClickOutsideClose = "clickOutsideClose",
     ExplicitClose = "explicitClose"
 }
 
+/** Visual style of a {@link PacemLoaderElement}'s spinner. */
 declare enum LoaderType {
     Spinner = "spin",
     Pacem = "pacem",
     Custom = "custom"
 }
 
+/** Parses Markdown into HTML, extended with C-like/script/markup code-fence highlighting and Pacem-specific inline embeds (`{tweet}(id)`, `{yt}(id)`). */
 declare class MarkdownService {
     #private;
     constructor();
     private _escape;
+    /** Converts the given Markdown source into an HTML string. */
     toHtml(md: string): string;
+    /** Tokenizes the given Markdown source, without rendering it to HTML. */
     tokenize(md: string): any[];
 }
 
@@ -238,18 +272,26 @@ declare const MEDIAQUERY_XL = "(min-width: 1824px)";
 
 declare const MEDIAQUERY_XS = "(max-width: 767px)";
 
+/** Base class for elements iterating a `datasource` under the control of a {@link PacemAdapterElement} (e.g. a slideshow), exposing `index`-relative helpers (`isPrevious`, `isNext`, `isCloseTo`). */
 declare abstract class PacemAdaptedIterativeElement<TItem> extends Components_2.PacemElement {
+    /** @readonly Gets the {@link PacemAdapterElement} driving this element's navigation. */
     protected abstract get adapter(): PacemAdapterElement;
+    /** Gets or sets the currently focused item's index within `datasource`. */
     index: number;
+    /** Gets or sets the collection of items being iterated. */
     datasource: TItem[];
+    /** Gets whether `ndx` is the focused item itself, or immediately adjacent (previous/next, wrapping around) to `focusndx`. */
     protected isCloseTo(ndx: number, focusndx: number): boolean;
+    /** Gets whether `ndx` is the item immediately preceding `focusndx` (wrapping around the datasource). */
     protected isPrevious(ndx: number, focusndx: number): boolean;
+    /** Gets whether `ndx` is the item immediately following `focusndx` (wrapping around the datasource). */
     protected isNext(ndx: number, focusndx: number): boolean;
     private _isNextCore;
     private _isPreviousCore;
     private _isCloseToCore;
 }
 
+/** Renders a dashboard of prev/next buttons and page indicators driving a {@link Components.PacemAdapter} (e.g. a `<pacem-slideshow>` master). */
 declare class PacemAdapterElement extends Components_2.PacemAdapter<Components_2.PacemIterativeElement<any>, any> {
     private _repeater;
     private _prevBtn;
@@ -269,15 +311,21 @@ declare class PacemAdapterElement extends Components_2.PacemAdapter<Components_2
     private _fireAdapterPageRefreshCallback;
     private _tickVersion;
     private _handle;
+    /** Gets or sets whether a play/pause button is shown to toggle the auto-advance timer (see `interval`). */
     pausable: boolean;
+    /** Gets or sets the auto-advance interval, in milliseconds. Unset (or non-positive) disables auto-advance. */
     interval: number;
+    /** Gets or sets the orientation used to interpret arrow-key navigation. */
     orientation: AdapterOrientation;
+    /** Gets or sets whether the dashboard responds to user interaction (keyboard, click, swipe). */
     interactive: boolean;
     /** Gets or sets whether swipe gesture is enabled for navigation (also depends on the 'interactive' flag being set to 'true') */
     swipeEnabled: boolean;
     /** Gets or sets whether, by selecting twice an item, you will de-select it and obtain an overall unselected state. */
     deselectable: boolean;
+    /** Gets or sets whether navigating past the last (or before the first) item wraps around. */
     loop: boolean;
+    /** Gets or sets the callback computing a page button's caption for a given item/index (defaults to the 1-based index). */
     labelCallback: (item: any, index: number) => string | Node;
     private _index;
     private _paused;
@@ -298,26 +346,37 @@ declare class PacemAdapterElement extends Components_2.PacemAdapter<Components_2
     private _labelCallback;
 }
 
+/** Renders a day/week hourly grid ("agenda" view) with an all-day row, placing {@link PacemCalendarEventElement} items on the timeline and dispatching {@link TimeSelectEvent} on slot click. */
 declare class PacemAgendaElement extends PacemCalendarWithEventsBaseElement {
     protected buildDataSource(items: PacemCalendarEventElement[]): CalendarDataItem[][];
     private _clock;
+    /** Gets or sets the currently selected time slot; setting it dispatches a {@link TimeSelectEvent}. */
     time: Date;
     private _allDayDatasource;
+    /** @readonly Gets the computed all-day row of positioned event items ready for rendering. */
     get allDayDatasource(): CalendarDataItem[];
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
 }
 
+/** Anchor-like custom element, supporting routed navigation (via a {@link Components.PacemRouterElement}), OAuth-authenticated downloads and keyboard activation. */
 declare class PacemAnchorElement extends Components_2.PacemElement implements Net.OAuthFetchable {
+    /** Gets or sets the credentials mode used when fetching a `download`-ed resource. */
     fetchCredentials: RequestCredentials;
+    /** Gets or sets extra headers (e.g. `Authorization`) sent when fetching a `download`-ed resource. */
     fetchHeaders: {
         [key: string]: string;
     };
     constructor();
+    /** Gets or sets the link's target URL (optionally formatted through `router`'s current state). */
     href: string;
+    /** Gets or sets the window/frame target to open `href` into (bypasses routed navigation). */
     target: string;
+    /** Gets or sets whether clicking triggers a download instead of navigating: `true` downloads with the original filename, a string downloads with that filename. */
     download: string | boolean;
+    /** Gets or sets the {@link Components.PacemRouterElement} to delegate navigation to, instead of a full page load. */
     router: Components_2.PacemRouterElement;
     private _fetching;
+    /** @readonly Gets whether a `download` fetch is currently in progress. */
     get fetching(): boolean;
     connectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
@@ -325,6 +384,7 @@ declare class PacemAnchorElement extends Components_2.PacemElement implements Ne
     private _download;
 }
 
+/** Positions its content as a floating popup (menu or tooltip) anchored to a `target` element or point; see {@link BalloonOptions}. */
 declare class PacemBalloonElement extends Components_2.PacemElement {
     private _timer;
     private _visible;
@@ -333,7 +393,9 @@ declare class PacemBalloonElement extends Components_2.PacemElement {
     private _container;
     private _resize;
     private _position;
+    /** Gets or sets the element (or point) the balloon is anchored to. Defaults to the parent element once activated. */
     target: ElementOrPoint;
+    /** Gets or sets the balloon's behavior/trigger/positioning options; see {@link BalloonOptions}. */
     options: BalloonOptions;
     /** Gets whether the balloon is open and visible. */
     get visible(): boolean;
@@ -370,15 +432,25 @@ declare class PacemBalloonElement extends Components_2.PacemElement {
     private _setHandlers;
 }
 
+/** Draws an SVG Bezier curve connecting two elements (or points), following them as they move/resize; e.g. wires or diagram connectors. */
 declare class PacemBinderElement extends Components_2.PacemElement {
+    /** Gets or sets the curve's starting element (or point). */
     from: PacemBinderTarget;
+    /** Gets or sets the curve's ending element (or point). */
     to: PacemBinderTarget;
+    /** Gets or sets the edge of `from` the curve attaches to. */
     fromAnchor: BinderAnchor;
+    /** Gets or sets the edge of `to` the curve attaches to. */
     toAnchor: BinderAnchor;
+    /** Gets or sets the decoration drawn at the `from` end of the curve. */
     fromEnd: BinderEnd;
+    /** Gets or sets the decoration drawn at the `to` end of the curve. */
     toEnd: BinderEnd;
+    /** Gets or sets how the curve's control points are computed. */
     tension: BinderTension;
+    /** Gets or sets the curve's stroke color. */
     color: string;
+    /** Gets or sets whether the curve's path responds to pointer interaction (dispatching {@link BinderInteractionEvent}). */
     interactive: boolean;
     connectedCallback(): void;
     viewActivatedCallback(): void;
@@ -387,11 +459,13 @@ declare class PacemBinderElement extends Components_2.PacemElement {
     disconnectedCallback(): void;
     private _setPathVisibility;
     private _ensurePath;
+    /** Resizes the shared full-page SVG overlay to match the current document size; call after layout changes that may affect `document.body`'s scroll size. */
     invalidateSize(): void;
     private _path;
     private _svg;
     private _state;
     private _computeAnchorPoints;
+    /** Updates the cached position/size for the given endpoint (`from` or `to`) and redraws the curve if both ends are known. @param args Pre-computed layout, or omitted to reuse the last known/cached value. */
     refresh(element: PacemBinderTarget, args?: Components_2.ResizeEventArgs): void;
     private _draw;
     private _getDefaultEndingPath;
@@ -401,21 +475,25 @@ declare class PacemBinderElement extends Components_2.PacemElement {
 
 declare type PacemBinderTarget = ElementOrPoint;
 
+/** Slide-in panel toggled via its `open` property, dispatching `open`/`close` events as it transitions. */
 declare class PacemBladeElement extends Components_2.PacemElement {
+    /** Gets or sets whether the blade is expanded (visible) or collapsed. */
     open: boolean;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     private _toggle;
 }
 
+/** Mobile-style panel anchored to the bottom of the viewport, draggable (via its {@link PacemBottomSheetHandleElement}) and swipeable open/closed. */
 declare class PacemBottomSheetElement extends Components_2.PacemElement {
     private _swiper;
     private _resizer;
     private _handleResizer;
     private _sheet;
+    /** Gets or sets whether the sheet is expanded (visible) or collapsed off-screen. */
     open: boolean;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     private _toggleSwiper;
-    /** @internal */
+    /** @internal Wires (or clears) the swiper's drag handle selector to the given {@link PacemBottomSheetHandleElement}. */
     _setHandle(handle: PacemBottomSheetHandleElement | null): void;
     private _assignLogger;
     private _resizeHandler;
@@ -442,9 +520,11 @@ declare class PacemBottomSheetElement extends Components_2.PacemElement {
     private _toggle;
 }
 
+/** Drag handle for an ancestor {@link PacemBottomSheetElement}: renders a small grip icon, toggles the sheet on click and drives its swipe-to-drag behavior. */
 declare class PacemBottomSheetHandleElement extends Components_2.PacemElement {
     #private;
     _icon: PacemIconElement;
+    /** Gets or sets the icon glyph shown on the handle (defaults to a horizontal rule/grip). */
     iconGlyph: string;
     viewActivatedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
@@ -455,33 +535,49 @@ declare class PacemBottomSheetHandleElement extends Components_2.PacemElement {
     private _setIcon;
 }
 
+/** Clickable button element with optional icon, command dispatching (via {@link CommandEvent}) and an optional confirmation dialog gate. */
 declare class PacemButtonElement extends Components_2.PacemIterableElement {
     constructor();
+    /** Gets or sets the icon glyph (ligature) rendered before the button's content. */
     iconGlyph: string;
+    /** Gets or sets the icon image URL rendered before the button's content. */
     iconUrl: string;
+    /** Gets or sets the command name dispatched (as a {@link CommandEvent}) when the button is clicked. */
     commandName: string;
+    /** Gets or sets the argument carried by the {@link CommandEvent} dispatched on click. */
     commandArgument: any;
+    /** Gets or sets the message shown by `confirmationDialog` before the click is actually processed. */
     confirmationMessage: string;
+    /** Gets or sets the dialog used to confirm the click before it's processed; when set, the click only proceeds if the user answers Yes/Ok. */
     confirmationDialog: PacemDialogBase;
     connectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     protected emit(evt: Event): void;
 }
 
+/** Groups {@link PacemButtonElement} children into a single iterable/selectable set, focusing the item matching `index`. */
 declare class PacemButtonsetElement extends Components_2.PacemIterativeElement<PacemButtonElement> {
     connectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     validate(item: any): item is PacemButtonElement;
 }
 
+/** Base class shared by the calendar-family elements ({@link PacemCalendarElement}, {@link PacemAgendaElement}, {@link PacemScheduleElement}): holds the current view date/zoom/week/month grids and the {@link PacemCalendarEventElement} items collection. */
 declare abstract class PacemCalendarBaseElement extends Components_2.PacemItemsContainerElement<PacemCalendarEventElement> {
     validate(item: PacemCalendarEventElement): boolean;
+    /** Gets or sets the date currently being viewed (drives which week/month is displayed). */
     viewDate: Date;
+    /** Gets or sets the date/time considered "now" (drives the "today"/clock highlighting). */
     now: Date;
+    /** Gets or sets the view granularity (month, week or day). */
     zoom: CalendarZoom;
+    /** Gets or sets which day is considered the first day of the week. */
     weekStart: 'mon' | 'sun' | 'm' | 's' | 'monday' | 'sunday';
+    /** Gets or sets the 7 dates (Date instances) making up the currently viewed week. */
     week: Date[];
+    /** Gets or sets the weeks-of-dates grid (rows of 7 dates each) making up the currently viewed month. */
     month: Date[][];
+    /** Gets or sets the date ranges disabled for interaction/selection. */
     disabledRanges: DateRange[];
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     protected oneventselect(el: HTMLElement, evt: PacemCalendarEventElement): void;
@@ -502,7 +598,9 @@ declare abstract class PacemCalendarBaseElement extends Components_2.PacemItemsC
     private _synchronizeWeek;
 }
 
+/** Declarative {@link PacemCalendarRuleBaseElement} that disables every day of the ancestor calendar not listed in `days` (e.g. weekends). */
 declare class PacemCalendarDayOfWeekRuleElement extends PacemCalendarRuleBaseElement {
+    /** Gets or sets the allowed days of week (e.g. `['monday', 'tuesday', ...]`); every other day gets disabled. */
     days: string[];
     viewActivatedCallback(): void;
     private _daysOfWeek;
@@ -511,8 +609,10 @@ declare class PacemCalendarDayOfWeekRuleElement extends PacemCalendarRuleBaseEle
     protected computeDisabledRanges(): DateRange[];
 }
 
+/** Renders a classic month grid, placing {@link PacemCalendarEventElement} items on their spanning day cells and dispatching {@link DateSelectEvent} on day click. */
 declare class PacemCalendarElement extends PacemCalendarWithEventsBaseElement {
     protected buildDataSource(items: PacemCalendarEventElement[]): CalendarDataItem[][];
+    /** Gets or sets the currently selected day; setting it dispatches a {@link DateSelectEvent}. */
     date: Date;
     /** Gets or sets the format for the first day of each month. */
     dayLabelFormatter: (d: Date) => string;
@@ -522,42 +622,57 @@ declare class PacemCalendarElement extends PacemCalendarWithEventsBaseElement {
     protected getDayLabel(d: Date, _?: number): string;
 }
 
+/** A single event/appointment item, meant as a child of a {@link PacemCalendarWithEventsBaseElement} (e.g. {@link PacemCalendarElement} or {@link PacemAgendaElement}). */
 declare class PacemCalendarEventElement extends Components_2.PacemItemElement {
+    /** Gets or sets the event's start date/time. */
     start: Date;
+    /** Gets or sets the event's end date/time. */
     end: Date;
+    /** Gets or sets the event's display caption. */
     caption: string;
+    /** Gets or sets the event's place/location. */
     place: string;
+    /** Gets or sets whether the event spans the whole day (rendered in the all-day row/column). */
     allDay: boolean;
     private _handle;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
 }
 
+/** Base class for declarative rule elements that compute and inject {@link DateRange}s into an ancestor {@link PacemCalendarBaseElement}'s `disabledRanges` (e.g. {@link PacemCalendarDayOfWeekRuleElement}). */
 declare abstract class PacemCalendarRuleBaseElement extends HTMLElement {
     viewActivatedCallback(): void;
     disconnectedCallback(): void;
     private _target;
+    /** @readonly Gets the ancestor calendar element this rule applies its disabled ranges to. */
     protected get target(): PacemCalendarBaseElement;
     private _disabledRanges;
     protected refreshDisabledRanges(): void;
     protected abstract computeDisabledRanges(): DateRange[];
 }
 
+/** Base class for calendar-family elements that render their {@link PacemCalendarEventElement} items into a positioned grid (see {@link PacemCalendarElement}, {@link PacemAgendaElement}); subclasses supply the grid-building logic via `buildDataSource`. */
 declare abstract class PacemCalendarWithEventsBaseElement extends PacemCalendarBaseElement {
     private _datasource;
     private _handle;
+    /** @readonly Gets the computed, per-row (week or day) grid of positioned event items ready for rendering. */
     get datasource(): CalendarDataItem[][];
     private _getSortedItems;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     protected abstract buildDataSource(items: PacemCalendarEventElement[]): CalendarDataItem[][];
 }
 
+/** Displays (and CSS-classes itself by) the current hour/minute; typically overlaid on a {@link PacemAgendaElement} to mark the current-time line. */
 declare class PacemClockElement extends Components_2.PacemElement {
+    /** Gets or sets the date/time the clock displays. */
     now: Date;
 }
 
+/** Animates its content's height (or width, if `horizontal`) between 0 and its natural size, toggled via the `collapse` property. */
 declare class PacemCollapseElement extends PacemEventTarget {
     #private;
+    /** Gets or sets whether the content is collapsed (hidden, size 0) or expanded. */
     collapse: boolean;
+    /** Gets or sets whether the collapse animates along the horizontal (width) axis instead of the vertical (height) one. */
     horizontal: boolean;
     private _resizer;
     private _container;
@@ -567,29 +682,39 @@ declare class PacemCollapseElement extends PacemEventTarget {
     private _toggle;
 }
 
+/** Base class for modal dialog elements (see {@link PacemDialogElement}): wraps a {@link Lightbox} with an open/commit lifecycle resolved through a promise. */
 declare abstract class PacemDialogBase extends Components_2.PacemElement {
     #private;
     /** Gets the current state/datacontext of the dialog.
      * It is automatically destroyed when the dialog closes.
      * (It has not to be set declaratively.) */
     state: any;
+    /** @readonly Gets the underlying {@link Lightbox} instance this dialog shows/hides itself through. */
     protected abstract get lightbox(): Lightbox;
+    /** Opens the dialog, optionally seeding its `state`. @returns A promise resolved with the {@link DialogResultEventArgs} once the dialog is committed. */
     open(state?: any): Promise<DialogResultEventArgs>;
+    /** Closes the dialog with the given button outcome, resolving the pending `open()` promise and dispatching a {@link DialogResultEvent}. */
     protected commit(btn: DialogButton, evt: Event): void;
 }
 
+/** Modal dialog built on top of a {@link PacemLightboxElement}, with a configurable Ok/Yes/No/Cancel button set (see {@link DialogButtons}). */
 declare class PacemDialogElement extends PacemDialogBase {
+    /** Gets or sets which button set is shown (Ok, OkCancel, YesNo, YesNoCancel). */
     buttons: DialogButtons;
+    /** Gets or sets the caption of the Ok button. */
     okCaption: string;
+    /** Gets or sets the caption of the Yes button. */
     yesCaption: string;
+    /** Gets or sets the caption of the No button. */
     noCaption: string;
+    /** Gets or sets the caption of the Cancel button. */
     cancelCaption: string;
     private _buttons;
     protected lightbox: PacemLightboxElement;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     open(state?: any): Promise<DialogResultEventArgs>;
     viewActivatedCallback(): void;
-    /** Gets the 'ok', 'yes', 'no' and 'cancel' dialog buttons. */
+    /** @readonly Gets the 'ok', 'yes', 'no' and 'cancel' dialog buttons. */
     get dialogButtons(): {
         ok: Element;
         yes: Element;
@@ -598,32 +723,41 @@ declare class PacemDialogElement extends PacemDialogBase {
     };
 }
 
+/** ARIA-`separator` element drawing a horizontal or vertical divider line, with optional `prepend`/`append` slotted content. */
 declare class PacemDividerElement extends Components_2.PacemElement {
     constructor();
+    /** Gets or sets the divider's orientation. Invalid/unset values fall back to `'horizontal'`. */
     orientation: 'vertical' | 'horizontal';
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     viewActivatedCallback(): void;
     private _syncOrientation;
 }
 
+/** Renders an icon from a wide range of notations (inline SVG, Font Awesome, Material Symbols/Icons, LineIcons, CoreUI, or a plain image URL), lazily importing the matching stylesheet/script on demand. */
 declare class PacemIconElement extends Components_2.PacemElement {
     constructor();
+    /** Gets or sets the icon notation to render (see class remarks for the supported formats). */
     icon: string;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     viewActivatedCallback(): void;
     private _setIcon;
 }
 
+/** Renders an image as a CSS background (rather than an `<img>` src), enabling `cover`/`contain`/`auto` fitting and reporting its natural/decoded size. */
 declare class PacemImageElement extends Components_2.PacemElement {
     #private;
     constructor();
+    /** Gets or sets how the image is fit within its box (`cover`, `contain`, or `auto` for natural size). */
     adapt: 'cover' | 'contain' | 'auto';
+    /** Gets or sets the image URL to load and display. */
     src: string;
+    /** Gets or sets an explicit `width,height` size (e.g. `"20,20"`, `".5vh"`); falls back to the image's natural size when unset. */
     size: {
         width: string;
         height: string;
         weight?: number;
     };
+    /** @readonly Gets whether the image is currently being fetched/decoded. */
     loading: boolean;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     viewActivatedCallback(): void;
@@ -631,13 +765,17 @@ declare class PacemImageElement extends Components_2.PacemElement {
     private _setSource;
 }
 
+/** Watches a scrollable `container` and dispatches a `fetchmore` event whenever the user scrolls within `threshold` pixels of the bottom. */
 declare class PacemInfiniteScrollerElement extends PacemEventTarget {
     constructor();
+    /** Gets or sets the scrollable element (or a selector for it) to watch; `'$document'` (the default) watches the whole page. */
     container: string | HTMLElement;
+    /** Gets or sets the distance from the bottom (in pixels) that triggers a `fetchmore` event. */
     threshold: number;
     viewActivatedCallback(): void;
     disconnectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    /** Re-targets the watched scroll container/viewport/scroll-event-source. @param v An element, a CSS selector, or `'$document'` for the whole page. */
     setInfiniteScrollContainer(v?: string | HTMLElement): void;
     private _scrollDelegate;
     private _enabled;
@@ -653,12 +791,16 @@ declare class PacemInfiniteScrollerElement extends PacemEventTarget {
     private _computeHeight;
 }
 
+/** Full-viewport overlay ("lightbox") element showing its slotted content above a backdrop, with an auto-injected close button and optional modal (non-dismissible) behavior. */
 declare class PacemLightboxElement extends Components_2.PacemElement implements Lightbox {
     #private;
     private _keyupHandler;
     private _wrapperMousedownHandler;
+    /** Gets or sets whether the lightbox is visible. */
     show: boolean;
+    /** Gets or sets whether the lightbox is modal: when `true`, ESC and clicking outside no longer dismiss it and the close button is hidden. */
     modal: boolean;
+    /** Gets or sets whether clicking outside the content closes the lightbox (ignored while `modal`). */
     behavior: LightboxBehavior;
     private _wrapperElement;
     private _container;
@@ -679,25 +821,33 @@ declare class PacemLightboxElement extends Components_2.PacemElement implements
     private _lookForAButton;
 }
 
+/** Shows a spinner (plain CSS or the branded Pacem gear/SVG animation) while `active`, typically overlaid on content being loaded. */
 declare class PacemLoaderElement extends Components_2.PacemElement {
     private _spinner;
     private _container;
     private _svgSpinner;
+    /** Gets or sets whether the loader's spinner is shown. */
     active: boolean;
+    /** Gets or sets the spinner's visual style. */
     type: LoaderType;
     viewActivatedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
 }
 
+/** Renders its `value` property, interpreted as Markdown, as this element's inner HTML. */
 declare class PacemMarkdownElement extends Components_2.PacemElement {
     private _md;
     constructor(_md?: MarkdownService);
+    /** Gets or sets the Markdown source to render. */
     value: string;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    /** Tokenizes the given (or current `value`) Markdown source. */
     tokens(md?: string): any[];
+    /** Converts the given (or current `value`) Markdown source to an HTML string. */
     html(md?: string): string;
 }
 
+/** Continuously scrolls its content horizontally in a loop, like a classic marquee. */
 declare class PacemMarqueeElement extends Components_2.PacemElement {
     connectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
@@ -715,8 +865,10 @@ declare class PacemMarqueeElement extends Components_2.PacemElement {
     private _adjust;
 }
 
+/** Evaluates a CSS media query and reflects its match state, dispatching `change`/`match`/`unmatch` events as it changes. */
 declare class PacemMediaQueryElement extends PacemEventTarget {
     #private;
+    /** Gets or sets the CSS media query to evaluate. */
     query: string;
     /** @readonly */
     isMatch: boolean;
@@ -728,6 +880,7 @@ declare class PacemMediaQueryElement extends PacemEventTarget {
     private _init;
 }
 
+/** Animated cursor/indicator that tracks the anchor matching the current path within an ancestor `PacemMenuElement`. */
 declare class PacemMenuCursorElement extends Components_2.PacemElement {
     private _menu;
     viewActivatedCallback(): void;
@@ -736,11 +889,17 @@ declare class PacemMenuCursorElement extends Components_2.PacemElement {
     private _onPathChange;
 }
 
+/** Collapsible off-canvas/hamburger navigation menu, optionally synchronized with the enclosing shell's CSS classes. */
 declare class PacemMenuElement extends Components_2.PacemElement {
+    /** Gets or sets whether the menu is open. */
     open: boolean;
+    /** Gets or sets whether the hamburger (open) toggle button is hidden. */
     hideHamburgerButton: boolean;
+    /** Gets or sets whether the back (close) toggle button is hidden. */
     hideBackButton: boolean;
+    /** Gets or sets whether the menu renders outset, overlapping the surrounding content, rather than inline. */
     outset: boolean;
+    /** Gets or sets whether the open/close and outset state toggle CSS classes on the ancestor shell. */
     synchronizeShell: boolean;
     private _container;
     private _base;
@@ -754,51 +913,69 @@ declare class PacemMenuElement extends Components_2.PacemElement {
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
 }
 
+/** Renders pagination buttons (first/previous/numbers/next/last, or a numeric-only strip) for a paged collection. */
 declare class PacemPagerElement extends Components_2.PacemElement {
     private _repeater;
+    /** Gets or sets the zero-based index of the first item of the current page. */
     index: number;
+    /** Gets or sets the total number of items to paginate. */
     total: number;
+    /** Gets or sets the number of page buttons to display at once. */
     pages: number;
+    /** Gets or sets the number of items per page. */
     size: number;
+    /** Gets or sets the rendering mode: `standard` (first/previous/numbers/next/last) or `numeric-only`. */
     mode: 'standard' | 'numeric-only';
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     private _databind;
 }
 
+/** Responsive `<picture>` wrapper that builds its `<source>` elements from child `PacemPictureSourceElement` items. */
 declare class PacemPictureElement extends Components_2.PacemItemsContainerElement<PacemPictureSourceElement> {
     constructor();
     validate(item: any): boolean;
     private _picture;
     private _img;
+    /** Gets or sets the fallback image URL, rendered on the inner `<img>`'s `src` attribute. */
     src: string;
+    /** @readonly Gets the URL currently selected by the browser among the declared sources. */
     currentSrc: string;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     viewActivatedCallback(): void;
     disconnectedCallback(): void;
     private _updateCurrentSrcHandler;
+    /** Rebuilds the `<source>` elements from the current child `PacemPictureSourceElement` items. */
     refreshSources(): void;
     private _setSources;
     private _setSource;
     private _setAltText;
 }
 
+/** Declares a single `<source>` candidate (srcset/media/type) for an ancestor `PacemPictureElement`. */
 declare class PacemPictureSourceElement extends Components_2.PacemItemElement {
+    /** Gets or sets the candidate image URL(s), reflected onto the generated `<source>`'s `srcset` attribute. */
     srcset: string;
+    /** Gets or sets the media condition, reflected onto the generated `<source>`'s `media` attribute. */
     media: string;
+    /** Gets or sets the MIME type, reflected onto the generated `<source>`'s `type` attribute. */
     type: string;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
 }
 
+/** Horizontal progress bar with an optional textual caption. */
 declare class PacemProgressbarElement extends Components_2.PacemElement {
     constructor();
     private _bar;
     private _glow;
     private _caption;
+    /** Gets or sets the caption text; when empty, defaults to the current percentage value. */
     caption: string;
+    /** Gets or sets the completion percentage (0-100). */
     percentage: number;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
 }
 
+/** Combines a {@link PacemCalendarElement} (month view) and a {@link PacemAgendaElement} (day/week view) into a single scheduler, switching between them based on `zoom`. */
 declare class PacemScheduleElement extends PacemCalendarBaseElement {
     private _calendar;
     private _agenda;
@@ -806,9 +983,12 @@ declare class PacemScheduleElement extends PacemCalendarBaseElement {
     disconnectedCallback(): void;
 }
 
+/** Collapsible off-canvas drawer/sidebar, optionally synchronized with the enclosing shell's CSS classes. */
 declare class PacemSidebarElement extends Components_2.PacemElement {
     #private;
+    /** Gets or sets whether the sidebar is open. */
     open: boolean;
+    /** Gets or sets whether the open/close state toggles CSS classes on the ancestor shell. */
     synchronizeShell: boolean;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     disconnectedCallback(): void;
@@ -816,18 +996,25 @@ declare class PacemSidebarElement extends Components_2.PacemElement {
     connectedCallback(): void;
 }
 
+/** Single slide item hosted within a `PacemSlideshowElement`. */
 declare class PacemSlideElement extends Components_2.PacemIterableElement {
 }
 
+/** Iterates over `PacemSlideElement` children, exposing them as a navigable slideshow. */
 declare class PacemSlideshowElement extends Components_2.PacemIterativeElement<PacemSlideElement> {
     validate(item: any): item is PacemSlideElement;
 }
 
+/** Header that reacts to page scroll, either staying pinned to the top of the shell or hiding/showing on scroll direction. */
 declare class PacemStickyHeaderElement extends PacemEventTarget {
     #private;
+    /** Gets or sets the scroll offset, in pixels, beyond which the sticky behavior activates. */
     threshold: number;
+    /** @readonly Gets the current scroll offset tracked by this element. */
     offset: Components_2.ScrollEventArgs;
+    /** @readonly Gets whether the header is currently visible (relevant when `visibility` is `quickreturn`). */
     visible: boolean;
+    /** Gets or sets the sticky behavior: `persistent` (stays pinned) or `quickreturn` (hides/shows with scroll direction). */
     visibility: StickyHeaderVisibility;
     private _scrollHandler;
     private _ensureScrollAwareElement;
@@ -837,6 +1024,7 @@ declare class PacemStickyHeaderElement extends PacemEventTarget {
     disconnectedCallback(): void;
 }
 
+/** Single tab item, pairing a `label` with its content, hosted within a `PacemTabsElement`. */
 declare class PacemTabElement extends Components_2.PacemIterableElement {
     #private;
     constructor();
@@ -844,17 +1032,22 @@ declare class PacemTabElement extends Components_2.PacemIterableElement {
     viewActivatedCallback(): void;
     disconnectedCallback(): void;
     private _slotChangeHandler;
+    /** @readonly Gets the nodes assigned to the `label` slot. */
     get content(): NodeList;
+    /** Gets or sets the tab's label, either as plain text/HTML or a DOM node (also settable via a `slot="label"` child). */
     label: string | Node;
+    /** Gets or sets the tab's key, used as a CSS class hook when no explicit label content is provided. */
     key: string;
 }
 
+/** Iterates over `PacemTabElement` children, rendering a tab strip (via an adapter) and animating the transition between the active tab's content. */
 declare class PacemTabsElement extends Components_2.PacemIterativeElement<PacemTabElement> {
     private _tweener;
     constructor(_tweener?: Animations.TweenService);
     private _defaultTabAdapter;
     private _tabs;
     private _container;
+    /** @readonly Gets whether the default (built-in) tab adapter is currently in use. */
     private _isUsingDefaultTabAdapter;
     /** Gets or sets the orientation of the default tabs adapter. */
     orientation: AdapterOrientation;
@@ -866,6 +1059,7 @@ declare class PacemTabsElement extends Components_2.PacemIterativeElement<PacemT
     validate(item: any): item is PacemTabElement;
 }
 
+/** Displays scrolling/ticking content, animating the swap whenever its `content` changes. */
 declare class PacemTickerElement extends Components_2.PacemSafeContentElement {
     #private;
     private _slot;
@@ -879,9 +1073,13 @@ declare class PacemTickerElement extends Components_2.PacemSafeContentElement {
     disconnectedCallback(): void;
 }
 
+/** Dismissible toast/snackbar notification, with optional autohide. */
 declare class PacemToastElement extends Components_2.PacemElement {
+    /** Gets or sets whether the toast automatically hides itself after `timeout` milliseconds. */
     autohide: boolean;
+    /** Gets or sets the autohide delay, in milliseconds. */
     timeout: number;
+    /** Gets or sets whether the toast is currently shown. */
     show: boolean;
     connectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
@@ -889,6 +1087,7 @@ declare class PacemToastElement extends Components_2.PacemElement {
     private _handle;
     private _doHide;
     private _show;
+    /** Shows the toast, (re)starting the autohide timer if applicable. */
     popup(): void;
     /**
      * Opinionated shortcut/utility for toast spinning.
@@ -902,6 +1101,13 @@ declare class PacemToastElement extends Components_2.PacemElement {
         timeout?: number;
         cssClass?: string | string[];
     }): Promise<void>;
+    /**
+     * Like `toast`, but renders the message inside a filled/bordered container for extra emphasis.
+     * @param toaster Toast container
+     * @param level Message criticity level
+     * @param message The message
+     * @param options Further options object
+     */
     static toast2(toaster: HTMLElement, level: 'info' | 'success' | 'warning' | 'danger' | 'error', message: string | HTMLElement, options?: {
         autohide?: boolean;
         timeout?: number;
@@ -909,12 +1115,17 @@ declare class PacemToastElement extends Components_2.PacemElement {
     }): Promise<void>;
 }
 
+/** Table-of-contents that lists the headings/elements matched by `selector`, highlighting and scrolling to the currently focused one. */
 declare class PacemTocElement extends Components_2.PacemElement {
     private _tweener;
     constructor(_tweener?: Animations.TweenService);
+    /** Gets or sets the CSS selector used to collect the headings/items to list. */
     selector: string;
+    /** Gets or sets the vertical offset, in pixels (e.g. to account for a fixed header), applied when scrolling to an item. */
     offset: number;
+    /** Gets or sets the container element to search within (defaults to `document.body`) and observe for changes. */
     target: HTMLElement;
+    /** Gets or sets the `PacemRouterElement` used to navigate, if any, when clicking on an item. */
     router: Components_2.PacemRouterElement;
     /** @readonly */
     hasContent: boolean;
@@ -937,6 +1148,7 @@ declare class PacemTocElement extends Components_2.PacemElement {
     refresh(): void;
 }
 
+/** Circular dial/knob control for picking a numeric value between `min` and `max` by rotating a handle. */
 declare class PacemTunerElement extends Components_2.PacemElement {
     #private;
     constructor();
@@ -948,10 +1160,15 @@ declare class PacemTunerElement extends Components_2.PacemElement {
     viewActivatedCallback(): void;
     disconnectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    /** Gets or sets the current value. */
     value: number;
+    /** Gets or sets the minimum selectable value. */
     min: number;
+    /** Gets or sets the maximum selectable value. */
     max: number;
+    /** Gets or sets whether the dial can be rotated by the user. */
     interactive: boolean;
+    /** Gets or sets the number of decimal digits the value is rounded to. */
     round: number;
     private _toggleRotate;
     private _angleToValue;
@@ -969,7 +1186,9 @@ declare class PacemTunerElement extends Components_2.PacemElement {
     private _draw;
 }
 
+/** Embeds a tweet, given its id, via Twitter's `widgets.js`. */
 declare class PacemTweetEmbedElement extends Components_2.PacemElement {
+    /** Gets or sets the id of the tweet to embed. */
     tweetid: string;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     private _scriptsLoaded;
@@ -977,17 +1196,26 @@ declare class PacemTweetEmbedElement extends Components_2.PacemElement {
     private _render;
 }
 
+/** Triggers the device's vibration hardware (via the Vibration API) with a configurable pattern. */
 declare class PacemVibrateElement extends PacemEventTarget {
+    /** Gets or sets the vibration pattern: alternating vibration/pause durations, in milliseconds. */
     pattern: number[];
+    /** Triggers a vibration using the current `pattern`, if supported by the browser and not disabled. */
     vibrate(): void;
 }
 
+/** Fetches and renders remote HTML (or a local `<template>`'s content) as its own inner content, dispatching `prerender`/`render` lifecycle events. */
 declare class PacemViewElement extends PacemEventTarget {
     #private;
+    /** Gets or sets the content source: a URL to fetch, a CSS selector pointing to a `<template>`, or the template element itself. */
     url: string | HTMLTemplateElement | Components_2.PacemTemplateProxyElement;
+    /** @readonly Gets whether a remote fetch is currently in progress. */
     fetching: boolean;
+    /** @readonly Gets the current fetch progress, from 0 to 1 (`NaN` when unknown or not applicable). */
     progress: number;
+    /** Gets or sets whether non-OK HTTP responses should still be rendered instead of being ignored. */
     renderErrors: boolean;
+    /** Gets or sets whether 301/302 responses should be followed automatically. */
     followRedirects: boolean;
     /** use it to ensure animation */
     debounce: number;
@@ -1003,9 +1231,12 @@ declare class PacemViewElement extends PacemEventTarget {
     private _setTmpl;
     private _manageUrl;
     private _manageResult;
+    private _debounceDispatchHandler;
     private _dispatchRender;
+    private _dispatchPrerender;
 }
 
+/** Container that arranges `PacemWindowElement` children as draggable/resizable floating windows, or docks them one at a time via an adapter. */
 declare class PacemWindowAreaElement extends Components_2.PacemIterativeElement<PacemWindowElement> {
     validate(item: PacemWindowElement): boolean;
     private _behaviors;
@@ -1020,27 +1251,37 @@ declare class PacemWindowAreaElement extends Components_2.PacemIterativeElement<
     viewActivatedCallback(): void;
     disconnectedCallback(): void;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    /** Registers a window item, wiring drag/resize behaviors and focus tracking; returns whether it was newly added. */
     register(item: PacemWindowElement): boolean;
+    /** Unregisters a window item, tearing down its drag/resize behaviors; returns whether it was found and removed. */
     unregister(item: PacemWindowElement): boolean;
     private _itemPropertyChangeHandler;
     private _adapterPagerCallback;
     private _syncVisibility;
 }
 
+/** Single draggable, resizable, and dockable window pane hosted within a `PacemWindowAreaElement`. */
 declare class PacemWindowElement extends Components_2.PacemIterableElement {
+    /** Gets or sets the window's title bar caption. */
     caption: string;
+    /** Gets or sets whether the window is minimized. */
     minimized: boolean;
+    /** Gets or sets whether the window floats freely (draggable/resizable) rather than being docked. */
     floating: boolean;
     propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
     viewActivatedCallback(): void;
     private _syncLayout;
 }
 
+/** Determines how a `PacemStickyHeaderElement` behaves once the scroll offset passes its `threshold`. */
 declare enum StickyHeaderVisibility {
+    /** Stays pinned/visible once past the threshold. */
     Persistent = "persistent",
+    /** Hides while scrolling down and reappears while scrolling up. */
     QuickReturn = "quickreturn"
 }
 
+/** Event dispatched (and bubbling) when a time slot is selected on a {@link PacemAgendaElement}, carrying the selected date/time. */
 declare class TimeSelectEvent extends CustomTypedEvent<Date> {
     constructor(date: Date);
 }
@@ -1150,6 +1391,7 @@ export declare namespace UI {
     }
 }
 
+/** Event dispatched by a {@link PacemCalendarBaseElement} whenever its `viewDate` changes, carrying the new date. */
 declare class ViewDateChangeEvent extends CustomTypedEvent<Date> {
     constructor(date: Date);
 }