@esri/calcite-components 1.0.0-beta.72 → 1.0.0-beta.76

package/dist/types/components/calcite-link/calcite-link.d.ts

@@ -0,0 +1,38 @@
+import { VNode } from "../../stencil-public-runtime";
+import { FlipContext } from "../interfaces";
+/** Any attributes placed on <calcite-link> component will propagate to the rendered child */
+/** Passing a 'href' will render an anchor link, instead of a span. Role will be set to link, or link, depending on this. */
+/** It is the consumers responsibility to add aria information, rel, target, for links, and any link attributes for form submission */
+/** @slot - A slot for adding text. */
+export declare class CalciteLink {
+  el: HTMLCalciteLinkElement;
+  /** is the link disabled  */
+  disabled: boolean;
+  /** Prompts the user to save the linked URL instead of navigating to it. Can be used with or without a value:
+   * Without a value, the browser will suggest a filename/extension
+   * See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#attr-download
+   */
+  download: string | boolean;
+  /** optionally pass a href - used to determine if the component should render as a link or an anchor */
+  href?: string;
+  hrefHandler(href: string): void;
+  /** optionally pass an icon to display at the end of a button - accepts calcite ui icon names  */
+  iconEnd?: string;
+  /** flip the icon(s) in rtl */
+  iconFlipRtl?: FlipContext;
+  /** optionally pass an icon to display at the start of a button - accepts calcite ui icon names  */
+  iconStart?: string;
+  /** The rel attribute to apply to the hyperlink */
+  rel?: string;
+  /** The target attribute to apply to the hyperlink */
+  target?: string;
+  connectedCallback(): void;
+  render(): VNode;
+  /** Sets focus on the component. */
+  setFocus(): Promise<void>;
+  /** the rendered child element */
+  private childEl;
+  /** the node type of the rendered child element */
+  childElType: "a" | "span";
+  private storeTagRef;
+}

package/dist/types/components/calcite-list/calcite-list.d.ts

@@ -0,0 +1,16 @@
+import { VNode } from "../../stencil-public-runtime";
+import { HeadingLevel } from "../functional/CalciteHeading";
+/**
+ * A general purpose list that enables users to construct list items that conform to Calcite styling.
+ * @slot - A slot for adding `calcite-list-item` elements.
+ */
+export declare class CalciteList {
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  el: HTMLCalciteListElement;
+  /** Sets focus on the component. */
+  setFocus(): Promise<void>;
+  render(): VNode;
+}

package/dist/types/components/calcite-list-item/calcite-list-item.d.ts

@@ -0,0 +1,40 @@
+import { VNode } from "../../stencil-public-runtime";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/**
+ * @slot - A slot for adding `calcite-list-item` and `calcite-list-item-group` elements.
+ * @slot actions-start - A slot for adding actionable `calcite-action` elements before the content of the list item.
+ * @slot content-start - A slot for adding non-actionable elements before the label and description of the list item.
+ * @slot content-end - A slot for adding non-actionable elements after the label and description of the list item.
+ * @slot actions-end - A slot for adding actionable `calcite-action` elements after the content of the list item.
+ */
+export declare class CalciteListItem implements ConditionalSlotComponent {
+  /**
+   * When true, prevents the content of the list item from user interaction.
+   */
+  nonInteractive: boolean;
+  /**
+   * An optional description for this item.  This will appear below the label text.
+   */
+  description: string;
+  /**
+   * When true, disabled prevents interaction.
+   */
+  disabled: boolean;
+  /**
+   * The label text of the list item. This will appear above the description text.
+   */
+  label: string;
+  el: HTMLCalciteListItemElement;
+  focusEl: HTMLButtonElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  /** Sets focus on the component. */
+  setFocus(): Promise<void>;
+  renderActionsStart(): VNode;
+  renderActionsEnd(): VNode;
+  renderContentStart(): VNode;
+  renderContentEnd(): VNode;
+  renderContent(): VNode;
+  renderContentContainer(): VNode;
+  render(): VNode;
+}

package/dist/types/components/calcite-list-item-group/calcite-list-item-group.d.ts

