@redvars/peacock 3.8.1 → 3.8.2

package/dist/src/__internal/aria/aria.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Accessibility Object Model reflective aria property name types.
+ */
+export type ARIAProperty = keyof ARIAMixin;
+/**
+ * Accessibility Object Model reflective aria properties.
+ */
+export declare const ARIA_PROPERTIES: ARIAProperty[];
+/**
+ * Accessibility Object Model aria attribute name types.
+ */
+export type ARIAAttribute = ARIAPropertyToAttribute<ARIAProperty>;
+/**
+ * Accessibility Object Model aria attributes.
+ */
+export declare const ARIA_ATTRIBUTES: ("role" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-braillelabel" | "aria-brailleroledescription" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colindextext" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-description" | "aria-details" | "aria-disabled" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowindextext" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext")[];
+/**
+ * Checks if an attribute is one of the AOM aria attributes.
+ *
+ * @example
+ * isAriaAttribute('aria-label'); // true
+ *
+ * @param attribute The attribute to check.
+ * @return True if the attribute is an aria attribute, or false if not.
+ */
+export declare function isAriaAttribute(attribute: string): attribute is ARIAAttribute;
+/**
+ * Converts an AOM aria property into its corresponding attribute.
+ *
+ * @example
+ * ariaPropertyToAttribute('ariaLabel'); // 'aria-label'
+ *
+ * @param property The aria property.
+ * @return The aria attribute.
+ */
+export declare function ariaPropertyToAttribute<K extends ARIAProperty>(property: K): ARIAPropertyToAttribute<K>;
+type ARIAPropertyToAttribute<K extends string> = K extends `aria${infer Suffix}Element${infer OptS}` ? `aria-${Lowercase<Suffix>}` : K extends `aria${infer Suffix}` ? `aria-${Lowercase<Suffix>}` : K;
+/**
+ * An extension of `ARIAMixin` that enforces strict value types for aria
+ * properties.
+ *
+ * This is needed for correct typing in render functions with lit analyzer.
+ *
+ * @example
+ * render() {
+ *   const {ariaLabel} = this as ARIAMixinStrict;
+ *   return html`
+ *     <button aria-label=${ariaLabel || nothing}>
+ *       <slot></slot>
+ *     </button>
+ *   `;
+ * }
+ */
+export interface ARIAMixinStrict extends ARIAMixin {
+    ariaAtomic: 'true' | 'false' | null;
+    ariaAutoComplete: 'none' | 'inline' | 'list' | 'both' | null;
+    ariaBusy: 'true' | 'false' | null;
+    ariaChecked: 'true' | 'false' | null;
+    ariaColCount: `${number}` | null;
+    ariaColIndex: `${number}` | null;
+    ariaColSpan: `${number}` | null;
+    ariaCurrent: 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false' | null;
+    ariaDisabled: 'true' | 'false' | null;
+    ariaExpanded: 'true' | 'false' | null;
+    ariaHasPopup: 'false' | 'true' | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog' | null;
+    ariaHidden: 'true' | 'false' | null;
+    ariaInvalid: 'true' | 'false' | null;
+    ariaKeyShortcuts: string | null;
+    ariaLabel: string | null;
+    ariaLevel: `${number}` | null;
+    ariaLive: 'assertive' | 'off' | 'polite' | null;
+    ariaModal: 'true' | 'false' | null;
+    ariaMultiLine: 'true' | 'false' | null;
+    ariaMultiSelectable: 'true' | 'false' | null;
+    ariaOrientation: 'horizontal' | 'vertical' | 'undefined' | null;
+    ariaPlaceholder: string | null;
+    ariaPosInSet: `${number}` | null;
+    ariaPressed: 'true' | 'false' | null;
+    ariaReadOnly: 'true' | 'false' | null;
+    ariaRequired: 'true' | 'false' | null;
+    ariaRoleDescription: string | null;
+    ariaRowCount: `${number}` | null;
+    ariaRowIndex: `${number}` | null;
+    ariaRowSpan: `${number}` | null;
+    ariaSelected: 'true' | 'false' | null;
+    ariaSetSize: `${number}` | null;
+    ariaSort: 'ascending' | 'descending' | 'none' | 'other' | null;
+    ariaValueMax: `${number}` | null;
+    ariaValueMin: `${number}` | null;
+    ariaValueNow: `${number}` | null;
+    ariaValueText: string | null;
+    role: ARIARole | null;
+}
+/**
+ * Valid values for `role`.
+ */
+export type ARIARole = 'alert' | 'alertdialog' | 'button' | 'checkbox' | 'dialog' | 'gridcell' | 'link' | 'log' | 'marquee' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'option' | 'progressbar' | 'radio' | 'scrollbar' | 'searchbox' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'tabpanel' | 'textbox' | 'timer' | 'tooltip' | 'treeitem' | 'combobox' | 'grid' | 'listbox' | 'menu' | 'menubar' | 'radiogroup' | 'tablist' | 'tree' | 'treegrid' | 'application' | 'article' | 'cell' | 'columnheader' | 'definition' | 'directory' | 'document' | 'feed' | 'figure' | 'group' | 'heading' | 'img' | 'list' | 'listitem' | 'math' | 'none' | 'note' | 'presentation' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'separator' | 'table' | 'term' | 'text' | 'toolbar' | 'banner' | 'complementary' | 'contentinfo' | 'form' | 'main' | 'navigation' | 'region' | 'search' | 'doc-abstract' | 'doc-acknowledgments' | 'doc-afterword' | 'doc-appendix' | 'doc-backlink' | 'doc-biblioentry' | 'doc-bibliography' | 'doc-biblioref' | 'doc-chapter' | 'doc-colophon' | 'doc-conclusion' | 'doc-cover' | 'doc-credit' | 'doc-credits' | 'doc-dedication' | 'doc-endnote' | 'doc-endnotes' | 'doc-epigraph' | 'doc-epilogue' | 'doc-errata' | 'doc-example' | 'doc-footnote' | 'doc-foreword' | 'doc-glossary' | 'doc-glossref' | 'doc-index' | 'doc-introduction' | 'doc-noteref' | 'doc-notice' | 'doc-pagebreak' | 'doc-pagelist' | 'doc-part' | 'doc-preface' | 'doc-prologue' | 'doc-pullquote' | 'doc-qna' | 'doc-subtitle' | 'doc-tip' | 'doc-toc';
+export {};

package/dist/src/__internal/aria/delegate.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LitElement } from 'lit';
+import { MixinBase, MixinReturn } from '../mixins/mixin.js';
+/**
+ * Mixes in aria delegation for elements that delegate focus and aria to inner
+ * shadow root elements.
+ *
+ * This mixin fixes invalid aria announcements with shadow roots, caused by
+ * duplicate aria attributes on both the host and the inner shadow root element.
+ *
+ * Note: this mixin **does not yet support** ID reference attributes, such as
+ * `aria-labelledby` or `aria-controls`.
+ *
+ * @example
+ * ```ts
+ * class MyButton extends mixinDelegatesAria(LitElement) {
+ *   static shadowRootOptions = {mode: 'open', delegatesFocus: true};
+ *
+ *   render() {
+ *     return html`
+ *       <button aria-label=${this.ariaLabel || nothing}>
+ *         <slot></slot>
+ *       </button>
+ *     `;
+ *   }
+ * }
+ * ```
+ * ```html
+ * <my-button aria-label="Plus one">+1</my-button>
+ * ```
+ *
+ * Use `ARIAMixinStrict` for lit analyzer strict types, such as the "role"
+ * attribute.
+ *
+ * @example
+ * ```ts
+ * return html`
+ *   <button role=${(this as ARIAMixinStrict).role || nothing}>
+ *     <slot></slot>
+ *   </button>
+ * `;
+ * ```
+ *
+ * In the future, updates to the Accessibility Object Model (AOM) will provide
+ * built-in aria delegation features that will replace this mixin.
+ *
+ * @param base The class to mix functionality into.
+ * @return The provided class with aria delegation mixed in.
+ */
+export declare function mixinDelegatesAria<T extends MixinBase<LitElement>>(base: T): MixinReturn<T>;

