@pine-ds/core 4.2.0 → 4.4.0

package/dist/types/components/pds-datepicker/pds-datepicker.d.ts

@@ -0,0 +1,489 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { PlacementType } from "../../utils/types";
+import type { DatepickerChangeEventDetail, DatepickerPreset } from './datepicker-interface';
+type DateError = '' | 'format' | 'min' | 'max';
+/**
+ * A field for one date, or in range mode a start and end date, with a calendar to pick from.
+ * The value is `YYYY-MM-DD`, or `YYYY-MM-DD/YYYY-MM-DD` for a range; with the time picker, each
+ * date carries a time, as `YYYY-MM-DDTHH:mm`.
+ *
+ * @part calendar - The open calendar. It's portaled out of the datepicker, so style it with `.pds-datepicker-calendar-portal::part(calendar)`.
+ * @part presets - The list of preset ranges in the calendar, styled with `.pds-datepicker-calendar-portal::part(presets)`.
+ */
+export declare class PdsDatepicker {
+    private inputEl?;
+    private triggerEl?;
+    private clearEl?;
+    private dialogEl?;
+    /** Where the open calendar lives, outside the datepicker so no ancestor clips or misplaces it. */
+    private portal?;
+    private internals?;
+    private cleanupAutoUpdate?;
+    /** Set when the active day should take focus on the next render. */
+    private focusActiveDay;
+    private readonly fallbackId;
+    /** Set by a click on the label, whose forwarded click on the input shouldn't open the calendar. */
+    private skipForwardedClick;
+    /** Set while an arrow key selects a preset, which auto-apply doesn't apply. */
+    private presetByArrow;
+    /** The value when the calendar opened, or as last set from outside, which Cancel (without `clearable`) and Escape go back to. */
+    private valueAtOpen;
+    /** The draft's start and end times from before text typed in the field changed them. */
+    private timesBeforeTyping?;
+    /** Set while the datepicker commits a value itself, as opposed to one set from outside. */
+    private committing;
+    /** Whether focus is in the datepicker or its calendar, for pdsFocus and pdsBlur. */
+    private hasFocus;
+    el: HTMLPdsDatepickerElement;
+    /**
+     * Accessible label for the button that applies the chosen dates.
+     */
+    applyLabel: string;
+    /**
+     * In range mode, applies the range as soon as its end or a preset is picked, without the Apply and
+     * Cancel buttons. Has no effect with the time picker, whose times still need Apply.
+     */
+    autoApply: boolean;
+    /**
+     * Accessible label for the button that closes the calendar without changing the dates.
+     */
+    cancelLabel: string;
+    /**
+     * Adds a button in the field that empties it, shown while there's a value. Where Apply and Cancel
+     * buttons show, Clear also takes the place of Cancel.
+     */
+    clearable: boolean;
+    /**
+     * Accessible label for the button that empties the field, when `clearable` is set.
+     */
+    clearLabel: string;
+    /**
+     * A unique identifier used for the underlying component `id` attribute.
+     */
+    componentId: string;
+    /**
+     * The label of the presets entry that stands for a range of your own. Range mode with presets only.
+     */
+    customRangeLabel: string;
+    /**
+     * Determines whether or not the datepicker is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Accessible label for the end time, in range mode with the time picker.
+     */
+    endTimeLabel: string;
+    /**
+     * Specifies the error message and provides an error-themed treatment to the field.
+     */
+    errorMessage?: string;
+    /**
+     * The first day of the week in the calendar, from `0` (Sunday) to `6` (Saturday). Defaults to the
+     * locale's first day where the browser reports it, otherwise Sunday.
+     */
+    firstDayOfWeek?: number;
+    /**
+     * How the field shows dates and reads typed ones, as tokens: `YYYY`, `MMMM` or `MMM` (month name,
+     * in the locale), `MM` or `M` (month), `DD` or `D` (day), and with the time picker `HH` or `H`
+     * (24-hour), `hh` or `h` (12-hour), `mm` and `A` (AM/PM, in the locale), as `MM/DD/YYYY`,
+     * `MMM D, YYYY` or `D.M.YYYY h:mm A`. Put literal text in brackets, as `[Due] D/M/YYYY`. The value
+     * and the change event stay ISO (`YYYY-MM-DD`), whatever the format. Typed ISO dates are always
+     * accepted too.
+     */
+    format: string;
+    /**
+     * Determines whether or not the datepicker takes full width of its container.
+     */
+    fullWidth?: boolean;
+    /**
+     * Displays a message or hint below the field.
+     */
+    helperMessage?: string;
+    /**
+     * Visually hides the label text for instances where only the field should be displayed. Label remains accessible to assistive technology such as screen readers.
+     */
+    hideLabel: boolean;
+    /**
+     * Accessible label for the hour in the time picker.
+     */
+    hourLabel: string;
+    /**
+     * Determines whether or not the datepicker is invalid or throws an error.
+     */
+    invalid?: boolean;
+    /**
+     * The validation message the form reports when the typed text isn't a date that can be picked.
+     */
+    invalidDateMessage: string;
+    /**
+     * The validation message the form reports for a date after `max`. `{date}` is replaced by the
+     * latest date, in the field's format.
+     */
+    maxDateMessage: string;
+    /**
+     * The validation message the form reports for a date before `min`. `{date}` is replaced by the
+     * earliest date, in the field's format.
+     */
+    minDateMessage: string;
+    /**
+     * Text to be displayed as the datepicker label.
+     */
+    label?: string;
+    /**
+     * The locale used for month and weekday names, as a BCP 47 language tag such as `en-US` or `fr`.
+     * Defaults to the nearest `lang` attribute, then the page's `<html lang>`, then `en`.
+     */
+    locale?: string;
+    /**
+     * The latest date that can be picked, as `YYYY-MM-DD`.
+     */
+    max?: string;
+    /**
+     * The earliest date that can be picked, as `YYYY-MM-DD`.
+     */
+    min?: string;
+    /**
+     * The minutes the time picker steps by, such as `15` or `30`.
+     */
+    minuteIncrement: number;
+    /**
+     * Accessible label for the minute in the time picker.
+     */
+    minuteLabel: string;
+    /**
+     * Accessible label for the month dropdown, when `show-dropdowns` is set.
+     */
+    monthLabel: string;
+    /**
+     * Specifies the name. Submitted with the form name/value pair.
+     */
+    name?: string;
+    /**
+     * Accessible label for the button that shows the next month.
+     */
+    nextMonthLabel: string;
+    /**
+     * Accessible label for the AM or PM choice in the time picker, in locales with a 12-hour clock.
+     */
+    periodLabel: string;
+    /**
+     * Specifies a short hint that describes the expected value of the field. Defaults to the format
+     * the field takes, such as `YYYY-MM-DD`.
+     */
+    placeholder?: string;
+    /**
+     * The placement of the calendar relative to the field.
+     */
+    placement: PlacementType;
+    /**
+     * Ranges listed beside the calendar in range mode. A comma-separated list of built-in keys
+     * (`today`, `yesterday`, `last-7-days`, `last-30-days`, `last-90-days`, `this-month`,
+     * `last-month`, `this-quarter`, `last-quarter`, `this-year`, `last-year`, `year-to-date`,
+     * `last-12-months`), or an array of `{ key, label?, start?, end? }` to relabel built-ins or add
+     * your own.
+     */
+    presets?: string | DatepickerPreset[];
+    /**
+     * Accessible label for the list of presets, in range mode.
+     */
+    presetsLabel: string;
+    /**
+     * Accessible label for the button that shows the previous month.
+     */
+    previousMonthLabel: string;
+    /**
+     * Picks a range: a start and an end date, from two months side by side, applied with the Apply
+     * button. The value is `YYYY-MM-DD/YYYY-MM-DD`.
+     */
+    range: boolean;
+    /**
+     * Determines whether or not the datepicker is readonly.
+     */
+    readonly?: boolean;
+    /**
+     * Determines whether or not the datepicker is required.
+     */
+    required?: boolean;
+    /**
+     * Shows month and year dropdowns in place of the month heading, for jumping far, as to a birth year.
+     */
+    showDropdowns: boolean;
+    /**
+     * Accessible label for the start time, in range mode with the time picker.
+     */
+    startTimeLabel: string;
+    /**
+     * Adds hour and minute pickers below the calendar, and the value carries the time as
+     * `YYYY-MM-DDTHH:mm`. The dates are applied with the Apply button.
+     */
+    timePicker: boolean;
+    /**
+     * Accessible label for the time, with the time picker and a single date.
+     */
+    timeLabel: string;
+    /**
+     * Accessible label for the button that opens the calendar. The selected date is added to it.
+     */
+    triggerLabel: string;
+    /**
+     * The selected date as `YYYY-MM-DD`, or in range mode the range as `YYYY-MM-DD/YYYY-MM-DD`; with
+     * the time picker, each date as `YYYY-MM-DDTHH:mm`. An empty string when nothing is selected.
+     */
+    value?: string;
+    /**
+     * Accessible label for the year dropdown, when `show-dropdowns` is set.
+     */
+    yearLabel: string;
+    /**
+     * Emitted when the value changes.
+     *
+     * This event will not emit when programmatically setting the `value` property.
+     */
+    pdsDatepickerChange: EventEmitter<DatepickerChangeEventDetail>;
+    /**
+     * Emitted when the datepicker loses focus: when focus leaves the field and the calendar.
+     */
+    pdsBlur: EventEmitter<FocusEvent>;
+    /**
+     * Emitted when the datepicker gains focus: when focus moves into the field or the calendar from outside.
+     */
+    pdsFocus: EventEmitter<FocusEvent>;
+    isOpen: boolean;
+    /** The text in the field, which may not be a valid date yet. */
+    text: string;
+    /** Why the typed text wasn't committed: it isn't a date, or it's before `min` or after `max`. */
+    textError: DateError;
+    /** The day the keyboard is on in the calendar, as `YYYY-MM-DD`. */
+    activeDate: string;
+    /** The first month on view, as the first of the month, `YYYY-MM-DD`. */
+    viewMonth: string;
+    /**
+     * The dates being chosen, before Apply: range mode's start and end, or the time picker's date.
+     * The end is empty while it's being picked.
+     */
+    draftStart: string;
+    draftEnd: string;
+    /** The time picker's times, as `HH:mm`. */
+    startTime: string;
+    endTime: string;
+    /** Range mode: the day under the pointer or keyboard, previewing the end of the range. */
+    previewDate: string;
+    /**
+     * Opens the calendar and moves focus to the selected day, or today.
+     */
+    open(): Promise<void>;
+    /**
+     * Closes the calendar.
+     */
+    close(): Promise<void>;
+    /**
+     * Sets focus on the datepicker's text field.
+     */
+    setFocus(): Promise<void>;
+    protected valueChanged(): void;
+    /**
+     * Props that change how the value reads or what can be picked: refresh the field, and an open
+     * calendar, as when a framework sets them after the datepicker loads.
+     */
+    protected contextChanged(): void;
+    protected placementChanged(): void;
+    private refreshFromValue;
+    protected requiredChanged(): void;
+    componentWillLoad(): void;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    componentDidRender(): void;
+    /** Focuses the active day once the calendar is placed: a hidden calendar can't take focus. */
+    private flushActiveDayFocus;
+    /** The id the datepicker's parts are named from: `component-id`, or a generated one. */
+    private get baseId();
+    private get resolvedLocale();
+    private get weekStart();
+    private get minDate();
+    private get maxDate();
+    private get isInteractive();
+    /** How many months the calendar shows side by side. */
+    private get monthCount();
+    /** Whether picks apply at once, without the footer: `auto-apply` in range mode, without times. */
+    private get appliesOnPick();
+    /** Whether picks wait for Apply: for a range, unless it auto-applies, and for a date with a time. */
+    private get hasFooter();
+    private get resolvedPresets();
+    /** The committed value, parsed: one date, or a range's start and end. */
+    private parsedValue;
+    /** The format the field shows and reads, with a time when the time picker is on. */
+    private get resolvedFormat();
+    /** What the field shows for the committed value. */
+    private fieldText;
+    /** Drops a time the time picker doesn't show, or adds the default one it does. */
+    private withTimePicker;
+    private get fieldPlaceholder();
+    /** Loads the committed value into the draft the calendar edits. */
+    private loadDraft;
+    /**
+     * Opens the calendar. From the button or the keyboard, focus moves to the active day; from a
+     * click in the field, it stays there so typing keeps working.
+     */
+    private openCalendar;
+    private closeCalendar;
+    /**
+     * Makes a day the active one and brings it into view. With two months, a day already on view
+     * doesn't move the view; `reset` lines the view up so the day is in the last month shown.
+     */
+    private showDate;
+    private pickDate;
+    /**
+     * The first pick starts a range and the second ends it. A day before the start moves the start,
+     * and a pick after a finished range starts a new one.
+     */
+    private pickRangeDay;
+    /** Sets the value from the user, emitting the change event when it differs. */
+    private commitValue;
+    /** Commits one date, or a range with its start, end and matching preset. */
+    private commitParts;
+    /** The draft as values, or `null` before a start is picked. A lone start is a one-day range. */
+    private draftParts;
+    private onApply;
+    /** Cancel empties the field with `clearable`, and otherwise leaves the dates as they were. */
+    private onCancel;
+    /**
+     * Goes back to the value from when the calendar opened, as Cancel and Escape do, and drops any
+     * typed text still pending. With Apply showing, typed text isn't committed while focus stays in
+     * the datepicker, so usually there's only text to drop; without a footer, text typed in the
+     * field is committed when it loses focus, so that commit is undone here.
+     */
+    private restoreValueAtOpen;
+    private onPresetClick;
+    /** Arrow keys move between the presets, picking each, as in a radio group. Custom range only takes focus. */
+    private onPresetsKeyDown;
+    /**
+     * Keeps a press on the clear button, by mouse or touch, from blurring the field, so the text
+     * typed in it isn't committed before the click empties it.
+     */
+    private onClearMouseDown;
+    /** The field's clear button: empties the field and returns focus to it. */
+    private onClearClick;
+    /** "Custom range" points to the calendar, where a range of your own is picked. */
+    private onCustomRangeClick;
+    private onDocumentPointerDown;
+    /** Whether a node is the datepicker, inside it, or in its portaled calendar. */
+    private isInside;
+    /**
+     * Reports focus arriving from outside. Focus moving within the datepicker never reaches the host:
+     * once retargeted, its target and related target are both the host, so the browser skips it.
+     */
+    private onHostFocusIn;
+    /**
+     * Focus arriving in the datepicker or its portaled calendar from outside emits pdsFocus, once.
+     * Tracked with a flag rather than `relatedTarget`, which is null or retargeted once the calendar
+     * is portaled out of the datepicker.
+     */
+    private focusEntered;
+    /**
+     * Once focus settles, whether it left both the datepicker and its calendar: then pdsBlur, once,
+     * and the calendar closes if focus went to another control. Focus that fell to the page, as on a
+     * click on a blank area or when a focused control is disabled, leaves the calendar open.
+     */
+    private checkFocusLeft;
+    /**
+     * The calendar is a modal dialog while focus is in it. Opened by a click in the field, focus stays
+     * in the field and the calendar is a plain popup beside it. Set on the element rather than through
+     * state: focus often moves in from `componentDidRender`, where a state change doesn't re-render.
+     */
+    private onCalendarFocusIn;
+    /**
+     * The portaled calendar is outside the datepicker, so the host never hears focus leave it: close
+     * and report blur from here when focus goes from the calendar to the rest of the page. Checked
+     * once focus has settled, with `:focus-within`, rather than from `relatedTarget`, which is
+     * retargeted past the datepicker when it sits in another component's shadow root.
+     */
+    private onCalendarFocusOut;
+    /** Closes the calendar and reports blur when focus leaves the datepicker, as when tabbing out. */
+    private onHostFocusOut;
+    private startPositioning;
+    private stopPositioning;
+    /** The field's box, so the calendar lines up with it rather than with the label or messages. */
+    private fieldReference;
+    private stopInnerEvent;
+    /** A click in the field opens the calendar beside it; the button inside toggles it on its own. */
+    private onFieldClick;
+    /** Typing a date or range the calendar can show moves the open calendar to it. */
+    private onTextInput;
+    private onTextChange;
+    /**
+     * Commits text typed while the calendar was open, when it closes without Apply or Cancel. A
+     * valid date or range commits the draft, which also holds a time picked in the calendar; text
+     * that isn't one is read as typed, so the field shows its error.
+     */
+    private commitPendingText;
+    /** The typed text as a date or range, or `null` if it isn't one; it may be outside `min` and `max`. */
+    private readText;
+    /** The typed text as a date or range that can be picked, or `null`. */
+    private parseText;
+    /** Whether any of these dates is before `min` or after `max`. */
+    private rangeError;
+    /** What's wrong with the committed value, as one set in code: not a date, or out of range. */
+    private valueError;
+    private commitText;
+    private onTextKeyDown;
+    /**
+     * The calendar button's keys. Escape closes an open calendar, as in the field and the calendar,
+     * and is stopped there, so a modal or popover around the datepicker stays open. Tab goes into a
+     * calendar a click in the field opened: it's portaled to the end of the page, so Tab would
+     * otherwise skip past it.
+     */
+    private onTriggerKeyDown;
+    private onTriggerClick;
+    /** Whether the month before (`-1`) or after (`1`) the ones on view has a day in range. */
+    private canShowMonth;
+    private showMonth;
+    /** Shows the chosen month in the calendar at `index`, from the month or year dropdown. */
+    private jumpTo;
+    /**
+     * Drops text typed in the field and not committed, showing the committed value again. pds-input
+     * is set directly: when typing and this land in one frame, the rendered text never changed.
+     */
+    private dropTypedText;
+    private onDialogKeyDown;
+    /** Keeps Tab within the calendar while it's open, as in a modal dialog. */
+    private trapTab;
+    private onGridKeyDown;
+    /** The day under an event in a grid, from its cell. */
+    private dayFromEvent;
+    private onGridClick;
+    private onGridPointerOver;
+    /**
+     * Submits the value and reports validity to the form, as pds-input does: `required` with no
+     * value, or typed text that isn't a date, blocks submission.
+     */
+    private updateFormValue;
+    /** A min or max message with its date, in the field's format. */
+    private boundMessage;
+    formResetCallback(): void;
+    /** Disabling the datepicker, or making it read-only, while the calendar is open closes it. */
+    protected interactivityChanged(): void;
+    formDisabledCallback(disabled: boolean): void;
+    formStateRestoreCallback(state: string | FormData | null): void;
+    private triggerAccessibleName;
+    /** The range to highlight: the chosen one, or the start to the previewed day while picking the end. */
+    private highlightedRange;
+    /** The day shown as selected: the draft, which opens as the committed day and follows typing. */
+    private selectedDay;
+    private renderMonthHeading;
+    private renderMonth;
+    /**
+     * The time pickers under a month: the start time under the first and the end time under the
+     * second, or both under the one month a narrow range shows.
+     */
+    private timesUnderMonth;
+    /** Hour, minute and (on a 12-hour clock) AM/PM pickers for the start or end time. */
+    private renderTime;
+    private renderPresets;
+    /** What Apply would set, in the field's format: shown in the footer, and announced as it changes. */
+    private selectionText;
+    private renderFooter;
+    private renderCalendar;
+    render(): any;
+}
+export {};

