@esri/calcite-components 1.0.0-beta.79 → 1.0.0-beta.80

package/dist/types/components/time-picker/time-picker.d.ts

@@ -0,0 +1,137 @@
+import { VNode, EventEmitter } from "../../stencil-public-runtime";
+import { Scale } from "../interfaces";
+import { TimePart, HourCycle, Meridiem } from "../../utils/time";
+export declare class TimePicker {
+  el: HTMLCalciteTimePickerElement;
+  /** aria-label for the hour input
+   * @default "Hour"
+   */
+  intlHour: string;
+  /** aria-label for the hour down button
+   * @default "Decrease hour"
+   */
+  intlHourDown: string;
+  /** aria-label for the hour up button
+   * @default "Increase hour"
+   */
+  intlHourUp: string;
+  /** aria-label for the meridiem (am/pm) input
+   * @default "AM/PM"
+   */
+  intlMeridiem: string;
+  /** aria-label for the meridiem (am/pm) down button
+   * @default "Decrease AM/PM"
+   */
+  intlMeridiemDown: string;
+  /** aria-label for the meridiem (am/pm) up button
+   * @default "Increase AM/PM"
+   */
+  intlMeridiemUp: string;
+  /** aria-label for the minute input
+   * @default "Minute"
+   */
+  intlMinute: string;
+  /** aria-label for the minute down button
+   * @default "Decrease minute"
+   */
+  intlMinuteDown: string;
+  /** aria-label for the minute up button
+   * @default "Increase minute"
+   */
+  intlMinuteUp: string;
+  /** aria-label for the second input
+   * @default "Second"
+   */
+  intlSecond: string;
+  /** aria-label for the second down button
+   * @default "Decrease second"
+   */
+  intlSecondDown: string;
+  /** aria-label for the second up button
+   * @default "Increase second"
+   */
+  intlSecondUp: string;
+  /**
+   * BCP 47 language tag for desired language and country format
+   * @internal
+   */
+  locale: string;
+  localeWatcher(newLocale: string): void;
+  /** The scale (size) of the time picker */
+  scale: Scale;
+  /** number (seconds) that specifies the granularity that the value must adhere to */
+  step: number;
+  /** The selected time in UTC (always 24-hour format) */
+  value: string;
+  valueWatcher(newValue: string): void;
+  private activeEl;
+  private hourEl;
+  private meridiemEl;
+  private minuteEl;
+  private secondEl;
+  private meridiemOrder;
+  hour: string;
+  hourChanged(newHour: string): void;
+  hourCycle: HourCycle;
+  localizedHour: string;
+  localizedHourSuffix: string;
+  localizedMeridiem: string;
+  localizedMinute: string;
+  localizedMinuteSuffix: string;
+  localizedSecond: string;
+  localizedSecondSuffix: string;
+  meridiem: Meridiem;
+  minute: string;
+  second: string;
+  showSecond: boolean;
+  /**
+   * @internal
+   */
+  calciteTimePickerBlur: EventEmitter<void>;
+  /**
+   * @internal
+   */
+  calciteTimePickerChange: EventEmitter<string>;
+  /**
+   * @internal
+   */
+  calciteTimePickerFocus: EventEmitter<void>;
+  hostBlurHandler(): void;
+  hostFocusHandler(): void;
+  keyDownHandler(event: KeyboardEvent): void;
+  /** Sets focus on the component. */
+  setFocus(target: TimePart): Promise<void>;
+  private buttonActivated;
+  private decrementHour;
+  private decrementMeridiem;
+  private decrementMinuteOrSecond;
+  private decrementMinute;
+  private decrementSecond;
+  private focusHandler;
+  private hourDownButtonKeyDownHandler;
+  private hourKeyDownHandler;
+  private hourUpButtonKeyDownHandler;
+  private incrementMeridiem;
+  private incrementHour;
+  private incrementMinuteOrSecond;
+  private incrementMinute;
+  private incrementSecond;
+  private meridiemDownButtonKeyDownHandler;
+  private meridiemKeyDownHandler;
+  private meridiemUpButtonKeyDownHandler;
+  private minuteDownButtonKeyDownHandler;
+  private minuteKeyDownHandler;
+  private minuteUpButtonKeyDownHandler;
+  private secondDownButtonKeyDownHandler;
+  private secondKeyDownHandler;
+  private secondUpButtonKeyDownHandler;
+  private setHourEl;
+  private setMeridiemEl;
+  private setMinuteEl;
+  private setSecondEl;
+  private setValue;
+  private setValuePart;
+  private getMeridiemOrder;
+  connectedCallback(): void;
+  render(): VNode;
+}