@@ -0,0 +1,18 @@
+import { VNode } from "../../stencil-public-runtime";
+import { HeadingLevel } from "../functional/CalciteHeading";
+/**
+ * @slot - A slot for adding `calcite-list-item` and `calcite-list-item-group` elements.
+ */
+export declare class CalciteListItemGroup {
+  /**
+   * The title used for all nested `calcite-list-item` rows.
+   *
+   */
+  heading: string;
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  el: HTMLCalciteListItemGroupElement;
+  render(): VNode;
+}

package/dist/types/components/calcite-loader/calcite-loader.d.ts

@@ -0,0 +1,27 @@
+import { VNode } from "../../stencil-public-runtime";
+import { Scale } from "../interfaces";
+export declare class CalciteLoader {
+  el: HTMLCalciteLoaderElement;
+  /** Show the loader */
+  active: boolean;
+  /** Inline loaders are smaller and will appear to the left of the text */
+  inline: boolean;
+  /** Accessible name for the component */
+  label: string;
+  /** Speficy the scale of the loader. Defaults to "m" */
+  scale: Scale;
+  /** Use indeterminate if finding actual progress value is impossible */
+  type: "indeterminate" | "determinate";
+  /** Percent complete of 100, only valid for determinate indicators */
+  value: number;
+  /** Text which should appear under the loading indicator (optional) */
+  text: string;
+  /** Turn off spacing around the loader */
+  noPadding: boolean;
+  render(): VNode;
+  /**
+   * Return the proper sizes based on the scale property
+   */
+  private getSize;
+  private getInlineSize;
+}

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

@@ -0,0 +1,89 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { Scale } from "../interfaces";
+import { ModalBackgroundColor } from "./interfaces";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/**
+ * @slot header - a slot for adding a modal header
+ * @slot content - a slot for adding modal content
+ * @slot primary - a slot for adding a primary button
+ * @slot secondary - a slot for adding a secondary button
+ * @slot back - a slot for adding a back button
+ */
+export declare class CalciteModal implements ConditionalSlotComponent {
+  el: HTMLCalciteModalElement;
+  /** Add the active attribute to open the modal */
+  active: boolean;
+  /** Optionally pass a function to run before close */
+  beforeClose: (el: HTMLElement) => Promise<void>;
+  /** Disables the display a close button within the Modal */
+  disableCloseButton: boolean;
+  /** Disables the closing of the Modal when clicked outside. */
+  disableOutsideClose: boolean;
+  /** Aria label for the close button */
+  intlClose: string;
+  /** Prevent the modal from taking up the entire screen on mobile */
+  docked: boolean;
+  /** Specify an element to focus when the modal is first opened */
+  firstFocus?: HTMLElement;
+  /** Flag to disable the default close on escape behavior */
+  disableEscape: boolean;
+  /** specify the scale of modal, defaults to m */
+  scale: Scale;
+  /** Set the width of the modal. Can use stock sizes or pass a number (in pixels) */
+  width: Scale | number;
+  /** Set the modal to always be fullscreen (overrides width) */
+  fullscreen: boolean;
+  /** Adds a color bar at the top for visual impact,
+   * Use color to add importance to destructive/workflow dialogs. */
+  color?: "red" | "blue";
+  /** Background color of modal content */
+  backgroundColor: ModalBackgroundColor;
+  /** Turn off spacing around the content area slot */
+  noPadding: boolean;
+  componentWillLoad(): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  render(): VNode;
+  renderFooter(): VNode;
+  renderCloseButton(): VNode;
+  renderStyle(): VNode;
+  hasFooter: boolean;
+  closeButtonEl: HTMLButtonElement;
+  contentId: string;
+  modalContent: HTMLDivElement;
+  private mutationObserver;
+  previousActiveElement: HTMLElement;
+  titleId: string;
+  private activeTransitionProp;
+  handleEscape(e: KeyboardEvent): void;
+  /** Fired when the modal finishes the open animation */
+  calciteModalOpen: EventEmitter;
+  /** Fired when the modal finishes the close animation */
+  calciteModalClose: EventEmitter;
+  /**
+   * Focus first interactive element
+   * @deprecated use `setFocus` instead.
+   */
+  focusElement(el?: HTMLElement): Promise<void>;
+  /**
+   * Sets focus on the component.
+   *
+   * By default, will try to focus on any focusable content. If there is none, it will focus on the close button.
+   * If you want to focus on the close button, you can use the `close-button` focus ID.
+   */
+  setFocus(focusId?: "close-button"): Promise<void>;
+  /** Set the scroll top of the modal content */
+  scrollContent(top?: number, left?: number): Promise<void>;
+  transitionEnd: (event: TransitionEvent) => void;
+  toggleModal(value: boolean, oldValue: boolean): Promise<void>;
+  private openEnd;
+  /** Open the modal */
+  private open;
+  handleOutsideClose: () => void;
+  /** Close the modal, first running the `beforeClose` method */
+  close: () => Promise<void>;
+  focusFirstElement: () => void;
+  focusLastElement: () => void;
+  private removeOverflowHiddenClass;
+  private updateFooterVisibility;
+}