package/dist/src/__internal/events/dispatch-hooks.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Add a hook for an event that is called after the event is dispatched and
+ * propagates to other event listeners.
+ *
+ * This is useful for behaviors that need to check if an event is canceled.
+ *
+ * The callback is invoked synchronously, which allows for better integration
+ * with synchronous platform APIs (like `<form>` or `<label>` clicking).
+ *
+ * Note: `setupDispatchHooks()` must be called on the element before adding any
+ * other event listeners. Call it in the constructor of an element or
+ * controller.
+ *
+ * @example
+ * ```ts
+ * class MyControl extends LitElement {
+ *   constructor() {
+ *     super();
+ *     setupDispatchHooks(this, 'click');
+ *     this.addEventListener('click', event => {
+ *       afterDispatch(event, () => {
+ *         if (event.defaultPrevented) {
+ *           return
+ *         }
+ *
+ *         // ... perform logic
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * class MyController implements ReactiveController {
+ *   constructor(host: ReactiveElement) {
+ *     // setupDispatchHooks() may be called multiple times for the same
+ *     // element and events, making it safe for multiple controllers to use it.
+ *     setupDispatchHooks(host, 'click');
+ *     host.addEventListener('click', event => {
+ *       afterDispatch(event, () => {
+ *         if (event.defaultPrevented) {
+ *           return;
+ *         }
+ *
+ *         // ... perform logic
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @param event The event to add a hook to.
+ * @param callback A hook that is called after the event finishes dispatching.
+ */
+export declare function afterDispatch(event: Event, callback: () => void): void;
+/**
+ * Sets up an element to add dispatch hooks to given event types. This must be
+ * called before adding any event listeners that need to use dispatch hooks
+ * like `afterDispatch()`.
+ *
+ * This function is safe to call multiple times with the same element or event
+ * types. Call it in the constructor of elements, mixins, and controllers to
+ * ensure it is set up before external listeners.
+ *
+ * @example
+ * ```ts
+ * class MyControl extends LitElement {
+ *   constructor() {
+ *     super();
+ *     setupDispatchHooks(this, 'click');
+ *     this.addEventListener('click', this.listenerUsingAfterDispatch);
+ *   }
+ * }
+ * ```
+ *
+ * @param element The element to set up event dispatch hooks for.
+ * @param eventTypes The event types to add dispatch hooks to.
+ */
+export declare function setupDispatchHooks(element: Element, ...eventTypes: [string, ...string[]]): void;

package/dist/src/__internal/mixins/element-internals.d.ts

@@ -0,0 +1,40 @@
+import { LitElement } from 'lit';
+import { MixinBase, MixinReturn } from './mixin.js';
+/**
+ * A unique symbol used for protected access to an instance's
+ * `ElementInternals`.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends mixinElementInternals(LitElement) {
+ *   constructor() {
+ *     super();
+ *     this[internals].role = 'button';
+ *   }
+ * }
+ * ```
+ */
+export declare const internals: unique symbol;
+/**
+ * An instance with an `internals` symbol property for the component's
+ * `ElementInternals`.
+ *
+ * Use this when protected access is needed for an instance's `ElementInternals`
+ * from other files. A unique symbol is used to access the internals.
+ */
+export interface WithElementInternals {
+    /**
+     * An instance's `ElementInternals`.
+     */
+    [internals]: ElementInternals;
+}
+/**
+ * Mixes in an attached `ElementInternals` instance.
+ *
+ * This mixin is only needed when other shared code needs access to a
+ * component's `ElementInternals`, such as form-associated mixins.
+ *
+ * @param base The class to mix functionality into.
+ * @return The provided class with `WithElementInternals` mixed in.
+ */
+export declare function mixinElementInternals<T extends MixinBase<LitElement>>(base: T): MixinReturn<T, WithElementInternals>;