package/dist/types/components/pds-datepicker/presets.d.ts

@@ -0,0 +1,23 @@
+import type { DatepickerPreset } from './datepicker-interface';
+/** A preset resolved against today: what the panel lists and matches the range against. */
+export interface ResolvedPreset {
+    key: string;
+    label: string;
+    start: Date;
+    end: Date;
+}
+/**
+ * The range a built-in preset covers on the given day, or `null` for an unknown key. "Last N days"
+ * is N days ending today; "this" and "last" periods are whole periods; "to date" ends today.
+ */
+export declare function builtInPresetRange(key: string, now: Date): [Date, Date] | null;
+/**
+ * Normalizes the `presets` prop: a comma-separated list of built-in keys, or an array of presets
+ * that may relabel a built-in (for translation) or give their own `start` and `end`. Entries that
+ * resolve to no range are dropped.
+ */
+export declare function resolvePresets(presets: string | DatepickerPreset[] | undefined, now: Date): ResolvedPreset[];
+/** The first preset covering exactly this range. */
+export declare function matchPreset(presets: ResolvedPreset[], start: Date | null, end: Date | null): ResolvedPreset | undefined;
+/** Whether a preset's whole range can be picked within `min` and `max`. */
+export declare function presetInRange(preset: ResolvedPreset, min: Date | null, max: Date | null): boolean;