package/dist/types/components/calcite-notice/calcite-notice.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { Scale, Width } from "../interfaces";
+import { StatusColor } from "../calcite-alert/interfaces";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/** Notices are intended to be used to present users with important-but-not-crucial contextual tips or copy. Because
+ * notices are displayed inline, a common use case is displaying them on page-load to present users with short hints or contextual copy.
+ * They are optionally dismissible - useful for keeping track of whether or not a user has dismissed the notice. You can also choose not
+ * to display a notice on page load and set the "active" attribute as needed to contextually provide inline messaging to users.
+ */
+/**
+ * @slot title - Title of the notice (optional)
+ * @slot message - Main text of the notice
+ * @slot link - Optional action to take from the notice (undo, try again, link to page, etc.)
+ * @slot actions-end - Allows adding a `calcite-action` at the end of the notice. It is recommended to use 2 or less actions.
+ */
+export declare class CalciteNotice implements ConditionalSlotComponent {
+  el: HTMLCalciteNoticeElement;
+  /** Is the notice currently active or not */
+  active: boolean;
+  /** Color for the notice (will apply to top border and icon) */
+  color: StatusColor;
+  /** Optionally show a button the user can click to dismiss the notice */
+  dismissible: boolean;
+  /** when used as a boolean set to true, show a default recommended icon. You can
+   * also pass a calcite-ui-icon name to this prop to display a requested icon */
+  icon: string | boolean;
+  /** String for the close button.
+   * @default "Close"
+   */
+  intlClose: string;
+  /** specify the scale of the notice, defaults to m */
+  scale: Scale;
+  /** specify the width of the notice, defaults to auto */
+  width: Width;
+  updateRequestedIcon(): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  componentWillLoad(): void;
+  render(): VNode;
+  /** Fired when an notice is closed */
+  calciteNoticeClose: EventEmitter;
+  /** Fired when an Notice is opened */
+  calciteNoticeOpen: EventEmitter;
+  /** Sets focus on the component. */
+  setFocus(): Promise<void>;
+  private close;
+  /** the close button element */
+  private closeButton?;
+  /** the computed icon to render */
+  private requestedIcon?;
+}

package/dist/types/components/calcite-pagination/calcite-pagination.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { Scale } from "../interfaces";
+export interface CalcitePaginationDetail {
+  start: number;
+  total: number;
+  num: number;
+}
+export declare class CalcitePagination {
+  /** number of items per page */
+  num: number;
+  /** index of item that should begin the page */
+  start: number;
+  /** total number of items */
+  total: number;
+  /** Used as an accessible label (aria-label) for the next button
+   * @default "Next"
+   */
+  textLabelNext: string;
+  /** Used as an accessible label (aria-label) of the previous button
+   * @default "Previous"
+   */
+  textLabelPrevious: string;
+  /** The scale of the pagination */
+  scale: Scale;
+  el: HTMLCalcitePaginationElement;
+  /**
+   * Emitted whenever the selected page changes.
+   * @deprecated use calcitePaginationChange instead
+   */
+  calcitePaginationUpdate: EventEmitter<CalcitePaginationDetail>;
+  /**
+   * Emitted whenever the selected page changes.
+   * @see [CalcitePaginationDetail](https://github.com/Esri/calcite-components/blob/master/src/components/calcite-pagination/calcite-pagination.tsx#L18)
+   */
+  calcitePaginationChange: EventEmitter<CalcitePaginationDetail>;
+  /** Go to the next page of results */
+  nextPage(): Promise<void>;
+  /** Go to the previous page of results */
+  previousPage(): Promise<void>;
+  private getLastStart;
+  private previousClicked;
+  private nextClicked;
+  private showLeftEllipsis;
+  private showRightEllipsis;
+  private emitUpdate;
+  renderPages(): VNode[];
+  renderPage(start: number): VNode;
+  renderLeftEllipsis(): VNode;
+  renderRightEllipsis(): VNode;
+  render(): VNode;
+}