package/dist/types/components/tip/tip.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { HeadingLevel } from "../functional/Heading";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/**
+ * @slot - A slot for adding text and a hyperlink.
+ * @slot thumbnail - A slot for adding an HTML image element to the tip.
+ */
+export declare class Tip implements ConditionalSlotComponent {
+  /**
+   * No longer displays the tip.
+   */
+  dismissed: boolean;
+  /**
+   * Indicates whether the tip can be dismissed.
+   */
+  nonDismissible: boolean;
+  /**
+   * The heading of the tip.
+   */
+  heading?: string;
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  /**
+   * The selected state of the tip if it is being used inside a `calcite-tip-manager`.
+   */
+  selected: boolean;
+  /**
+   * Alternate text for closing the tip.
+   */
+  intlClose?: string;
+  el: HTMLCalciteTipElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  /**
+   * Emitted when the component has been dismissed.
+   */
+  calciteTipDismiss: EventEmitter;
+  hideTip: () => void;
+  renderHeader(): VNode;
+  renderDismissButton(): VNode;
+  renderImageFrame(): VNode;
+  renderInfoNode(): VNode;
+  renderContent(): VNode;
+  render(): VNode;
+}

package/dist/types/components/tip-manager/tip-manager.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { HeadingLevel } from "../functional/Heading";
+/**
+ * @slot - A slot for adding `calcite-tip`s.
+ */
+export declare class TipManager {
+  /**
+   * Alternate text for closing the `calcite-tip-manager`.
+   */
+  closed: boolean;
+  closedChangeHandler(): void;
+  /**
+   * Number at which section headings should start for this component.
+   */
+  headingLevel: HeadingLevel;
+  /**
+   * Alternate text for closing the tip.
+   */
+  intlClose?: string;
+  /**
+   * The default group title for the `calcite-tip-manager`.
+   */
+  intlDefaultTitle?: string;
+  /**
+   * Alternate text for navigating to the next tip.
+   */
+  intlNext?: string;
+  /**
+   * Label that appears on hover of pagination icon.
+   */
+  intlPaginationLabel?: string;
+  /**
+   * Alternate text for navigating to the previous tip.
+   */
+  intlPrevious?: string;
+  el: HTMLCalciteTipManagerElement;
+  selectedIndex: number;
+  selectedChangeHandler(): void;
+  tips: HTMLCalciteTipElement[];
+  total: number;
+  direction: "advancing" | "retreating";
+  groupTitle: string;
+  mutationObserver: MutationObserver;
+  container: HTMLDivElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  /** Selects the next tip to display */
+  nextTip(): Promise<void>;
+  /** Selects the previous tip to display */
+  previousTip(): Promise<void>;
+  /**
+   * Emitted when the `calcite-tip-manager` has been toggled open or closed.
+   */
+  calciteTipManagerToggle: EventEmitter;
+  setUpTips(): void;
+  hideTipManager: () => void;
+  showSelectedTip(): void;
+  updateGroupTitle(): void;
+  previousClicked: () => void;
+  nextClicked: () => void;
+  tipManagerKeyUpHandler: (event: KeyboardEvent) => void;
+  storeContainerRef: (el: HTMLDivElement) => void;
+  renderPagination(): VNode;
+  render(): VNode;
+}

package/dist/types/components/tooltip/tooltip.d.ts