package/dist/types/components/pds-datepicker/value.d.ts

@@ -0,0 +1,47 @@
+/** A day, with a wall-clock time when the time picker is on. No time zone, so it never shifts. */
+export interface DateTimeValue {
+    date: Date;
+    /** `HH:mm`, 24-hour, or `null` without a time. */
+    time: string | null;
+}
+/** Parses `YYYY-MM-DD`, `YYYY-MM-DDTHH:mm` or `YYYY-MM-DD HH:mm`. */
+export declare function parseDateTime(text: string | null | undefined): DateTimeValue | null;
+export declare const DEFAULT_FORMAT = "YYYY-MM-DD";
+/**
+ * The field's format: the date format, with a time added when the time picker is on and it has
+ * none, on the same clock as the time picker. A 12-hour format gets AM/PM if it has none, as
+ * `1:30` alone can't say which.
+ */
+export declare function fieldFormat(format: string | null | undefined, timePicker: boolean, hour12?: boolean): string;
+/** Writes a date in a format of tokens (see `FORMAT_PARTS`), with month names and AM/PM in the locale. */
+export declare function formatWith(value: DateTimeValue, format: string, locale?: string): string;
+/**
+ * Reads typed text in a format of tokens, as written by `formatWith`. Leading zeros are optional,
+ * spaces are loose, and month names and AM/PM are matched without regard to case, in the locale or
+ * in English. Returns `null` for anything that isn't a real date and time in that format.
+ */
+export declare function parseWith(text: string | null | undefined, format: string, locale?: string): DateTimeValue | null;
+/** Reads one typed date in the format, falling back to ISO, which is always accepted. */
+export declare function parseFieldText(text: string | null | undefined, format?: string, locale?: string): DateTimeValue | null;
+/**
+ * Parses a typed range: two dates (with times, optionally) joined by a dash or `to` with spaces
+ * around it, as `2026-09-13 – 2026-10-13`, or by `/` when the format doesn't use slashes. The
+ * split is tried at each separator until both halves read as dates, so a format that itself has a
+ * spaced dash, as `D - M - YYYY`, still works.
+ */
+export declare function parseRangeText(text: string | null | undefined, format?: string, locale?: string): [DateTimeValue, DateTimeValue] | null;
+export declare function compareDateTime(a: DateTimeValue, b: DateTimeValue): number;
+/** The value form: `YYYY-MM-DD`, or `YYYY-MM-DDTHH:mm` with a time. */
+export declare function toValueString(value: DateTimeValue): string;
+/** The field form in a format, or by default `YYYY-MM-DD`, with ` HH:mm` when it has a time. */
+export declare function toFieldText(value: DateTimeValue, format?: string, locale?: string): string;
+export declare const RANGE_SEPARATOR = " \u2013 ";
+/** Hour and minute numbers from `HH:mm`. */
+export declare function splitTime(time: string): [number, number];
+export declare function joinTime(hours: number, minutes: number): string;
+/** Whether the locale writes times on a 12-hour clock, and its AM and PM words. */
+export declare function clockFor(locale: string): {
+    hour12: boolean;
+    am: string;
+    pm: string;
+};