package/dist/types/components/calcite-panel/calcite-panel.d.ts

@@ -0,0 +1,130 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { Scale } from "../interfaces";
+import { HeadingLevel } from "../functional/CalciteHeading";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/**
+ * @slot - A slot for adding custom content.
+ * @slot header-actions-start - A slot for adding actions or content to the start side of the panel header.
+ * @slot header-actions-end - A slot for adding actions or content to the end side of the panel header.
+ * @slot header-content - A slot for adding custom content to the header.
+ * @slot header-menu-actions - A slot for adding an overflow menu with actions inside a dropdown.
+ * @slot fab - A slot for adding a `calcite-fab` (floating action button) to perform an action.
+ * @slot footer-actions - A slot for adding buttons to the footer.
+ * @slot footer - A slot for adding custom content to the footer.
+ */
+export declare class CalcitePanel implements ConditionalSlotComponent {
+  /**
+   * Hides the panel.
+   */
+  dismissed: boolean;
+  dismissedHandler(): void;
+  /**
+   * When provided, this method will be called before it is removed from the parent flow.
+   */
+  beforeBack?: () => Promise<void>;
+  /**
+   * When true, disabled prevents interaction. This state shows items with lower opacity/grayed.
+   */
+  disabled: boolean;
+  /**
+   * Displays a close button in the trailing side of the header.
+   */
+  dismissible: boolean;
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  /**
+   * Shows a back button in the header.
+   */
+  showBackButton: boolean;
+  /**
+   * 'Back' text string.
+   */
+  intlBack?: string;
+  /**
+   * Specifies the maxiumum height of the panel.
+   */
+  heightScale: Scale;
+  /**
+   * This sets width of the panel.
+   */
+  widthScale?: Scale;
+  /**
+   * When true, content is waiting to be loaded. This state shows a busy indicator.
+   */
+  loading: boolean;
+  /**
+   * 'Close' text string for the close button. The close button will only be shown when 'dismissible' is true.
+   */
+  intlClose?: string;
+  /**
+   * 'Options' text string for the actions menu.
+   */
+  intlOptions?: string;
+  /**
+   * Heading text.
+   */
+  heading?: string;
+  /**
+   * Summary text. A description displayed underneath the heading.
+   */
+  summary?: string;
+  /**
+   * Opens the action menu.
+   */
+  menuOpen: boolean;
+  el: HTMLCalcitePanelElement;
+  backButtonEl: HTMLCalciteActionElement;
+  dismissButtonEl: HTMLCalciteActionElement;
+  containerEl: HTMLElement;
+  panelScrollEl: HTMLElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  /**
+   * Emitted when the close button has been clicked.
+   */
+  calcitePanelDismissedChange: EventEmitter;
+  /**
+   * Emitted when the content has been scrolled.
+   */
+  calcitePanelScroll: EventEmitter;
+  /**
+   * Emitted when the back button has been clicked.
+   */
+  calcitePanelBackClick: EventEmitter;
+  setContainerRef: (node: HTMLElement) => void;
+  setDismissRef: (node: HTMLCalciteActionElement) => void;
+  setBackRef: (node: HTMLCalciteActionElement) => void;
+  panelKeyDownHandler: (event: KeyboardEvent) => void;
+  dismiss: () => void;
+  panelScrollHandler: () => void;
+  backButtonClick: () => void;
+  /** Sets focus on the component. */
+  setFocus(focusId?: "dismiss-button" | "back-button"): Promise<void>;
+  /** Scrolls panel content to a particular set of coordinates.
+   *
+   * ```
+   *   myCalcitePanel.scrollContentTo({
+   *     left: 0, // Specifies the number of pixels along the X axis to scroll the window or element.
+   *     top: 0, // Specifies the number of pixels along the Y axis to scroll the window or element
+   *     behavior: "auto" // Specifies whether the scrolling should animate smoothly (smooth), or happen instantly in a single jump (auto, the default value).
+   *   });
+   * ```
+   */
+  scrollContentTo(options?: ScrollToOptions): Promise<void>;
+  renderBackButton(): VNode;
+  renderHeaderContent(): VNode;
+  /**
+   * Allows user to override the entire header-content node.
+   */
+  renderHeaderSlottedContent(): VNode;
+  renderHeaderStartActions(): VNode;
+  renderHeaderActionsEnd(): VNode;
+  renderMenu(): VNode;
+  renderHeaderNode(): VNode;
+  renderFooterNode(): VNode;
+  renderContent(): VNode;
+  renderFab(): VNode;
+  render(): VNode;
+}