@@ -0,0 +1,60 @@
+import { VNode } from "../../stencil-public-runtime";
+import { StrictModifiers, Instance as Popper } from "@popperjs/core";
+import { PopperPlacement, OverlayPositioning } from "../../utils/popper";
+/**
+ * @slot - A slot for adding text.
+ */
+export declare class Tooltip {
+  /** Accessible name for the component */
+  label: string;
+  /**
+   * Offset the position of the tooltip away from the reference element.
+   * @default 6
+   */
+  offsetDistance: number;
+  offsetDistanceOffsetHandler(): void;
+  /**
+   * Offset the position of the tooltip along the reference element.
+   */
+  offsetSkidding: number;
+  offsetSkiddingHandler(): void;
+  /**
+   * Display and position the component.
+   */
+  open: boolean;
+  openHandler(): void;
+  /** Describes the type of positioning to use for the overlaid content. If your element is in a fixed container, use the 'fixed' value. */
+  overlayPositioning: OverlayPositioning;
+  /**
+   * Determines where the component will be positioned relative to the referenceElement.
+   * @see [PopperPlacement](https://github.com/Esri/calcite-components/blob/master/src/utils/popper.ts#L25)
+   */
+  placement: PopperPlacement;
+  placementHandler(): void;
+  /**
+   * Reference HTMLElement used to position this component according to the placement property. As a convenience, a string ID of the reference element can be used. However, setting this property to use an HTMLElement is preferred so that the component does not need to query the DOM for the referenceElement.
+   */
+  referenceElement: HTMLElement | string;
+  referenceElementHandler(): void;
+  el: HTMLCalciteTooltipElement;
+  effectiveReferenceElement: HTMLElement;
+  arrowEl: HTMLDivElement;
+  popper: Popper;
+  guid: string;
+  componentWillLoad(): void;
+  componentDidLoad(): void;
+  disconnectedCallback(): void;
+  /** Updates the position of the component. */
+  reposition(): Promise<void>;
+  setUpReferenceElement: () => void;
+  getId: () => string;
+  addReferences: () => void;
+  removeReferences: () => void;
+  show: () => void;
+  hide: () => void;
+  getReferenceElement(): HTMLElement;
+  getModifiers(): Partial<StrictModifiers>[];
+  createPopper(): void;
+  destroyPopper(): void;
+  render(): VNode;
+}

package/dist/types/components/tooltip-manager/tooltip-manager.d.ts

@@ -0,0 +1,41 @@
+import { VNode } from "../../stencil-public-runtime";
+/**
+ * @slot - A slot for adding elements that reference a 'calcite-tooltip' by the 'selector' property.
+ */
+export declare class TooltipManager {
+  el: HTMLCalciteTooltipManagerElement;
+  tooltipEl: HTMLCalciteTooltipElement;
+  hoverTimeouts: WeakMap<HTMLCalciteTooltipElement, number>;
+  clickedTooltip: HTMLCalciteTooltipElement;
+  /**
+   * CSS Selector to match reference elements for tooltips. Reference elements will be identified by this selector in order to open their associated tooltip.
+   * @default `[data-calcite-tooltip-reference]`
+   */
+  selector: string;
+  queryTooltip: (composedPath: EventTarget[]) => HTMLCalciteTooltipElement;
+  clearHoverTimeout: (tooltip: HTMLCalciteTooltipElement) => void;
+  closeExistingTooltip: () => void;
+  focusTooltip: ({ tooltip, value }: {
+    tooltip: HTMLCalciteTooltipElement;
+    value: boolean;
+  }) => void;
+  toggleTooltip: (tooltip: HTMLCalciteTooltipElement, value: boolean) => void;
+  hoverToggle: ({ tooltip, value }: {
+    tooltip: HTMLCalciteTooltipElement;
+    value: boolean;
+  }) => void;
+  hoverTooltip: ({ tooltip, value }: {
+    tooltip: HTMLCalciteTooltipElement;
+    value: boolean;
+  }) => void;
+  activeTooltipHover: (event: MouseEvent) => void;
+  hoverEvent: (event: MouseEvent, value: boolean) => void;
+  focusEvent: (event: FocusEvent, value: boolean) => void;
+  render(): VNode;
+  keyUpHandler(event: KeyboardEvent): void;
+  mouseEnterShow(event: MouseEvent): void;
+  mouseLeaveHide(event: MouseEvent): void;
+  clickHandler(event: MouseEvent): void;
+  focusShow(event: FocusEvent): void;
+  blurHide(event: FocusEvent): void;
+}