package/dist/src/__internal/mixins/form-associated.d.ts

@@ -0,0 +1,174 @@
+import { LitElement } from 'lit';
+import { WithElementInternals } from './element-internals.js';
+import { MixinBase, MixinReturn } from './mixin.js';
+/**
+ * A form-associated element.
+ */
+export interface FormAssociated {
+    /**
+     * The associated form element with which this element's value will submit.
+     */
+    readonly form: HTMLFormElement | null;
+    /**
+     * The labels this element is associated with.
+     */
+    readonly labels: NodeList;
+    /**
+     * The HTML name to use in form submission.
+     */
+    name: string;
+    /**
+     * Whether or not the element is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Gets the current form value of a component. Defaults to the component's
+     * `value` attribute.
+     *
+     * @return The current form value.
+     */
+    [getFormValue](): FormValue | null;
+    /**
+     * Gets the current form state of a component. Defaults to the component's
+     * `[getFormValue]()` result.
+     *
+     * Use this when the state of an element is different from its value, such as
+     * checkboxes (internal boolean state and a user string value).
+     *
+     * @return The current form state, defaults to the form value.
+     */
+    [getFormState](): FormValue | null;
+    /**
+     * A callback for when a form component should be disabled or enabled. This
+     * can be called in a variety of situations, such as disabled `<fieldset>`s.
+     *
+     * @param disabled Whether or not the form control should be disabled.
+     */
+    formDisabledCallback(disabled: boolean): void;
+    /**
+     * An optional callback for when the form requests to reset its value.
+     * Typically, the default value that is reset is represented in the attribute
+     * of an element.
+     *
+     * This means the attribute used for the value should not update as the value
+     * changes. For example, a checkbox should not change its default `checked`
+     * attribute when selected. Ensure form values do not reflect.
+     */
+    formResetCallback?(): void;
+    /**
+     * An optional callback for when the form restores the state of a component.
+     * For example, when a page is reloaded or forms are autofilled.
+     *
+     * @param state The state to restore, or null to reset the form control's
+     *     value.
+     * @param reason The reason state was restored, either `'restore'` or
+     *   `'autocomplete'`.
+     */
+    formStateRestoreCallback?(state: FormRestoreState | null, reason: FormRestoreReason): void;
+    /**
+     * An optional callback for when the associated form changes.
+     *
+     * @param form The new associated form, or `null` if there is none.
+     */
+    formAssociatedCallback?(form: HTMLFormElement | null): void;
+}
+/**
+ * The constructor of a `FormAssociated` element.
+ */
+export interface FormAssociatedConstructor {
+    /**
+     * Indicates that an element is participating in form association.
+     */
+    readonly formAssociated: true;
+}
+/**
+ * A symbol property to retrieve the form value for an element.
+ */
+export declare const getFormValue: unique symbol;
+/**
+ * A symbol property to retrieve the form state for an element.
+ */
+export declare const getFormState: unique symbol;
+/**
+ * Mixes in form-associated behavior for a class. This allows an element to add
+ * values to `<form>` elements.
+ *
+ * Implementing classes should provide a `[formValue]` to return the current
+ * value of the element, as well as reset and restore callbacks.
+ *
+ * @example
+ * ```ts
+ * const base = mixinFormAssociated(mixinElementInternals(LitElement));
+ *
+ * class MyControl extends base {
+ *   \@property()
+ *   value = '';
+ *
+ *   override [getFormValue]() {
+ *     return this.value;
+ *   }
+ *
+ *   override formResetCallback() {
+ *     const defaultValue = this.getAttribute('value');
+ *     this.value = defaultValue;
+ *   }
+ *
+ *   override formStateRestoreCallback(state: string) {
+ *     this.value = state;
+ *   }
+ * }
+ * ```
+ *
+ * Elements may optionally provide a `[formState]` if their values do not
+ * represent the state of the component.
+ *
+ * @example
+ * ```ts
+ * const base = mixinFormAssociated(mixinElementInternals(LitElement));
+ *
+ * class MyCheckbox extends base {
+ *   \@property()
+ *   value = 'on';
+ *
+ *   \@property({type: Boolean})
+ *   checked = false;
+ *
+ *   override [getFormValue]() {
+ *     return this.checked ? this.value : null;
+ *   }
+ *
+ *   override [getFormState]() {
+ *     return String(this.checked);
+ *   }
+ *
+ *   override formResetCallback() {
+ *     const defaultValue = this.hasAttribute('checked');
+ *     this.checked = defaultValue;
+ *   }
+ *
+ *   override formStateRestoreCallback(state: string) {
+ *     this.checked = Boolean(state);
+ *   }
+ * }
+ * ```
+ *
+ * @param base The class to mix functionality into. The base class must use
+ *     `mixinElementInternals()`.
+ * @return The provided class with `FormAssociated` mixed in.
+ */
+export declare function mixinFormAssociated<T extends MixinBase<LitElement & WithElementInternals>>(base: T): MixinReturn<T & FormAssociatedConstructor, FormAssociated>;
+/**
+ * A value that can be provided for form submission and state.
+ */
+export type FormValue = File | string | FormData;
+/**
+ * A value to be restored for a component's form value. If a component's form
+ * state is a `FormData` object, its entry list of name and values will be
+ * provided.
+ */
+export type FormRestoreState = File | string | Array<[string, FormDataEntryValue]>;
+/**
+ * The reason a form component is being restored for, either `'restore'` for
+ * browser restoration or `'autocomplete'` for restoring user values.
+ */
+export type FormRestoreReason = 'restore' | 'autocomplete';