package/dist/types/components/calcite-pick-list/calcite-pick-list.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { ICON_TYPES } from "./resources";
+import { ListFocusId, ItemData } from "./shared-list-logic";
+import { HeadingLevel } from "../functional/CalciteHeading";
+/**
+ * @slot - A slot for adding `calcite-pick-list-item` elements or `calcite-pick-list-group` elements. Items are displayed as a vertical list.
+ * @slot menu-actions - A slot for adding a button + menu combo for performing actions like sorting.
+ */
+export declare class CalcitePickList<ItemElement extends HTMLCalcitePickListItemElement = HTMLCalcitePickListItemElement> {
+  /**
+   * When true, disabled prevents interaction. This state shows items with lower opacity/grayed.
+   */
+  disabled: boolean;
+  /**
+   * When true, an input appears at the top of the list that can be used by end users to filter items in the list.
+   */
+  filterEnabled: boolean;
+  /**
+   * Placeholder text for the filter input field.
+   */
+  filterPlaceholder: string;
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  /**
+   * When true, content is waiting to be loaded. This state shows a busy indicator.
+   */
+  loading: boolean;
+  /**
+   * Multiple works similar to standard radio buttons and checkboxes.
+   * When true, a user can select multiple items at a time.
+   * When false, only a single item can be selected at a time
+   * and selecting a new item will deselect any other selected items.
+   */
+  multiple: boolean;
+  /**
+   * When true and single-selection is enabled, the selection will change when navigating items via the keyboard.
+   */
+  selectionFollowsFocus: boolean;
+  selectedValues: Map<string, ItemElement>;
+  dataForFilter: ItemData;
+  items: ItemElement[];
+  lastSelectedItem: ItemElement;
+  mutationObserver: MutationObserver;
+  el: HTMLCalcitePickListElement;
+  emitCalciteListChange: () => void;
+  filterEl: HTMLCalciteFilterElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  /**
+   * Emitted when any of the item selections have changed.
+   */
+  calciteListChange: EventEmitter<Map<string, HTMLCalcitePickListItemElement>>;
+  calciteListItemRemoveHandler(event: CustomEvent<void>): void;
+  calciteListItemChangeHandler(event: CustomEvent): void;
+  calciteListItemPropsChangeHandler(event: CustomEvent): void;
+  calciteListItemValueChangeHandler(event: CustomEvent): void;
+  calciteListFocusOutHandler(event: FocusEvent): void;
+  setUpItems(): void;
+  setUpFilter(): void;
+  setFilterEl: (el: HTMLCalciteFilterElement) => void;
+  deselectRemovedItems: any;
+  deselectSiblingItems: any;
+  selectSiblings: any;
+  handleFilter: any;
+  getItemData: any;
+  keyDownHandler: any;
+  /** Returns the currently selected items */
+  getSelectedItems(): Promise<Map<string, HTMLCalcitePickListItemElement>>;
+  /** Sets focus on the component. */
+  setFocus(focusId?: ListFocusId): Promise<void>;
+  getIconType(): ICON_TYPES;
+  render(): VNode;
+}