package/dist/types/components/tree/interfaces.d.ts

@@ -0,0 +1,10 @@
+export interface TreeSelectDetail {
+  selected: HTMLCalciteTreeItemElement[];
+}
+export declare enum TreeSelectionMode {
+  Single = "single",
+  Multi = "multi",
+  Children = "children",
+  MultiChildren = "multi-children",
+  Ancestors = "ancestors"
+}

package/dist/types/components/tree/tree.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { TreeItemSelectDetail } from "../tree-item/interfaces";
+import { TreeSelectDetail, TreeSelectionMode } from "./interfaces";
+import { Scale } from "../interfaces";
+/**
+ * @slot - A slot for `calcite-tree-item` elements.
+ */
+export declare class Tree {
+  el: HTMLCalciteTreeElement;
+  /** Display indentation guide lines */
+  lines: boolean;
+  /** Display input
+   * @deprecated use "ancestors" selection-mode for checkbox input
+   */
+  inputEnabled: boolean;
+  /** @internal If this tree is nested within another tree, set to false */
+  child: boolean;
+  /** Specify the scale of the tree, defaults to m */
+  scale: Scale;
+  /** Customize how tree selection works (single, multi, children, multi-children, ancestors)
+   * @default "single"
+   * @see [TreeSelectionMode](https://github.com/Esri/calcite-components/blob/master/src/components/tree/interfaces.ts#L5)
+   */
+  selectionMode: TreeSelectionMode;
+  componentWillRender(): void;
+  render(): VNode;
+  onFocus(): void;
+  onFocusIn(event: FocusEvent): void;
+  onFocusOut(event: FocusEvent): void;
+  onClick(e: CustomEvent<TreeItemSelectDetail>): void;
+  keyDownHandler(event: KeyboardEvent): void;
+  updateAncestorTree(e: CustomEvent<TreeItemSelectDetail>): void;
+  /**
+   * Emitted when user selects/deselects tree items. An object including an array of selected items will be passed in the event's `detail` property.
+   * @see [TreeSelectDetail](https://github.com/Esri/calcite-components/blob/master/src/components/tree/interfaces.ts#L1)
+   */
+  calciteTreeSelect: EventEmitter<TreeSelectDetail>;
+  getRootTabIndex(): number;
+}

package/dist/types/components/tree-item/tree-item.d.ts

@@ -0,0 +1,60 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { TreeItemSelectDetail } from "./interfaces";
+import { TreeSelectionMode } from "../tree/interfaces";
+import { Scale } from "../interfaces";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+/**
+ * @slot - A slot for adding content to the item.
+ * @slot children - A slot for adding nested `calcite-tree` elements.
+ */
+export declare class TreeItem implements ConditionalSlotComponent {
+  el: HTMLCalciteTreeItemElement;
+  /** Is the item currently selected */
+  selected: boolean;
+  /** True if the item is in an expanded state */
+  expanded: boolean;
+  expandedHandler(newValue: boolean): void;
+  /** @internal Is the parent of this item expanded? */
+  parentExpanded: boolean;
+  /** @internal What level of depth is this item at? */
+  depth: number;
+  /** @internal Does this tree item have a tree inside it? */
+  hasChildren: boolean;
+  /** @internal Draw lines (set on parent) */
+  lines: boolean;
+  /** Display checkboxes (set on parent)
+   * @internal
+   * @deprecated set "ancestors" selection-mode on parent tree for checkboxes
+   */
+  inputEnabled: boolean;
+  /** @internal Scale of the parent tree, defaults to m */
+  scale: Scale;
+  /**
+   * @internal
+   * In ancestor selection mode,
+   * show as indeterminate when only some children are selected
+   **/
+  indeterminate: boolean;
+  /** @internal Tree selection-mode (set on parent) */
+  selectionMode: TreeSelectionMode;
+  getselectionMode(): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  componentWillRender(): void;
+  componentDidLoad(): void;
+  private isSelectionMultiLike;
+  render(): VNode;
+  onClick(e: Event): void;
+  iconClickHandler: (event: MouseEvent) => void;
+  childrenClickHandler: (event: MouseEvent) => void;
+  keyDownHandler(e: KeyboardEvent): void;
+  /**
+   * @internal
+   */
+  calciteTreeItemSelect: EventEmitter<TreeItemSelectDetail>;
+  childrenSlotWrapper: HTMLElement;
+  defaultSlotWrapper: HTMLElement;
+  private parentTreeItem?;
+  private updateParentIsExpanded;
+  private updateAncestorTree;
+}

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