package/dist/src/__internal/mixins/form-submitter.d.ts

@@ -0,0 +1,59 @@
+import { LitElement } from 'lit';
+import { WithElementInternals } from './element-internals.js';
+import { MixinBase, MixinReturn } from './mixin.js';
+/**
+ * A string indicating the form submission behavior of the element.
+ *
+ * - submit: The element submits the form. This is the default value if the
+ * attribute is not specified, or if it is dynamically changed to an empty or
+ * invalid value.
+ * - reset: The element resets the form.
+ * - button: The element does nothing.
+ */
+export type FormSubmitterType = 'button' | 'submit' | 'reset';
+/**
+ * An element that can submit or reset a `<form>`, similar to
+ * `<button type="submit">`.
+ */
+export interface FormSubmitter {
+    /**
+     * A string indicating the form submission behavior of the element.
+     *
+     * - submit: The element submits the form. This is the default value if the
+     * attribute is not specified, or if it is dynamically changed to an empty or
+     * invalid value.
+     * - reset: The element resets the form.
+     * - button: The element does nothing.
+     */
+    type: string;
+    /**
+     * The HTML name to use in form submission. When combined with a `value`, the
+     * submitting button's name/value will be added to the form.
+     *
+     * Names must reflect to a `name` attribute for form integration.
+     */
+    name: string;
+    /**
+     * The value of the button. When combined with a `name`, the submitting
+     * button's name/value will be added to the form.
+     */
+    value: string;
+}
+/**
+ * Mixes in form submitter behavior for a class.
+ *
+ * A click listener is added to each element instance. If the click is not
+ * default prevented, it will submit the element's form, if any.
+ *
+ * @example
+ * ```ts
+ * const base = mixinFormSubmitter(mixinElementInternals(LitElement));
+ * class MyButton extends base {
+ *   static formAssociated = true;
+ * }
+ * ```
+ *
+ * @param base The class to mix functionality into.
+ * @return The provided class with `FormSubmitter` mixed in.
+ */
+export declare function mixinFormSubmitter<T extends MixinBase<LitElement & WithElementInternals>>(base: T): MixinReturn<T, FormSubmitter>;