package/dist/types/components/calcite-pick-list/shared-list-logic.d.ts

@@ -0,0 +1,31 @@
+import { CalcitePickList } from "./calcite-pick-list";
+import { CalciteValueList } from "../calcite-value-list/calcite-value-list";
+declare type Lists = CalcitePickList | CalciteValueList;
+declare type ListItemElement<T> = T extends CalcitePickList ? HTMLCalcitePickListItemElement : HTMLCalciteValueListItemElement;
+declare type List<T> = T extends CalcitePickList ? CalcitePickList : CalciteValueList;
+export declare type ListFocusId = "filter";
+export declare function mutationObserverCallback<T extends Lists>(this: List<T>): void;
+export declare function initialize<T extends Lists>(this: List<T>): void;
+export declare function initializeObserver<T extends Lists>(this: List<T>): void;
+export declare function cleanUpObserver<T extends Lists>(this: List<T>): void;
+export declare function calciteListItemChangeHandler<T extends Lists>(this: List<T>, event: CustomEvent): void;
+export declare function calciteListItemValueChangeHandler<T extends Lists>(this: List<T>, event: CustomEvent): void;
+export declare function calciteListFocusOutHandler<T extends Lists>(this: List<T>, event: FocusEvent): void;
+export declare function keyDownHandler<T extends Lists>(this: List<T>, event: KeyboardEvent): void;
+export declare function internalCalciteListChangeEvent<T extends Lists>(this: List<T>): void;
+export declare function removeItem<T extends Lists, U extends ListItemElement<T>>(this: List<T>, event: CustomEvent): void;
+export declare function setFocus<T extends Lists>(this: List<T>, focusId: ListFocusId): Promise<void>;
+export declare function setUpItems<T extends Lists>(this: List<T>, tagName: T extends CalcitePickList ? "calcite-pick-list-item" : "calcite-value-list-item"): void;
+export declare function setUpFilter<T extends Lists>(this: List<T>): void;
+export declare function deselectRemovedItems<T extends Lists>(this: List<T>): void;
+export declare function deselectSiblingItems<T extends Lists>(this: List<T>, item: ListItemElement<T>): void;
+export declare function selectSiblings<T extends Lists>(this: List<T>, item: ListItemElement<T>, deselect?: boolean): void;
+export declare function handleFilter<T extends Lists>(this: List<T>, event: CustomEvent): void;
+export declare type ItemData = {
+  label: string;
+  description: string;
+  metadata: Record<string, unknown>;
+  value: string;
+}[];
+export declare function getItemData<T extends Lists>(this: List<T>): ItemData;
+export {};

package/dist/types/components/calcite-pick-list/shared-list-render.d.ts

@@ -0,0 +1,18 @@
+import { FunctionalComponent } from "../../stencil-public-runtime";
+import { JSXBase } from "../../stencil-public-runtime";
+import { handleFilter } from "./shared-list-logic";
+import DOMAttributes = JSXBase.DOMAttributes;
+interface ListProps extends DOMAttributes<any> {
+  disabled: boolean;
+  loading: boolean;
+  filterEnabled: boolean;
+  dataForFilter: any;
+  handleFilter: typeof handleFilter;
+  filterPlaceholder: string;
+  el: HTMLCalcitePickListElement | HTMLCalciteValueListElement;
+  setFilterEl: (el: HTMLCalciteFilterElement) => void;
+}
+export declare const List: FunctionalComponent<{
+  props: ListProps;
+} & DOMAttributes<any>>;
+export default List;

package/dist/types/components/calcite-pick-list-group/calcite-pick-list-group.d.ts

@@ -0,0 +1,21 @@
+import { VNode } from "../../stencil-public-runtime";
+import { HeadingLevel } from "../functional/CalciteHeading";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/**
+ * @slot - A slot for adding `calcite-pick-list-item` elements.
+ */
+export declare class CalcitePickListGroup implements ConditionalSlotComponent {
+  /**
+   * The title used for all nested `calcite-pick-list` rows.
+   *
+   */
+  groupTitle: string;
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  el: HTMLCalcitePickListGroupElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  render(): VNode;
+}