@@ -0,0 +1,92 @@
+import Sortable from "sortablejs";
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { ICON_TYPES } from "./resources";
+import { ListFocusId, ItemData } from "../pick-list/shared-list-logic";
+import { InteractiveComponent } from "../../utils/interactive";
+/**
+ * @slot - A slot for adding `calcite-value-list-item` 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 ValueList<ItemElement extends HTMLCalciteValueListItemElement = HTMLCalciteValueListItemElement> implements InteractiveComponent {
+  /**
+   * When true, disabled prevents interaction. This state shows items with lower opacity/grayed.
+   */
+  disabled: boolean;
+  /**
+   * When true, the items will be sortable via drag and drop.
+   */
+  dragEnabled: 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;
+  /**
+   * The list's group identifier.
+   *
+   * To drag elements from one list into another, both lists must have the same group value.
+   */
+  group?: string;
+  /**
+   * 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;
+  sortable: Sortable;
+  el: HTMLCalciteValueListElement;
+  emitCalciteListChange: () => void;
+  filterEl: HTMLCalciteFilterElement;
+  connectedCallback(): void;
+  componentDidLoad(): void;
+  componentDidRender(): void;
+  disconnectedCallback(): void;
+  /**
+   * Emitted when any of the item selections have changed.
+   */
+  calciteListChange: EventEmitter<Map<string, HTMLCalciteValueListItemElement>>;
+  /**
+   * Emitted when the order of the list has changed.
+   */
+  calciteListOrderChange: EventEmitter<any[]>;
+  calciteListFocusOutHandler(event: FocusEvent): void;
+  calciteListItemRemoveHandler(event: CustomEvent<void>): void;
+  calciteListItemChangeHandler(event: CustomEvent): void;
+  calciteListItemPropsChangeHandler(event: CustomEvent): void;
+  calciteListItemValueChangeHandler(event: CustomEvent): void;
+  getItems(): ItemElement[];
+  setUpItems(): void;
+  setUpFilter(): void;
+  setFilterEl: (el: HTMLCalciteFilterElement) => void;
+  setUpDragAndDrop(): void;
+  cleanUpDragAndDrop(): void;
+  deselectRemovedItems: any;
+  deselectSiblingItems: any;
+  selectSiblings: any;
+  handleFilter: any;
+  getItemData: any;
+  keyDownHandler: (event: KeyboardEvent) => void;
+  /** Returns the currently selected items */
+  getSelectedItems(): Promise<Map<string, HTMLCalciteValueListItemElement>>;
+  /** Sets focus on the component. */
+  setFocus(focusId?: ListFocusId): Promise<void>;
+  getIconType(): ICON_TYPES | null;
+  render(): VNode;
+}

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