package/dist/src/__internal/mixins/hyperlink.d.ts

@@ -0,0 +1,42 @@
+import { LitElement } from 'lit';
+import { MixinBase, MixinReturn } from './mixin.js';
+/**
+ * An element that navigates to a URL when activated, similar to `<a href>`.
+ */
+export interface Hyperlink {
+    /**
+     * The URL the hyperlink points to. When set, the component renders as an
+     * `<a>` element. Maps to the native `href` attribute.
+     */
+    href?: string;
+    /**
+     * Where to display the linked URL. Maps to the native `target` attribute.
+     * Possible values: `"_self"`, `"_blank"`, `"_parent"`, `"_top"`, or a
+     * frame name. When using `"_blank"`, set `rel="noopener noreferrer"`.
+     */
+    target: '_self' | '_parent' | '_blank' | '_top' | string;
+    /**
+     * The relationship between the current document and the linked URL.
+     * Maps to the native `rel` attribute. Use `"noopener noreferrer"` when
+     * `target="_blank"` to prevent tab-napping attacks.
+     */
+    rel: string;
+    /**
+     * Causes the browser to download the linked URL instead of navigating.
+     * A string value is used as the suggested filename. Only applies when
+     * `href` is set. Maps to the native `download` attribute.
+     */
+    download: string;
+}
+/**
+ * Mixes in hyperlink behavior for a class.
+ *
+ * @example
+ * ```ts
+ * class MyLink extends mixinHyperlink(LitElement) {}
+ * ```
+ *
+ * @param base The class to mix functionality into.
+ * @return The provided class with `Hyperlink` mixed in.
+ */
+export declare function mixinHyperlink<T extends MixinBase<LitElement>>(base: T): MixinReturn<T, Hyperlink>;