package/dist/types/components/pds-dropdown-menu/pds-dropdown-menu.d.ts

@@ -27,6 +27,7 @@ export declare class PdsDropdownMenu implements BasePdsProps {
     private toggleDropdown;
     private openDropdown;
     private closeDropdown;
+    private isFocusInMenu;
     private handleClick;
     private isItemDisabled;
     private getFocusedItemIndex;

package/dist/types/components/pds-modal/pds-modal.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from '../../stencil-public-runtime';
+import type { ModalSizeType } from "../../utils/types";
 export declare class PdsModal {
     private modalRef;
     private previousActiveElement;
@@ -19,10 +20,12 @@ export declare class PdsModal {
      */
     open: boolean;
     /**
-     * The size of the modal
+     * The size of the modal. Can be a predefined value ('sm', 'md', 'lg', 'fullscreen') or a custom
+     * max-width as a CSS length (e.g., '1250px', '80vw'). A custom width stays fluid below that size.
+     * A value that is neither falls back to 'md'.
      * @default 'md'
      */
-    size: 'sm' | 'md' | 'lg' | 'fullscreen';
+    size: ModalSizeType | (string & Record<never, never>);
     /**
      * Whether the modal content should be scrollable
      * @default true
@@ -63,6 +66,8 @@ export declare class PdsModal {
      * Stores the list of focusable elements in the modal
      */
     focusableElementsArray: HTMLElement[];
+    componentWillLoad(): void;
+    sizeChanged(): void;
     componentDidLoad(): void;
     componentDidRender(): void;
     disconnectedCallback(): void;
@@ -122,5 +127,7 @@ export declare class PdsModal {
      */
     private isInnermostModal;
     private handleKeyDown;
+    private resolveSize;
+    private warnOnInvalidSize;
     render(): any;
 }

package/dist/types/components/pds-multiselect/multiselect-interface.d.ts

@@ -9,12 +9,28 @@ export interface MultiselectOption {
      * rows with the same label produce separate headers (mirrors native `<optgroup>`).
      */
     group?: string;
+    /**
+     * Sets the dot color of the option's chip when the multiselect's `optionDisplay` is `'chip'`. Accepts a sentiment
+     * name other than `brand` (e.g. `success`), a color token, or a [valid color value](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value).
+     */
+    dotColor?: string;
+    /**
+     * The name of the icon for this option's action, such as `pen`; URLs and file paths are not accepted. Shown when the
+     * multiselect has `optionActions`; options without a valid icon name have no action.
+     */
+    actionIcon?: string;
+    /** Overrides the multiselect's `optionActionLabel` for this option; `{text}` is interpolated. */
+    actionLabel?: string;
     isCreateOption?: boolean;
     [key: string]: unknown;
 }
 export interface MultiselectChangeEventDetail {
     values: string[];
     items: MultiselectOption[];
+    /** Values selected by this change. Always present on emitted events. */
+    added?: string[];
+    /** Values deselected by this change. Always present on emitted events. */
+    removed?: string[];
 }
 export interface MultiselectSearchEventDetail {
     query: string;
@@ -27,6 +43,9 @@ export interface MultiselectCreateEventDetail {
     query: string;
     newOption: MultiselectOption;
 }
+export interface MultiselectOptionActionEventDetail {
+    option: MultiselectOption;
+}
 export interface AsyncResponse {
     results: Array<{
         id: string | number;