@@ -0,0 +1,81 @@
+import { EventEmitter, VNode } from "../../stencil-public-runtime";
+import { ICON_TYPES } from "../pick-list/resources";
+import { ConditionalSlotComponent } from "../../utils/conditionalSlot";
+import { InteractiveComponent } from "../../utils/interactive";
+/**
+ * @slot actions-end - A slot for adding actions or content to the end side of the item.
+ * @slot actions-start - A slot for adding actions or content to the start side of the item.
+ */
+export declare class ValueListItem implements ConditionalSlotComponent, InteractiveComponent {
+  /**
+   * An optional description for this item. Will appear below the label text.
+   */
+  description?: string;
+  /**
+   * When true, the item cannot be clicked and is visually muted
+   */
+  disabled: boolean;
+  /**
+   * @internal When false, the item cannot be deselected by user interaction.
+   */
+  disableDeselect: boolean;
+  /**
+   * When true, prevents the content of the list item from user interaction.
+   */
+  nonInteractive: boolean;
+  /**
+   * @internal - stores the activated state of the drag handle.
+   */
+  handleActivated?: boolean;
+  /**
+   * Determines the icon SVG symbol that will be shown. Options are circle, square, grip or null.
+   * @see [ICON_TYPES](https://github.com/Esri/calcite-components/blob/master/src/components/pick-list/resources.ts#L5)
+   */
+  icon?: ICON_TYPES | null;
+  /**
+   * The main label for this item. Appears next to the icon.
+   */
+  label: string;
+  /**
+   * Used to provide additional metadata to an item, primarily used when the parent list has a filter.
+   */
+  metadata?: Record<string, unknown>;
+  /**
+   * Set this to true to display a remove action that removes the item from the list.
+   */
+  removable: boolean;
+  /**
+   * Set this to true to pre-select an item. Toggles when an item is checked/unchecked.
+   */
+  selected: boolean;
+  /**
+   * The item's associated value.
+   */
+  value: any;
+  el: HTMLCalciteValueListItemElement;
+  pickListItem: HTMLCalcitePickListItemElement;
+  guid: string;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  componentDidRender(): void;
+  /**
+   * Used to toggle the selection state. By default this won't trigger an event.
+   * The first argument allows the value to be coerced, rather than swapping values.
+   */
+  toggleSelected(coerce?: boolean): Promise<void>;
+  /** Sets focus on the component. */
+  setFocus(): Promise<void>;
+  /**
+   * Emitted whenever the remove button is pressed.
+   */
+  calciteListItemRemove: EventEmitter<void>;
+  calciteListItemChangeHandler(event: CustomEvent): void;
+  getPickListRef: (el: HTMLCalcitePickListItemElement) => HTMLCalcitePickListItemElement;
+  handleKeyDown: (event: KeyboardEvent) => void;
+  handleBlur: () => void;
+  handleSelectChange: (event: CustomEvent) => void;
+  renderActionsEnd(): VNode;
+  renderActionsStart(): VNode;
+  renderHandle(): VNode;
+  render(): VNode;
+}

package/dist/types/components.d.ts

@@ -7,7 +7,6 @@
 import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { AccordionAppearance } from "./components/accordion/interfaces";
 import { Alignment, Appearance, Columns, FlipContext, Layout, Position, Scale, Status, Width } from "./components/interfaces";
-import { Placement } from "@popperjs/core";
 import { ComputedPlacement, MenuPlacement, OverlayPositioning, PopperPlacement } from "./utils/popper";
 import { AlertDuration, AlertPlacement, StatusColor } from "./components/alert/interfaces";
 import { HeadingLevel } from "./components/functional/Heading";
@@ -208,7 +207,7 @@ export namespace Components {
         /**
           * Defines the available placements that can be used when a flip occurs.
          */
-        "flipPlacements"?: Placement[];
+        "flipPlacements"?: ComputedPlacement[];
         /**
           * Text string for the actions menu.
          */
@@ -2322,7 +2321,7 @@ export namespace Components {
         /**
           * Defines the available placements that can be used when a flip occurs.
          */
-        "flipPlacements"?: Placement[];
+        "flipPlacements"?: ComputedPlacement[];
         /**
           * Heading text.
          */
@@ -4315,7 +4314,7 @@ declare namespace LocalJSX {
         /**
           * Defines the available placements that can be used when a flip occurs.
          */
-        "flipPlacements"?: Placement[];
+        "flipPlacements"?: ComputedPlacement[];
         /**
           * Text string for the actions menu.
          */
@@ -6447,7 +6446,7 @@ declare namespace LocalJSX {
         /**
           * Defines the available placements that can be used when a flip occurs.
          */
-        "flipPlacements"?: Placement[];
+        "flipPlacements"?: ComputedPlacement[];
         /**
           * Heading text.
          */