package/dist/src/__internal/mixins/mixin.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The base class for a mixin with an optional expected base class type.
+ *
+ * @template ExpectedBase Optional expected base class type, such as
+ *     `LitElement`.
+ *
+ * @example
+ * ```ts
+ * interface Foo {
+ *   isFoo: boolean;
+ * }
+ *
+ * function mixinFoo<T extends MixinBase>(base: T): MixinReturn<T, Foo> {
+ *   // Mixins must be `abstract`
+ *   abstract class FooImpl extends base implements Foo {
+ *     isFoo = true;
+ *   }
+ *
+ *   return FooImpl;
+ * }
+ * ```
+ */
+export type MixinBase<ExpectedBase = object> = abstract new (...args: any[]) => ExpectedBase;
+/**
+ * The return value of a mixin.
+ *
+ * @template MixinBase The generic that extends `MixinBase` used for the mixin's
+ *     base class argument.
+ * @template MixinClass Optional interface of fuctionality that was mixed in.
+ *     Omit if no additional APIs were added (such as purely overriding base
+ *     class functionality).
+ *
+ * @example
+ * ```ts
+ * interface Foo {
+ *   isFoo: boolean;
+ * }
+ *
+ * // Mixins must be `abstract`
+ * function mixinFoo<T extends MixinBase>(base: T): MixinReturn<T, Foo> {
+ *   abstract class FooImpl extends base implements Foo {
+ *     isFoo = true;
+ *   }
+ *
+ *   return FooImpl;
+ * }
+ * ```
+ */
+export type MixinReturn<MixinBase, MixinClass = object> = (abstract new (...args: any[]) => MixinClass) & MixinBase;

package/dist/src/{__utils → __internal/utils}/observe-slot-change.d.ts

@@ -1 +1,2 @@
+export declare function hasMeaningfulContent(slotElement: HTMLSlotElement | null): boolean;
 export declare function observerSlotChangesWithCallback(slot: HTMLSlotElement | null, callback: (hasContent: boolean) => void): () => void;

package/dist/src/accordion/accordion-item.d.ts

@@ -3,7 +3,7 @@ import { LitElement } from 'lit';
  * @label Accordion Item
  * @tag wc-accordion-item
  * @rawTag accordion-item
- * @summary An expansion panel with a header that reveals or hides associated content. Follows Material Design 3 expansion panel guidelines.
+ * @summary An expansion panel with a header that reveals or hides associated content.
  *
  * @slot - The body content revealed when the panel is expanded.
  * @slot heading - The panel title. Renders as `body-large` text.
@@ -48,7 +48,9 @@ export declare class AccordionItem extends LitElement {
      * `'before'` places it at the leading start.
      */
     togglePosition: 'before' | 'after';
+    /** True when the `description` slot contains at least one non-empty node. */
     private _hasDescriptionSlot;
+    /** True when the `heading` slot contains at least one non-empty node. */
     private _hasHeadingSlot;
     private readonly buttonElement;
     focus(): void;

package/dist/src/accordion/accordion.d.ts

@@ -4,7 +4,7 @@ import { AccordionItem } from './accordion-item.js';
  * @label Accordion
  * @tag wc-accordion
  * @rawTag accordion
- * @summary A vertically stacked set of expansion panels. Follows Material Design 3 expansion panel guidelines.
+ * @summary A vertically stacked set of expansion panels.
  *
  * @example
  * ```html

package/dist/src/alert/alert.d.ts

@@ -0,0 +1,43 @@
+import { LitElement } from 'lit';
+type AlertVariant = 'note' | 'info' | 'success' | 'warning' | 'error';
+/**
+ * @label Alert
+ * @tag wc-alert
+ * @rawTag alert
+ * @summary Alerts show short, prominent contextual messages with optional icon and description.
+ *
+ * @cssprop --alert-container-color - Background color of the alert container.
+ * @cssprop --alert-label-text-color - Label text color.
+ * @cssprop --alert-description-text-color - Description text color.
+ * @cssprop --alert-icon-color - Icon color.
+ * @cssprop --alert-border-radius - Border radius of the alert surface.
+ *
+ * @example
+ * ```html
+ * <wc-alert variant="note" description="Use semantic roles that preserve a 3:1 contrast ratio."></wc-alert>
+ * ```
+ * @tags display, feedback
+ */
+export declare class Alert extends LitElement {
+    static styles: import("lit").CSSResultGroup[];
+    /**
+     * Visual intent of the alert.
+     */
+    variant: AlertVariant;
+    /**
+     * Optional explicit label text. Falls back to a variant-based label.
+     */
+    label?: string;
+    /**
+     * Optional explicit icon name. Falls back to a variant-based icon.
+     */
+    icon?: string;
+    /**
+     * Optional description text when a default slot is not provided.
+     */
+    description: string;
+    private get resolvedLabel();
+    private get resolvedIcon();
+    render(): import("lit-html").TemplateResult<1>;
+}
+export {};

package/dist/src/alert/index.d.ts

@@ -0,0 +1 @@
+export { Alert } from './alert.js';