## API Report File for "office-ui-fabric-react"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { BaseComponent } from '@uifabric/utilities';
import { EventGroup } from '@uifabric/utilities';
import { IBaseProps } from '@uifabric/utilities';
import { IComponent } from '@uifabric/foundation';
import { IComponentAs } from '@uifabric/utilities';
import { IComponentStyles } from '@uifabric/foundation';
import { ICSSPixelUnitRule } from '@uifabric/merge-styles/lib/IRawStyleBase';
import { ICSSRule } from '@uifabric/merge-styles/lib/IRawStyleBase';
import { IFontStyles } from '@uifabric/styling';
import { IHTMLSlot } from '@uifabric/foundation';
import { IObjectWithKey } from '@uifabric/utilities';
import { IPoint } from '@uifabric/utilities';
import { IRawStyle } from '@uifabric/styling';
import { IRectangle } from '@uifabric/utilities';
import { IRefObject } from '@uifabric/utilities';
import { IRenderComponent } from '@uifabric/utilities';
import { IRenderFunction } from '@uifabric/utilities';
import { ISelection } from '@uifabric/utilities';
import { ISelectionOptions } from '@uifabric/utilities';
import { ISlotProp } from '@uifabric/foundation';
import { ISlottableProps } from '@uifabric/foundation';
import { IStyle } from '@uifabric/styling';
import { IStyleableComponentProps } from '@uifabric/foundation';
import { IStyleFunction } from '@uifabric/utilities';
import { IStyleFunctionOrObject } from '@uifabric/utilities';
import { IStyleSet } from '@uifabric/styling';
import { ITheme } from '@uifabric/styling';
import { KeyCodes } from '@uifabric/utilities';
import { Omit } from '@uifabric/utilities';
import * as PropTypes from 'prop-types';
import * as React from 'react';
import { Selection } from '@uifabric/utilities';
import { SELECTION_CHANGE } from '@uifabric/utilities';
import { SelectionDirection } from '@uifabric/utilities';
import { SelectionMode } from '@uifabric/utilities';

// @public (undocumented)
export class ActionButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public (undocumented)
export class ActivityItem extends React.Component<IActivityItemProps, {}> {
    constructor(props: IActivityItemProps);
    // (undocumented)
    render(): JSX.Element;
}

// @public
export type Alignment = 'start' | 'end' | 'center' | 'space-between' | 'space-around' | 'space-evenly' | 'baseline' | 'stretch';

// @public (undocumented)
export const Announced: React.StatelessComponent<IAnnouncedProps>;

// @public (undocumented)
export class AnnouncedBase extends React.Component<IAnnouncedProps> {
    // (undocumented)
    static defaultProps: Partial<IAnnouncedProps>;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export class Autofill extends BaseComponent<IAutofillProps, IAutofillState> implements IAutofill {
    constructor(props: IAutofillProps);
    // (undocumented)
    clear(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    readonly cursorLocation: number | null;
    // (undocumented)
    static defaultProps: {
        enableAutofillOnKeyPress: number[];
    };
    // (undocumented)
    focus(): void;
    // (undocumented)
    readonly inputElement: HTMLInputElement | null;
    // (undocumented)
    readonly isValueSelected: boolean;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    readonly selectionEnd: number | null;
    // (undocumented)
    readonly selectionStart: number | null;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: IAutofillProps): void;
    // (undocumented)
    readonly value: string;
    }

// @public @deprecated (undocumented)
export class BaseAutoFill extends Autofill {
}

// @public (undocumented)
export class BaseButton extends BaseComponent<IBaseButtonProps, IBaseButtonState> implements IButton {
    constructor(props: IBaseButtonProps, rootClassName: string);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IBaseButtonProps, prevState: IBaseButtonState): void;
    // (undocumented)
    static defaultProps: Partial<IBaseButtonProps>;
    // (undocumented)
    dismissMenu(): void;
    // (undocumented)
    focus(): void;
    // (undocumented)
    openMenu(shouldFocusOnContainer?: boolean, shouldFocusOnMount?: boolean): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export class BaseExtendedPeoplePicker extends BaseExtendedPicker<IPersonaProps, IExtendedPeoplePickerProps> {
}

// @public (undocumented)
export class BaseExtendedPicker<T, P extends IBaseExtendedPickerProps<T>> extends BaseComponent<P, IBaseExtendedPickerState<T>> implements IBaseExtendedPicker<T> {
    constructor(basePickerProps: P);
    // (undocumented)
    protected canAddItems(): boolean;
    // (undocumented)
    clearInput(): void;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    floatingPicker: React.RefObject<BaseFloatingPicker<T, IBaseFloatingPickerProps<T>>>;
    // (undocumented)
    protected floatingPickerProps: IBaseFloatingPickerProps<T>;
    // (undocumented)
    focus(): void;
    // (undocumented)
    readonly highlightedItems: T[];
    // (undocumented)
    protected input: React.RefObject<Autofill>;
    // (undocumented)
    readonly inputElement: HTMLInputElement | null;
    // (undocumented)
    readonly items: any;
    // (undocumented)
    protected onBackspace: (ev: React.KeyboardEvent<HTMLElement>) => void;
    // (undocumented)
    protected onCopy: (ev: React.ClipboardEvent<HTMLElement>) => void;
    // (undocumented)
    protected onInputChange: (value: string) => void;
    // (undocumented)
    protected onInputClick: (ev: React.MouseEvent<HTMLInputElement | Autofill, MouseEvent>) => void;
    // (undocumented)
    protected onInputFocus: (ev: React.FocusEvent<HTMLInputElement | Autofill>) => void;
    // (undocumented)
    protected onPaste: (ev: React.ClipboardEvent<HTMLInputElement | Autofill>) => void;
    // (undocumented)
    protected _onSelectedItemsChanged: () => void;
    // (undocumented)
    protected onSelectionChange: () => void;
    // (undocumented)
    protected _onSuggestionSelected: (item: T) => void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    protected renderFloatingPicker(): JSX.Element;
    // (undocumented)
    protected renderSelectedItemsList(): JSX.Element;
    // (undocumented)
    protected root: React.RefObject<HTMLDivElement>;
    // (undocumented)
    selectedItemsList: React.RefObject<BaseSelectedItemsList<T, IBaseSelectedItemsListProps<T>>>;
    // (undocumented)
    protected selectedItemsListProps: IBaseSelectedItemsListProps<T>;
    // (undocumented)
    protected selection: Selection;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: P): void;
}

// @public (undocumented)
export class BaseFloatingPeoplePicker extends BaseFloatingPicker<IPersonaProps, IPeopleFloatingPickerProps> {
}

// @public (undocumented)
export class BaseFloatingPicker<T, P extends IBaseFloatingPickerProps<T>> extends BaseComponent<P, IBaseFloatingPickerState> implements IBaseFloatingPicker {
    constructor(basePickerProps: P);
    // (undocumented)
    completeSuggestion: () => void;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    protected currentPromise: PromiseLike<T[]>;
    // (undocumented)
    readonly currentSelectedSuggestionIndex: number;
    // (undocumented)
    forceResolveSuggestion(): void;
    // (undocumented)
    hidePicker: () => void;
    // (undocumented)
    readonly inputText: string;
    // (undocumented)
    protected isComponentMounted: boolean;
    // (undocumented)
    readonly isSuggestionsShown: boolean;
    // (undocumented)
    protected onChange(item: T): void;
    // (undocumented)
    protected onKeyDown: (ev: MouseEvent) => void;
    // (undocumented)
    onQueryStringChanged: (queryString: string) => void;
    // (undocumented)
    protected onSelectionChange(): void;
    // (undocumented)
    protected onSuggestionClick: (ev: React.MouseEvent<HTMLElement, MouseEvent>, item: T, index: number) => void;
    // (undocumented)
    protected onSuggestionRemove: (ev: React.MouseEvent<HTMLElement, MouseEvent>, item: T, index: number) => void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    protected renderSuggestions(): JSX.Element | null;
    // (undocumented)
    protected root: React.RefObject<HTMLDivElement>;
    // (undocumented)
    protected selection: Selection;
    // (undocumented)
    showPicker: (updateValue?: boolean) => void;
    // (undocumented)
    readonly suggestions: any[];
    // (undocumented)
    protected suggestionsControl: React.RefObject<SuggestionsControl<T>>;
    // (undocumented)
    protected SuggestionsControlOfProperType: new (props: ISuggestionsControlProps<T>) => SuggestionsControl<T>;
    // (undocumented)
    protected suggestionStore: SuggestionsStore<T>;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IBaseFloatingPickerProps<T>): void;
    // (undocumented)
    updateSuggestions(suggestions: T[], forceUpdate?: boolean): void;
    // (undocumented)
    protected updateSuggestionsList(suggestions: T[] | PromiseLike<T[]>): void;
    // (undocumented)
    protected updateSuggestionWithZeroState(): void;
    // (undocumented)
    protected updateValue(updatedValue: string): void;
}

// @public (undocumented)
export class BasePeoplePicker extends BasePicker<IPersonaProps, IPeoplePickerProps> {
}

// @public (undocumented)
export class BasePeopleSelectedItemsList extends BaseSelectedItemsList<IExtendedPersonaProps, ISelectedPeopleProps> {
}

// @public (undocumented)
export class BasePicker<T, P extends IBasePickerProps<T>> extends BaseComponent<P, IBasePickerState> implements IBasePicker<T> {
    constructor(basePickerProps: P);
    // (undocumented)
    protected addItem: (item: T) => void;
    // (undocumented)
    protected addItemByIndex: (index: number) => void;
    // (undocumented)
    protected _ariaMap: IPickerAriaIds;
    // (undocumented)
    protected canAddItems(): boolean;
    // (undocumented)
    completeSuggestion(): void;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    protected currentPromise: PromiseLike<any> | undefined;
    // (undocumented)
    dismissSuggestions: (ev?: any) => void;
    // (undocumented)
    focus(): void;
    // (undocumented)
    focusInput(): void;
    // (undocumented)
    protected focusZone: React.RefObject<IFocusZone>;
    // (undocumented)
    protected getActiveDescendant(): string | undefined;
    // (undocumented)
    protected getSuggestionsAlert(suggestionAlertClassName?: string): JSX.Element | undefined;
    // (undocumented)
    protected input: React.RefObject<IAutofill>;
    // (undocumented)
    protected _isFocusZoneInnerKeystroke: (ev: React.KeyboardEvent<HTMLElement>) => boolean;
    // (undocumented)
    readonly items: T[];
    // (undocumented)
    protected onBackspace(ev: React.KeyboardEvent<HTMLElement>): void;
    // (undocumented)
    protected onBlur: (ev: React.FocusEvent<HTMLElement | Autofill>) => void;
    // (undocumented)
    protected onChange(items?: T[]): void;
    protected onClick: (ev: React.MouseEvent<HTMLInputElement, MouseEvent>) => void;
    // (undocumented)
    protected onEmptyInputFocus(): void;
    // (undocumented)
    protected onGetMoreResults: () => void;
    // (undocumented)
    protected onInputBlur: (ev: React.FocusEvent<HTMLInputElement | Autofill>) => void;
    // (undocumented)
    protected onInputChange: (value: string) => void;
    // (undocumented)
    protected onInputFocus: (ev: React.FocusEvent<HTMLInputElement | Autofill>) => void;
    // (undocumented)
    protected onItemChange: (changedItem: T, index: number) => void;
    // (undocumented)
    protected onKeyDown: (ev: React.KeyboardEvent<HTMLElement>) => void;
    // (undocumented)
    protected onSelectionChange(): void;
    // (undocumented)
    protected onSuggestionClick: (ev: React.MouseEvent<HTMLElement, MouseEvent>, item: any, index: number) => void;
    // (undocumented)
    protected onSuggestionRemove: (ev: React.MouseEvent<HTMLElement, MouseEvent>, item: T, index: number) => void;
    // (undocumented)
    protected onSuggestionSelect(): void;
    // (undocumented)
    refocusSuggestions: (keyCode: number) => void;
    // (undocumented)
    protected removeItem: (item: IPickerItemProps<T>, focusNextItem?: boolean | undefined) => void;
    // (undocumented)
    protected removeItems: (itemsToRemove: any[]) => void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    protected renderItems(): JSX.Element[];
    // (undocumented)
    protected renderSuggestions(): JSX.Element | null;
    // (undocumented)
    protected resetFocus(index?: number): void;
    // (undocumented)
    protected resolveNewValue(updatedValue: string, suggestions: T[]): void;
    // (undocumented)
    protected root: React.RefObject<HTMLDivElement>;
    // (undocumented)
    protected selection: Selection;
    // (undocumented)
    protected suggestionElement: React.RefObject<ISuggestions<T>>;
    // @deprecated (undocumented)
    protected SuggestionOfProperType: new (props: ISuggestionsProps<T>) => Suggestions<T>;
    // (undocumented)
    protected suggestionStore: SuggestionsController<T>;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: P): void;
    // (undocumented)
    UNSAFE_componentWillUpdate(newProps: P, newState: IBasePickerState): void;
    // (undocumented)
    protected updateSuggestions(suggestions: any[]): void;
    // (undocumented)
    protected updateSuggestionsList(suggestions: T[] | PromiseLike<T[]>, updatedValue?: string): void;
    // (undocumented)
    protected updateValue(updatedValue: string): void;
}

// @public (undocumented)
export class BasePickerListBelow<T, P extends IBasePickerProps<T>> extends BasePicker<T, P> {
    // (undocumented)
    protected onBackspace(ev: React.KeyboardEvent<HTMLElement>): void;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export class BaseSelectedItemsList<T, P extends IBaseSelectedItemsListProps<T>> extends BaseComponent<P, IBaseSelectedItemsListState<T>> implements IBaseSelectedItemsList<T> {
    constructor(basePickerProps: P);
    // (undocumented)
    addItems: (items: T[]) => void;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    protected copyItems(items: T[]): void;
    // (undocumented)
    hasSelectedItems(): boolean;
    // (undocumented)
    highlightedItems(): T[];
    // (undocumented)
    readonly items: T[];
    // (undocumented)
    protected onChange(items?: T[]): void;
    // (undocumented)
    onCopy: (ev: React.ClipboardEvent<HTMLElement>) => void;
    // (undocumented)
    protected onItemChange: (changedItem: T, index: number) => void;
    // (undocumented)
    protected onSelectionChanged: () => void;
    // (undocumented)
    removeItem: (item: T) => void;
    // (undocumented)
    removeItemAt: (index: number) => void;
    // (undocumented)
    removeItems: (itemsToRemove: any[]) => void;
    // (undocumented)
    removeSelectedItems(): void;
    // (undocumented)
    render(): any;
    // (undocumented)
    protected renderItems: () => JSX.Element[];
    // (undocumented)
    replaceItem: (itemToReplace: T, itemsToReplaceWith: T[]) => void;
    // (undocumented)
    protected root: HTMLElement;
    // (undocumented)
    protected selection: Selection;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: P): void;
    // (undocumented)
    UNSAFE_componentWillUpdate(newProps: P, newState: IBaseSelectedItemsListState): void;
    // (undocumented)
    unselectAll(): void;
    updateItems(items: T[], focusIndex?: number): void;
}

// @public (undocumented)
export enum BaseSlots {
    // (undocumented)
    backgroundColor = 1,
    // (undocumented)
    foregroundColor = 2,
    // (undocumented)
    primaryColor = 0
}

// @public (undocumented)
export const Breadcrumb: React.StatelessComponent<IBreadcrumbProps>;

// @public (undocumented)
export class BreadcrumbBase extends BaseComponent<IBreadcrumbProps, any> {
    constructor(props: IBreadcrumbProps);
    // (undocumented)
    static defaultProps: IBreadcrumbProps;
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export function buildColumns(items: any[], canResizeColumns?: boolean, onColumnClick?: (ev: React.MouseEvent<HTMLElement>, column: IColumn) => void, sortedColumnKey?: string, isSortedDescending?: boolean, groupedColumnKey?: string, isMultiline?: boolean): IColumn[];

// @public @deprecated
export class Button extends BaseComponent<IButtonProps, {}> {
    constructor(props: IButtonProps);
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public (undocumented)
export enum ButtonType {
    // (undocumented)
    command = 4,
    // (undocumented)
    compound = 3,
    // (undocumented)
    default = 6,
    // (undocumented)
    hero = 2,
    // (undocumented)
    icon = 5,
    // (undocumented)
    normal = 0,
    // (undocumented)
    primary = 1
}

// @public (undocumented)
export class Calendar extends BaseComponent<ICalendarProps, ICalendarState> implements ICalendar {
    constructor(props: ICalendarProps);
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    static defaultProps: ICalendarProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: ICalendarProps): void;
}

// Warning: (ae-forgotten-export) The symbol "ICalloutState" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export class Callout extends React.Component<ICalloutProps, ICalloutState> {
    // (undocumented)
    render(): JSX.Element;
}

// @public
export function canAnyMenuItemsCheck(items: IContextualMenuItem[]): boolean;

// @public (undocumented)
export const Check: React.FunctionComponent<ICheckProps>;

// @public (undocumented)
export const CheckBase: React.FunctionComponent<ICheckProps>;

// @public (undocumented)
export const Checkbox: React.StatelessComponent<ICheckboxProps>;

// @public (undocumented)
export class CheckboxBase extends React.Component<ICheckboxProps, ICheckboxState> implements ICheckbox {
    constructor(props: ICheckboxProps, context?: any);
    // (undocumented)
    readonly checked: boolean;
    // (undocumented)
    static defaultProps: ICheckboxProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    static getDerivedStateFromProps(props: ICheckboxProps, state: ICheckboxState): ICheckboxState | null;
    // (undocumented)
    readonly indeterminate: boolean;
    render(): JSX.Element;
}

// @public (undocumented)
export enum CheckboxVisibility {
    always = 1,
    hidden = 2,
    onHover = 0
}

// @public (undocumented)
export const ChoiceGroup: React.StatelessComponent<IChoiceGroupProps>;

// @public (undocumented)
export class ChoiceGroupBase extends React.Component<IChoiceGroupProps, IChoiceGroupState> implements IChoiceGroup {
    constructor(props: IChoiceGroupProps);
    readonly checkedOption: IChoiceGroupOption | undefined;
    // (undocumented)
    componentDidUpdate(prevProps: IChoiceGroupProps, prevState: IChoiceGroupState): void;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const ChoiceGroupOption: React.StatelessComponent<IChoiceGroupOptionProps>;

// @public
export function clamp(value: number, max: number, min?: number): number;

// @public (undocumented)
export const Coachmark: React.StatelessComponent<ICoachmarkProps>;

// @public (undocumented)
export const COACHMARK_ATTRIBUTE_NAME = "data-coachmarkid";

// @public (undocumented)
export class CoachmarkBase extends BaseComponent<ICoachmarkProps, ICoachmarkState> implements ICoachmark {
    constructor(props: ICoachmarkProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: ICoachmarkProps, prevState: ICoachmarkState): void;
    // (undocumented)
    static defaultProps: Partial<ICoachmarkProps>;
    // (undocumented)
    dismiss: (ev?: Event | React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement, MouseEvent> | undefined) => void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    shouldComponentUpdate(newProps: ICoachmarkProps, newState: ICoachmarkState): boolean;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: ICoachmarkProps): void;
}

// @public (undocumented)
export enum CollapseAllVisibility {
    // (undocumented)
    hidden = 0,
    // (undocumented)
    visible = 1
}

// @public (undocumented)
export const ColorPicker: React.StatelessComponent<IColorPickerProps>;

// @public (undocumented)
export class ColorPickerBase extends React.Component<IColorPickerProps, IColorPickerState> implements IColorPicker {
    constructor(props: IColorPickerProps);
    // (undocumented)
    readonly color: IColor;
    // (undocumented)
    static defaultProps: {
        hexLabel: string;
        redLabel: string;
        greenLabel: string;
        blueLabel: string;
        alphaLabel: string;
    };
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IColorPickerProps): void;
    }

// @public (undocumented)
export const ColorPickerGridCell: React.StatelessComponent<IColorPickerGridCellProps>;

// @public (undocumented)
export class ColorPickerGridCellBase extends React.Component<IColorPickerGridCellProps, {}> {
    // (undocumented)
    static defaultProps: IColorPickerGridCellProps;
    // (undocumented)
    render(): JSX.Element;
}

// @public
export enum ColumnActionsMode {
    clickable = 1,
    disabled = 0,
    hasDropdown = 2
}

// @public
export enum ColumnDragEndLocation {
    header = 2,
    outside = 0,
    surface = 1
}

// @public (undocumented)
export class ComboBox extends BaseComponent<IComboBoxProps, IComboBoxState> {
    constructor(props: IComboBoxProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IComboBoxProps, prevState: IComboBoxState): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: IComboBoxProps;
    dismissMenu: () => void;
    // Warning: (ae-unresolved-inheritdoc-base) The @inheritDoc tag needs a TSDoc declaration reference; signature matching is not supported yet
    // 
    // (undocumented)
    focus: (shouldOpenOnFocus?: boolean | undefined, useFocusAsync?: boolean | undefined) => void;
    // (undocumented)
    render(): JSX.Element;
    readonly selectedOptions: IComboBoxOption[];
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IComboBoxProps): void;
}

// @public (undocumented)
export const CommandBar: React.StatelessComponent<ICommandBarProps>;

// @public (undocumented)
export class CommandBarBase extends BaseComponent<ICommandBarProps, {}> implements ICommandBar {
    // (undocumented)
    static defaultProps: ICommandBarProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    remeasure(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export class CommandBarButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public (undocumented)
export const CommandButton: typeof ActionButton;

// @public (undocumented)
export const CompactPeoplePicker: React.FunctionComponent<IPeoplePickerProps>;

// @public
export class CompactPeoplePickerBase extends BasePeoplePicker {
    static defaultProps: {
        onRenderItem: (props: IPeoplePickerItemSelectedProps) => JSX.Element;
        onRenderSuggestionsItem: (personaProps: IPersonaProps, suggestionsProps?: IBasePickerSuggestionsProps<any> | undefined) => JSX.Element;
        createGenericItem: typeof createGenericItem;
    };
}

// @public (undocumented)
export class CompoundButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public (undocumented)
export enum ConstrainMode {
    horizontalConstrained = 1,
    unconstrained = 0
}

// @public
export const ContextualMenu: React.StatelessComponent<IContextualMenuProps>;

// @public (undocumented)
export class ContextualMenuBase extends BaseComponent<IContextualMenuProps, IContextualMenuState> {
    constructor(props: IContextualMenuProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: IContextualMenuProps;
    // (undocumented)
    dismiss: (ev?: any, dismissAll?: boolean | undefined) => void;
    // (undocumented)
    render(): JSX.Element | null;
    // (undocumented)
    shouldComponentUpdate(newProps: IContextualMenuProps, newState: IContextualMenuState): boolean;
    // (undocumented)
    UNSAFE_componentWillMount(): void;
    // (undocumented)
    UNSAFE_componentWillUpdate(newProps: IContextualMenuProps): void;
    }

// @public
export const ContextualMenuItem: React.StatelessComponent<IContextualMenuItemProps>;

// @public (undocumented)
export class ContextualMenuItemBase extends BaseComponent<IContextualMenuItemProps, {}> {
    // (undocumented)
    dismissMenu: (dismissAll?: boolean | undefined) => void;
    // (undocumented)
    dismissSubMenu: () => void;
    // (undocumented)
    openSubMenu: () => void;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export enum ContextualMenuItemType {
    // (undocumented)
    Divider = 1,
    // (undocumented)
    Header = 2,
    // (undocumented)
    Normal = 0,
    // (undocumented)
    Section = 3
}

// @public
export function correctHex(hex: string): string;

// @public
export function correctHSV(color: IHSV): IHSV;

// @public
export function correctRGB(color: IRGB): IRGB;

// @public (undocumented)
export function createGenericItem(name: string, currentValidationState: ValidationState): IGenericItem & {
    key: React.Key;
};

// @public (undocumented)
export function createItem(name: string, isValid: boolean): ISuggestionModel<IPersonaProps>;

// @public
export function cssColor(color?: string): IRGB | undefined;

// @public
export const DatePicker: React.StatelessComponent<IDatePickerProps>;

// @public (undocumented)
export class DatePickerBase extends BaseComponent<IDatePickerProps, IDatePickerState> implements IDatePicker {
    constructor(props: IDatePickerProps);
    // (undocumented)
    componentDidUpdate(prevProps: IDatePickerProps, prevState: IDatePickerState): void;
    // (undocumented)
    static defaultProps: IDatePickerProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    reset(): void;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: IDatePickerProps): void;
    }

// @public
export enum DateRangeType {
    // (undocumented)
    Day = 0,
    // (undocumented)
    Month = 2,
    // (undocumented)
    Week = 1,
    // (undocumented)
    WorkWeek = 3
}

// @public
export enum DayOfWeek {
    // (undocumented)
    Friday = 5,
    // (undocumented)
    Monday = 1,
    // (undocumented)
    Saturday = 6,
    // (undocumented)
    Sunday = 0,
    // (undocumented)
    Thursday = 4,
    // (undocumented)
    Tuesday = 2,
    // (undocumented)
    Wednesday = 3
}

// @public (undocumented)
export const DEFAULT_MASK_CHAR = "_";

// @public (undocumented)
export class DefaultButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public (undocumented)
export type DefaultProps = Required<Pick<ISpinButtonProps, 'step' | 'min' | 'max' | 'disabled' | 'labelPosition' | 'label' | 'incrementButtonIcon' | 'decrementButtonIcon'>>;

// @public
export class DetailsColumnBase extends React.Component<IDetailsColumnProps> {
    constructor(props: IDetailsColumnProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export const DetailsHeader: React.StatelessComponent<IDetailsHeaderBaseProps>;

// @public (undocumented)
export class DetailsHeaderBase extends React.Component<IDetailsHeaderBaseProps, IDetailsHeaderState> implements IDetailsHeader {
    constructor(props: IDetailsHeaderBaseProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IDetailsHeaderBaseProps): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        selectAllVisibility: SelectAllVisibility;
        collapseAllVisibility: CollapseAllVisibility;
        useFastIcons: boolean;
    };
    focus(): boolean;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export const DetailsList: React.StatelessComponent<IDetailsListProps>;

// @public (undocumented)
export class DetailsListBase extends React.Component<IDetailsListProps, IDetailsListState> implements IDetailsList {
    constructor(props: IDetailsListProps);
    // (undocumented)
    componentDidUpdate(prevProps: IDetailsListProps, prevState: IDetailsListState): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        layoutMode: DetailsListLayoutMode;
        selectionMode: SelectionMode;
        constrainMode: ConstrainMode;
        checkboxVisibility: CheckboxVisibility;
        isHeaderVisible: boolean;
        compact: boolean;
        useFastIcons: boolean;
    };
    // (undocumented)
    focusIndex(index: number, forceIntoFirstElement?: boolean, measureItem?: (itemIndex: number) => number, scrollToMode?: ScrollToMode): void;
    // (undocumented)
    forceUpdate(): void;
    // (undocumented)
    getStartItemIndexInView(): number;
    // (undocumented)
    protected _onRenderRow: (props: IDetailsRowProps, defaultRender?: IRenderFunction<IDetailsRowProps> | undefined) => JSX.Element;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    scrollToIndex(index: number, measureItem?: (itemIndex: number) => number, scrollToMode?: ScrollToMode): void;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IDetailsListProps): void;
    // (undocumented)
    UNSAFE_componentWillUpdate(): void;
}

// @public (undocumented)
export enum DetailsListLayoutMode {
    fixedColumns = 0,
    justified = 1
}

// @public (undocumented)
export const DetailsRow: React.StatelessComponent<IDetailsRowBaseProps>;

// @public (undocumented)
export class DetailsRowBase extends React.Component<IDetailsRowBaseProps, IDetailsRowState> {
    constructor(props: IDetailsRowBaseProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(previousProps: IDetailsRowBaseProps): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    focus(forceIntoFirstElement?: boolean): boolean;
    measureCell(index: number, onMeasureDone: (width: number) => void): void;
    // (undocumented)
    protected _onRenderCheck(props: IDetailsRowCheckProps): JSX.Element;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    shouldComponentUpdate(nextProps: IDetailsRowBaseProps, nextState: IDetailsRowState): boolean;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IDetailsRowBaseProps): void;
    }

// @public (undocumented)
export const DetailsRowCheck: React.FunctionComponent<IDetailsRowCheckProps>;

// @public (undocumented)
export const DetailsRowGlobalClassNames: {
    root: string;
    compact: string;
    cell: string;
    cellAnimation: string;
    cellCheck: string;
    check: string;
    cellMeasurer: string;
    listCellFirstChild: string;
    isContentUnselectable: string;
    isSelected: string;
    isCheckVisible: string;
    isRowHeader: string;
    fields: string;
};

// @public (undocumented)
export const Dialog: React.StatelessComponent<IDialogProps>;

// @public (undocumented)
export class DialogBase extends React.Component<IDialogProps, {}> {
    constructor(props: IDialogProps);
    // (undocumented)
    static defaultProps: IDialogProps;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const DialogContent: React.StatelessComponent<IDialogContentProps>;

// @public (undocumented)
export class DialogContentBase extends BaseComponent<IDialogContentProps, {}> {
    constructor(props: IDialogContentProps);
    // (undocumented)
    static defaultProps: IDialogContentProps;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const DialogFooter: React.StatelessComponent<IDialogFooterProps>;

// @public (undocumented)
export class DialogFooterBase extends BaseComponent<IDialogFooterProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export enum DialogType {
    close = 2,
    largeHeader = 1,
    normal = 0
}

// @public (undocumented)
export const DirectionalHint: {
    topLeftEdge: 0;
    topCenter: 1;
    topRightEdge: 2;
    topAutoEdge: 3;
    bottomLeftEdge: 4;
    bottomCenter: 5;
    bottomRightEdge: 6;
    bottomAutoEdge: 7;
    leftTopEdge: 8;
    leftCenter: 9;
    leftBottomEdge: 10;
    rightTopEdge: 11;
    rightCenter: 12;
    rightBottomEdge: 13;
};

// @public (undocumented)
export type DirectionalHint = typeof DirectionalHint[keyof typeof DirectionalHint];

// @public (undocumented)
export const DocumentCard: React.StatelessComponent<IDocumentCardProps>;

// @public (undocumented)
export const DocumentCardActions: React.StatelessComponent<IDocumentCardActionsProps>;

// @public (undocumented)
export const DocumentCardActivity: React.StatelessComponent<IDocumentCardActivityProps>;

// @public (undocumented)
export const DocumentCardDetails: React.StatelessComponent<IDocumentCardDetailsProps>;

// @public (undocumented)
export const DocumentCardImage: React.StatelessComponent<IDocumentCardImageProps>;

// @public (undocumented)
export const DocumentCardLocation: React.StatelessComponent<IDocumentCardLocationProps>;

// @public (undocumented)
export const DocumentCardLogo: React.StatelessComponent<IDocumentCardLogoProps>;

// @public (undocumented)
export const DocumentCardPreview: React.StatelessComponent<IDocumentCardPreviewProps>;

// @public (undocumented)
export const DocumentCardStatus: React.StatelessComponent<IDocumentCardStatusProps>;

// @public (undocumented)
export const DocumentCardTitle: React.StatelessComponent<IDocumentCardTitleProps>;

// @public (undocumented)
export enum DocumentCardType {
    compact = 1,
    normal = 0
}

// @public (undocumented)
export const Dropdown: React.StatelessComponent<IDropdownProps>;

// @public (undocumented)
export class DropdownBase extends React.Component<IDropdownInternalProps, IDropdownState> implements IDropdown {
    constructor(props: IDropdownProps);
    // (undocumented)
    componentDidUpdate(prevProps: IDropdownProps, prevState: IDropdownState): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        options: any[];
    };
    // (undocumented)
    focus(shouldOpenOnFocus?: boolean): void;
    // (undocumented)
    render(): JSX.Element;
    readonly selectedOptions: IDropdownOption[];
    // (undocumented)
    setSelectedIndex(event: React.FormEvent<HTMLDivElement>, index: number): void;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IDropdownProps): void;
}

// @public (undocumented)
export enum ElementType {
    anchor = 1,
    button = 0
}

// @public (undocumented)
export const ExpandingCard: React.StatelessComponent<IExpandingCardProps>;

// @public (undocumented)
export class ExpandingCardBase extends BaseComponent<IExpandingCardProps, IExpandingCardState> {
    constructor(props: IExpandingCardProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        compactCardHeight: number;
        expandedCardHeight: number;
        directionalHintFixed: boolean;
    };
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export enum ExpandingCardMode {
    compact = 0,
    expanded = 1
}

// @public (undocumented)
export class ExtendedPeoplePicker extends BaseExtendedPeoplePicker {
}

// @public (undocumented)
export class ExtendedSelectedItem extends BaseComponent<ISelectedPeopleItemProps, IPeoplePickerItemState> {
    constructor(props: ISelectedPeopleItemProps);
    // (undocumented)
    protected persona: React.RefObject<HTMLDivElement>;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const Fabric: React.StatelessComponent<IFabricProps>;

// @public (undocumented)
export class FabricBase extends React.Component<IFabricProps, {
    isFocusVisible: boolean;
}> {
    constructor(props: IFabricProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export enum FabricSlots {
    // (undocumented)
    black = 20,
    // (undocumented)
    neutralDark = 19,
    // (undocumented)
    neutralLight = 11,
    // (undocumented)
    neutralLighter = 10,
    // (undocumented)
    neutralLighterAlt = 9,
    // (undocumented)
    neutralPrimary = 18,
    // (undocumented)
    neutralPrimaryAlt = 17,
    // (undocumented)
    neutralQuaternary = 13,
    // (undocumented)
    neutralQuaternaryAlt = 12,
    // (undocumented)
    neutralSecondary = 16,
    // (undocumented)
    neutralTertiary = 15,
    // (undocumented)
    neutralTertiaryAlt = 14,
    // (undocumented)
    themeDark = 7,
    // (undocumented)
    themeDarkAlt = 6,
    // (undocumented)
    themeDarker = 8,
    // (undocumented)
    themeLight = 3,
    // (undocumented)
    themeLighter = 2,
    // (undocumented)
    themeLighterAlt = 1,
    // (undocumented)
    themePrimary = 0,
    // (undocumented)
    themeSecondary = 5,
    // (undocumented)
    themeTertiary = 4,
    // (undocumented)
    white = 21
}

// @public
export const Facepile: React.StatelessComponent<IFacepileProps>;

// @public
export class FacepileBase extends BaseComponent<IFacepileProps, {}> {
    constructor(props: IFacepileProps);
    // (undocumented)
    static defaultProps: IFacepileProps;
    // (undocumented)
    protected onRenderAriaDescription(): "" | JSX.Element | undefined;
    // (undocumented)
    render(): JSX.Element;
    }

// @public
export enum FirstWeekOfYear {
    // (undocumented)
    FirstDay = 0,
    // (undocumented)
    FirstFourDayWeek = 2,
    // (undocumented)
    FirstFullWeek = 1
}

// @public (undocumented)
export class FloatingPeoplePicker extends BaseFloatingPeoplePicker {
    // (undocumented)
    static defaultProps: any;
}

// @public
export const FocusTrapCallout: React.StatelessComponent<IFocusTrapCalloutProps>;

// @public (undocumented)
export class FocusTrapZone extends React.Component<IFocusTrapZoneProps, {}> implements IFocusTrapZone {
    constructor(props: IFocusTrapZoneProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IFocusTrapZoneProps): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: IFocusTrapZoneProps): void;
    }

// @public (undocumented)
export class FocusZone extends React.Component<IFocusZoneProps> implements IFocusZone {
    constructor(props: IFocusZoneProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: IFocusZoneProps;
    focus(forceIntoFirstElement?: boolean): boolean;
    focusElement(element: HTMLElement): boolean;
    static getOuterZones(): number;
    // (undocumented)
    render(): JSX.Element;
    setFocusAlignment(point: IPoint): void;
    }

// @public (undocumented)
export enum FocusZoneDirection {
    bidirectional = 2,
    horizontal = 1,
    vertical = 0
}

// @public (undocumented)
export const FocusZoneTabbableElements: {
    none: 0;
    all: 1;
    inputOnly: 2;
};

// @public (undocumented)
export type FocusZoneTabbableElements = typeof FocusZoneTabbableElements[keyof typeof FocusZoneTabbableElements];

// @public
export const FontIcon: React.FunctionComponent<IFontIconProps>;

// @public (undocumented)
export function getAllSelectedOptions(options: ISelectableOption[], selectedIndices: number[]): ISelectableOption[];

// @public (undocumented)
export function getBackgroundShade(color: IColor, shade: Shade, isInverted?: boolean): IColor | null;

// @public
export const getCheck: (theme?: ITheme | undefined, checked?: boolean | undefined, className?: string | undefined) => JSX.Element;

// @public
export function getColorFromHSV(hsv: IHSV, a?: number): IColor;

// @public
export function getColorFromRGBA(rgba: IRGB): IColor;

// @public
export function getColorFromString(inputColor: string): IColor | undefined;

// @public (undocumented)
export function getContrastRatio(color1: IColor, color2: IColor): number;

// @public
export const getFontIcon: (iconName: string, className?: string | undefined, ariaLabel?: string | undefined) => React.ReactElement<any, string | ((props: any) => React.ReactElement<any, string | any | (new (props: any) => React.Component<any, any, any>)> | null) | (new (props: any) => React.Component<any, any, any>)> | null;

// @public
export function getFullColorString(color: IColor): string;

// @public (undocumented)
export const getIconContent: (iconName?: string | undefined) => {
    children: string | undefined;
    iconClassName: string | undefined;
};

// @public
export const getMeasurementCache: () => {
    getCachedMeasurement: (data: any) => number | undefined;
    addMeasurementToCache: (data: any, measurement: number) => void;
};

// @public
export const getNextResizeGroupStateProvider: (measurementCache?: {
    getCachedMeasurement: (data: any) => number | undefined;
    addMeasurementToCache: (data: any, measurement: number) => void;
}) => {
    getNextState: (props: IResizeGroupProps, currentState: IResizeGroupState, getElementToMeasureDimension: () => number, newContainerDimension?: number | undefined) => IResizeGroupState | undefined;
    shouldRenderDataForMeasurement: (dataToMeasure: any) => boolean;
    getInitialResizeGroupState: (data: any) => IResizeGroupState;
};

// @public
export function getPersonaInitialsColor(props: Pick<IPersonaProps, 'primaryText' | 'text' | 'initialsColor'>): string;

// @public
export function getShade(color: IColor, shade: Shade, isInverted?: boolean): IColor | null;

// @public (undocumented)
export function getSubmenuItems(item: IContextualMenuItem): IContextualMenuItem[] | undefined;

// @public (undocumented)
export const Grid: React.StatelessComponent<IGridProps>;

// @public (undocumented)
export class GridCell<T, P extends IGridCellProps<T>> extends React.Component<P, {}> {
    // (undocumented)
    static defaultProps: {
        disabled: boolean;
        id: string;
    };
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const GroupedList: React.StatelessComponent<IGroupedListProps>;

// @public (undocumented)
export class GroupedListBase extends React.Component<IGroupedListProps, IGroupedListState> implements IGroupedList {
    constructor(props: IGroupedListProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    static defaultProps: {
        selectionMode: SelectionMode;
        isHeaderVisible: boolean;
        groupProps: {};
        compact: boolean;
    };
    // (undocumented)
    forceUpdate(): void;
    // (undocumented)
    getStartItemIndexInView(): number;
    // (undocumented)
    refs: {
        [key: string]: React.ReactInstance;
    };
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    scrollToIndex(index: number, measureItem?: (itemIndex: number) => number, scrollToMode?: ScrollToMode): void;
    // (undocumented)
    toggleCollapseAll(allCollapsed: boolean): void;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IGroupedListProps): void;
    }

// @public (undocumented)
export const GroupFooter: React.StatelessComponent<IGroupFooterProps>;

// @public (undocumented)
export const GroupHeader: React.StatelessComponent<IGroupHeaderProps>;

// @public (undocumented)
export const groupOne: IExtendedPersonaProps[];

// @public (undocumented)
export const GroupShowAll: React.StatelessComponent<IGroupShowAllProps>;

// @public (undocumented)
export const GroupSpacer: React.FunctionComponent<IGroupSpacerProps>;

// @public (undocumented)
export const groupTwo: IExtendedPersonaProps[];

// @public
export const HEX_REGEX: RegExp;

// @public (undocumented)
export const HoverCard: React.StatelessComponent<IHoverCardProps>;

// @public (undocumented)
export class HoverCardBase extends BaseComponent<IHoverCardProps, IHoverCardState> implements IHoverCard {
    constructor(props: IHoverCardProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IHoverCardProps, prevState: IHoverCardState): void;
    // (undocumented)
    static defaultProps: {
        cardOpenDelay: number;
        cardDismissDelay: number;
        expandedCardOpenDelay: number;
        instantOpenOnClick: boolean;
        setInitialFocus: boolean;
        openHotKey: number;
        type: HoverCardType;
    };
    // (undocumented)
    dismiss: (withTimeOut?: boolean | undefined) => void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export enum HoverCardType {
    expanding = "ExpandingCard",
    plain = "PlainCard"
}

// @public
export function hsl2hsv(h: number, s: number, l: number): IHSV;

// @public
export function hsl2rgb(h: number, s: number, l: number): IRGB;

// @public
export function hsv2hex(h: number, s: number, v: number): string;

// @public
export function hsv2hsl(h: number, s: number, v: number): IHSL;

// @public
export function hsv2rgb(h: number, s: number, v: number): IRGB;

// @public (undocumented)
export interface IActivityItemProps extends React.AllHTMLAttributes<HTMLElement> {
    activityDescription?: React.ReactNode[] | React.ReactNode;
    // @deprecated
    activityDescriptionText?: string;
    activityIcon?: React.ReactNode;
    activityPersonas?: Array<IPersonaSharedProps>;
    animateBeaconSignal?: boolean;
    beaconColorOne?: string;
    beaconColorTwo?: string;
    comments?: React.ReactNode[] | React.ReactNode;
    // @deprecated
    commentText?: string;
    isCompact?: boolean;
    onRenderActivityDescription?: IRenderFunction<IActivityItemProps>;
    onRenderComments?: IRenderFunction<IActivityItemProps>;
    onRenderIcon?: IRenderFunction<IActivityItemProps>;
    onRenderTimeStamp?: IRenderFunction<IActivityItemProps>;
    styles?: IActivityItemStyles;
    timeStamp?: string | React.ReactNode[] | React.ReactNode;
}

// @public (undocumented)
export interface IActivityItemStyles {
    activityContent?: IStyle;
    activityPersona?: IStyle;
    activityText?: IStyle;
    activityTypeIcon?: IStyle;
    commentText?: IStyle;
    doublePersona?: IStyle;
    isCompactContent?: IStyle;
    isCompactIcon?: IStyle;
    isCompactPersona?: IStyle;
    isCompactPersonaContainer?: IStyle;
    isCompactRoot?: IStyle;
    isCompactTimeStamp?: IStyle;
    personaContainer?: IStyle;
    pulsingBeacon?: IStyle;
    root?: IStyle;
    timeStamp?: IStyle;
}

// @public (undocumented)
export interface IAnnouncedProps extends React.Props<AnnouncedBase>, React.HTMLAttributes<HTMLDivElement> {
    message?: string;
    styles?: IStyleFunctionOrObject<{}, IAnnouncedStyles>;
}

// @public (undocumented)
export interface IAnnouncedStyles {
    screenReaderText: IStyle;
}

// @public (undocumented)
export interface IAutofill {
    clear(): void;
    cursorLocation: number | null;
    focus(): void;
    inputElement: HTMLInputElement | null;
    isValueSelected: boolean;
    selectionEnd: number | null;
    selectionStart: number | null;
    value: string;
}

// @public (undocumented)
export interface IAutofillProps extends React.InputHTMLAttributes<HTMLInputElement | Autofill> {
    componentRef?: IRefObject<IAutofill>;
    defaultVisibleValue?: string;
    enableAutofillOnKeyPress?: KeyCodes[];
    onInputChange?: (value: string) => string;
    onInputValueChange?: (newValue?: string) => void;
    preventValueSelection?: boolean;
    shouldSelectFullInputValueInComponentDidUpdate?: () => boolean;
    suggestedDisplayValue?: string;
    updateValueInWillReceiveProps?: () => string | null;
}

// @public (undocumented)
export interface IAutofillState {
    // (undocumented)
    displayValue?: string;
}

// @public @deprecated
export interface IBaseAutoFill extends IAutofill {
}

// @public @deprecated
export interface IBaseAutoFillProps extends IAutofillProps {
}

// @public (undocumented)
export interface IBaseButtonProps extends IButtonProps {
    // (undocumented)
    baseClassName?: string;
    // (undocumented)
    variantClassName?: string;
}

// @public (undocumented)
export interface IBaseButtonState {
    // (undocumented)
    menuProps?: IContextualMenuProps | null;
}

// @public (undocumented)
export interface IBaseExtendedPicker<T> {
    focus: () => void;
    forceResolve?: () => void;
    items: T[] | undefined;
}

// @public (undocumented)
export interface IBaseExtendedPickerProps<T> {
    className?: string;
    componentRef?: IRefObject<IBaseExtendedPicker<T>>;
    currentRenderedQueryString?: string;
    defaultSelectedItems?: T[];
    disabled?: boolean;
    floatingPickerProps: IBaseFloatingPickerProps<T>;
    focusZoneProps?: IFocusZoneProps;
    headerComponent?: JSX.Element;
    inputProps?: IInputProps;
    itemLimit?: number;
    onBlur?: React.FocusEventHandler<HTMLInputElement | Autofill>;
    onChange?: (items?: T[]) => void;
    onFocus?: React.FocusEventHandler<HTMLInputElement | Autofill>;
    onItemAdded?: (addedItem: T) => void;
    onItemSelected?: (selectedItem?: T) => T | PromiseLike<T>;
    onItemsRemoved?: (removedItems: T[]) => void;
    onPaste?: (pastedText: string) => T[];
    onRenderFloatingPicker: React.ComponentType<IBaseFloatingPickerProps<T>>;
    onRenderSelectedItems: React.ComponentType<IBaseSelectedItemsListProps<T>>;
    selectedItems?: T[];
    selectedItemsListProps: IBaseSelectedItemsListProps<T>;
    suggestionItems?: T[];
}

// @public (undocumented)
export interface IBaseExtendedPickerState<T> {
    // (undocumented)
    queryString: string | null;
    // (undocumented)
    selectedItems: T[] | null;
    // (undocumented)
    suggestionItems: T[] | null;
}

// @public (undocumented)
export interface IBaseFloatingPicker {
    hidePicker: () => void;
    inputText: string;
    isSuggestionsShown: boolean;
    onQueryStringChanged: (input: string) => void;
    showPicker: (updateValue?: boolean) => void;
    suggestions: any[];
}

// @public (undocumented)
export interface IBaseFloatingPickerProps<T> extends React.ClassAttributes<any> {
    calloutWidth?: number;
    className?: string;
    // (undocumented)
    componentRef?: IRefObject<IBaseFloatingPicker>;
    createGenericItem?: (input: string, isValid: boolean) => ISuggestionModel<T>;
    getTextFromItem?: (item: T, currentValue?: string) => string;
    inputElement?: HTMLInputElement | null;
    onChange?: (item: T) => void;
    onInputChanged?: (filter: string) => void;
    onRemoveSuggestion?: (item: T) => void;
    onRenderSuggestionsItem?: (props: T, itemProps: ISuggestionItemProps<T>) => JSX.Element;
    onResolveSuggestions: (filter: string, selectedItems?: T[]) => T[] | PromiseLike<T[]> | null;
    onSuggestionsHidden?: () => void;
    onSuggestionsShown?: () => void;
    onValidateInput?: (input: string) => boolean;
    onZeroQuerySuggestion?: (selectedItems?: T[]) => T[] | PromiseLike<T[]> | null;
    pickerSuggestionsProps?: IBaseFloatingPickerSuggestionProps;
    resolveDelay?: number;
    searchingText?: ((props: {
        input: string;
    }) => string) | string;
    selectedItems?: T[];
    showForceResolve?: () => boolean;
    suggestionItems?: T[];
    suggestionsStore: SuggestionsStore<T>;
}

// @public (undocumented)
export interface IBaseFloatingPickerState {
    // (undocumented)
    didBind: boolean;
    // (undocumented)
    queryString: string;
    // (undocumented)
    suggestionsVisible?: boolean;
}

// @public
export type IBaseFloatingPickerSuggestionProps = Pick<ISuggestionsControlProps<any>, 'shouldSelectFirstItem' | 'headerItemsProps' | 'footerItemsProps' | 'showRemoveButtons'>;

// @public
export interface IBasePicker<T> {
    focus: () => void;
    focusInput: () => void;
    items: T[] | undefined;
}

// @public
export interface IBasePickerProps<T> extends React.Props<any> {
    className?: string;
    componentRef?: IRefObject<IBasePicker<T>>;
    createGenericItem?: (input: string, ValidationState: ValidationState) => ISuggestionModel<T> | T;
    defaultSelectedItems?: T[];
    disabled?: boolean;
    enableSelectedSuggestionAlert?: boolean;
    getTextFromItem?: (item: T, currentValue?: string) => string;
    inputProps?: IInputProps;
    itemLimit?: number;
    onBlur?: React.FocusEventHandler<HTMLInputElement | BaseAutoFill>;
    onChange?: (items?: T[]) => void;
    onDismiss?: (ev?: any, selectedItem?: T) => void;
    // @deprecated
    onEmptyInputFocus?: (selectedItems?: T[]) => T[] | PromiseLike<T[]>;
    onEmptyResolveSuggestions?: (selectedItems?: T[]) => T[] | PromiseLike<T[]>;
    onFocus?: React.FocusEventHandler<HTMLInputElement | BaseAutoFill>;
    onGetMoreResults?: (filter: string, selectedItems?: T[]) => T[] | PromiseLike<T[]>;
    onInputChange?: (input: string) => string;
    onItemSelected?: (selectedItem?: T) => T | PromiseLike<T> | null;
    onRemoveSuggestion?: (item: T) => void;
    onRenderItem?: (props: IPickerItemProps<T>) => JSX.Element;
    onRenderSuggestionsItem?: (props: T, itemProps: ISuggestionItemProps<T>) => JSX.Element;
    onResolveSuggestions: (filter: string, selectedItems?: T[]) => T[] | PromiseLike<T[]>;
    onValidateInput?: (input: string) => ValidationState;
    pickerCalloutProps?: ICalloutProps;
    pickerSuggestionsProps?: IBasePickerSuggestionsProps;
    removeButtonAriaLabel?: string;
    resolveDelay?: number;
    searchingText?: ((props: {
        input: string;
    }) => string) | string;
    selectedItems?: T[];
    styles?: IStyleFunctionOrObject<IBasePickerStyleProps, IBasePickerStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IBasePickerState {
    // (undocumented)
    isFocused?: boolean;
    // (undocumented)
    isMostRecentlyUsedVisible?: boolean;
    // (undocumented)
    isResultsFooterVisible?: boolean;
    // (undocumented)
    isSearching?: boolean;
    // (undocumented)
    items?: any;
    // (undocumented)
    moreSuggestionsAvailable?: boolean;
    // (undocumented)
    selectedIndices?: number[];
    // (undocumented)
    suggestedDisplayValue?: string;
    // (undocumented)
    suggestionsLoading?: boolean;
    // (undocumented)
    suggestionsVisible?: boolean;
}

// @public
export type IBasePickerStyleProps = Pick<IBasePickerProps<any>, 'theme' | 'className' | 'disabled'> & {
    isFocused?: boolean;
    inputClassName?: string;
};

// @public
export interface IBasePickerStyles {
    input: IStyle;
    itemsWrapper: IStyle;
    root: IStyle;
    screenReaderText: IStyle;
    text: IStyle;
}

// @public
export interface IBasePickerSuggestionsProps<T = any> extends Pick<ISuggestionsProps<T>, 'onRenderNoResultFound' | 'suggestionsHeaderText' | 'mostRecentlyUsedHeaderText' | 'noResultsFoundText' | 'className' | 'suggestionsClassName' | 'suggestionsItemClassName' | 'searchForMoreText' | 'forceResolveText' | 'loadingText' | 'searchingText' | 'resultsFooterFull' | 'resultsFooter' | 'resultsMaximumNumber' | 'showRemoveButtons' | 'suggestionsAvailableAlertText' | 'suggestionsContainerAriaLabel'> {
}

// @public (undocumented)
export interface IBaseSelectedItemsList<T> {
    // (undocumented)
    addItems: (items: T[]) => void;
    items: T[] | undefined;
}

// @public (undocumented)
export interface IBaseSelectedItemsListProps<T> extends React.ClassAttributes<any> {
    canRemoveItem?: (item: T) => boolean;
    // (undocumented)
    componentRef?: IRefObject<IBaseSelectedItemsList<T>>;
    createGenericItem?: (input: string, ValidationState: ValidationState) => ISuggestionModel<T>;
    defaultSelectedItems?: T[];
    onChange?: (items?: T[]) => void;
    onCopyItems?: (items: T[]) => string;
    // @deprecated
    onItemDeleted?: (deletedItem: T) => void;
    onItemsDeleted?: (deletedItems: T[]) => void;
    onItemSelected?: (selectedItem?: T) => T | PromiseLike<T>;
    onRenderItem?: (props: ISelectedItemProps<T>) => JSX.Element;
    removeButtonAriaLabel?: string;
    selectedItems?: T[];
    selection?: Selection;
}

// @public (undocumented)
export interface IBaseSelectedItemsListState<T = any> {
    // (undocumented)
    items: T[];
}

// @public (undocumented)
export interface IBreadcrumb {
    focus(): void;
}

// @public @deprecated (undocumented)
export type IBreadCrumbData = IBreadcrumbData;

// @public (undocumented)
export interface IBreadcrumbData {
    // (undocumented)
    props: IBreadcrumbProps;
    // (undocumented)
    renderedItems: IBreadcrumbItem[];
    // (undocumented)
    renderedOverflowItems: IBreadcrumbItem[];
}

// @public (undocumented)
export interface IBreadcrumbItem {
    href?: string;
    isCurrentItem?: boolean;
    key: string;
    onClick?: (ev?: React.MouseEvent<HTMLElement>, item?: IBreadcrumbItem) => void;
    text: string;
}

// @public (undocumented)
export interface IBreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
    ariaLabel?: string;
    className?: string;
    componentRef?: IRefObject<IBreadcrumb>;
    dividerAs?: IComponentAs<IDividerAsProps>;
    focusZoneProps?: IFocusZoneProps;
    items: IBreadcrumbItem[];
    maxDisplayedItems?: number;
    onReduceData?: (data: IBreadcrumbData) => IBreadcrumbData | undefined;
    onRenderItem?: IRenderFunction<IBreadcrumbItem>;
    overflowAriaLabel?: string;
    overflowIndex?: number;
    // (undocumented)
    styles?: IStyleFunctionOrObject<IBreadcrumbStyleProps, IBreadcrumbStyles>;
    // (undocumented)
    theme?: ITheme;
    tooltipHostProps?: ITooltipHostProps;
}

// @public (undocumented)
export interface IBreadcrumbStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface IBreadcrumbStyles {
    // (undocumented)
    chevron: IStyle;
    // (undocumented)
    item: IStyle;
    // (undocumented)
    itemLink: IStyle;
    // (undocumented)
    list: IStyle;
    // (undocumented)
    listItem: IStyle;
    // (undocumented)
    overflow: IStyle;
    // (undocumented)
    overflowButton: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IButton {
    dismissMenu: () => void;
    focus: () => void;
    openMenu: (shouldFocusOnContainer?: boolean, shouldFocusOnMount?: boolean) => void;
}

// @public (undocumented)
export interface IButtonProps extends React.AllHTMLAttributes<HTMLAnchorElement | HTMLButtonElement | HTMLDivElement | BaseButton | Button | HTMLSpanElement> {
    allowDisabledFocus?: boolean;
    ariaDescription?: string;
    ariaHidden?: boolean;
    ariaLabel?: string;
    // @deprecated
    buttonType?: ButtonType;
    checked?: boolean;
    className?: string;
    componentRef?: IRefObject<IButton>;
    data?: any;
    defaultRender?: any;
    // @deprecated
    description?: IStyle;
    disabled?: boolean;
    // Warning: (ae-forgotten-export) The symbol "IButtonClassNames" needs to be exported by the entry point index.d.ts
    getClassNames?: (theme: ITheme, className: string, variantClassName: string, iconClassName: string | undefined, menuIconClassName: string | undefined, disabled: boolean, checked: boolean, expanded: boolean, isSplit: boolean | undefined, allowDisabledFocus: boolean) => IButtonClassNames;
    // Warning: (ae-forgotten-export) The symbol "ISplitButtonClassNames" needs to be exported by the entry point index.d.ts
    getSplitButtonClassNames?: (disabled: boolean, expanded: boolean, checked: boolean, allowDisabledFocus: boolean) => ISplitButtonClassNames;
    href?: string;
    iconProps?: IIconProps;
    keytipProps?: IKeytipProps;
    menuAs?: IComponentAs<IContextualMenuProps>;
    menuIconProps?: IIconProps;
    menuProps?: IContextualMenuProps;
    menuTriggerKeyCode?: KeyCodes | null;
    onAfterMenuDismiss?: () => void;
    onMenuClick?: (ev?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>, button?: IButtonProps) => void;
    onRenderAriaDescription?: IRenderFunction<IButtonProps>;
    onRenderChildren?: IRenderFunction<IButtonProps>;
    onRenderDescription?: IRenderFunction<IButtonProps>;
    onRenderIcon?: IRenderFunction<IButtonProps>;
    // @deprecated
    onRenderMenu?: IRenderFunction<IContextualMenuProps>;
    onRenderMenuIcon?: IRenderFunction<IButtonProps>;
    onRenderText?: IRenderFunction<IButtonProps>;
    persistMenu?: boolean;
    primary?: boolean;
    primaryActionButtonProps?: IButtonProps;
    primaryDisabled?: boolean;
    // @deprecated
    rootProps?: React.ButtonHTMLAttributes<HTMLButtonElement> | React.AnchorHTMLAttributes<HTMLAnchorElement>;
    secondaryText?: string;
    split?: boolean;
    splitButtonAriaLabel?: string;
    splitButtonMenuProps?: IButtonProps;
    styles?: IButtonStyles;
    text?: string;
    theme?: ITheme;
    toggle?: boolean;
    // @deprecated
    toggled?: boolean;
    uniqueId?: string | number;
}

// @public (undocumented)
export interface IButtonStyles {
    description?: IStyle;
    descriptionChecked?: IStyle;
    descriptionDisabled?: IStyle;
    descriptionHovered?: IStyle;
    descriptionPressed?: IStyle;
    flexContainer?: IStyle;
    icon?: IStyle;
    iconChecked?: IStyle;
    iconDisabled?: IStyle;
    iconExpanded?: IStyle;
    iconExpandedHovered?: IStyle;
    iconHovered?: IStyle;
    iconPressed?: IStyle;
    label?: IStyle;
    labelChecked?: IStyle;
    labelDisabled?: IStyle;
    labelHovered?: IStyle;
    menuIcon?: IStyle;
    menuIconChecked?: IStyle;
    menuIconDisabled?: IStyle;
    menuIconExpanded?: IStyle;
    menuIconExpandedHovered?: IStyle;
    menuIconHovered?: IStyle;
    menuIconPressed?: IStyle;
    root?: IStyle;
    rootChecked?: IStyle;
    rootCheckedDisabled?: IStyle;
    rootCheckedHovered?: IStyle;
    rootCheckedPressed?: IStyle;
    rootDisabled?: IStyle;
    rootExpanded?: IStyle;
    rootExpandedHovered?: IStyle;
    rootFocused?: IStyle;
    rootHovered?: IStyle;
    rootPressed?: IStyle;
    screenReaderText?: IStyle;
    secondaryText?: IStyle;
    splitButtonContainer?: IStyle;
    splitButtonContainerChecked?: IStyle;
    splitButtonContainerCheckedHovered?: IStyle;
    splitButtonContainerDisabled?: IStyle;
    splitButtonContainerFocused?: IStyle;
    splitButtonContainerHovered?: IStyle;
    splitButtonDivider?: IStyle;
    splitButtonDividerDisabled?: IStyle;
    splitButtonFlexContainer?: IStyle;
    splitButtonMenuButton?: IStyle;
    splitButtonMenuButtonChecked?: IStyle;
    splitButtonMenuButtonDisabled?: IStyle;
    splitButtonMenuButtonExpanded?: IStyle;
    splitButtonMenuIcon?: IStyle;
    splitButtonMenuIconDisabled?: IStyle;
    textContainer?: IStyle;
}

// @public (undocumented)
export interface ICalendar {
    focus: () => void;
}

// @public (undocumented)
export interface ICalendarFormatDateCallbacks {
    formatDay: (date: Date) => string;
    formatMonthDayYear: (date: Date, strings?: ICalendarStrings) => string;
    formatMonthYear: (date: Date, strings?: ICalendarStrings) => string;
    formatYear: (date: Date) => string;
}

// @public (undocumented)
export interface ICalendarIconStrings {
    closeIcon?: string;
    leftNavigation?: string;
    rightNavigation?: string;
}

// @public (undocumented)
export interface ICalendarProps extends IBaseProps<ICalendar>, React.HTMLAttributes<HTMLElement> {
    allFocusable?: boolean;
    autoNavigateOnSelection?: boolean;
    className?: string;
    componentRef?: IRefObject<ICalendar>;
    dateRangeType?: DateRangeType;
    dateTimeFormatter?: ICalendarFormatDateCallbacks;
    firstDayOfWeek?: DayOfWeek;
    firstWeekOfYear?: FirstWeekOfYear;
    highlightCurrentMonth?: boolean;
    highlightSelectedMonth?: boolean;
    isDayPickerVisible?: boolean;
    isMonthPickerVisible?: boolean;
    maxDate?: Date;
    minDate?: Date;
    navigationIcons?: ICalendarIconStrings;
    onDismiss?: () => void;
    onSelectDate?: (date: Date, selectedDateRangeArray?: Date[]) => void;
    restrictedDates?: Date[];
    selectDateOnClick?: boolean;
    // @deprecated
    shouldFocusOnMount?: boolean;
    showCloseButton?: boolean;
    showGoToToday?: boolean;
    showMonthPickerAsOverlay?: boolean;
    showSixWeeksByDefault?: boolean;
    showWeekNumbers?: boolean;
    strings: ICalendarStrings | null;
    today?: Date;
    value?: Date;
    workWeekDays?: DayOfWeek[];
    yearPickerHidden?: boolean;
}

// @public (undocumented)
export interface ICalendarState {
    isDayPickerVisible?: boolean;
    isMonthPickerVisible?: boolean;
    navigatedDayDate?: Date;
    navigatedMonthDate?: Date;
    selectedDate?: Date;
}

// @public (undocumented)
export interface ICalendarStrings {
    closeButtonAriaLabel?: string;
    days: string[];
    goToToday: string;
    months: string[];
    nextMonthAriaLabel?: string;
    nextYearAriaLabel?: string;
    nextYearRangeAriaLabel?: string;
    prevMonthAriaLabel?: string;
    prevYearAriaLabel?: string;
    prevYearRangeAriaLabel?: string;
    shortDays: string[];
    shortMonths: string[];
    weekNumberFormatString?: string;
}

// @public (undocumented)
export interface ICalloutContentStyleProps {
    backgroundColor?: string;
    beakWidth?: number;
    calloutMaxWidth?: number;
    calloutWidth?: number;
    className?: string;
    overflowYHidden?: boolean;
    // Warning: (ae-forgotten-export) The symbol "ICalloutPositionedInfo" needs to be exported by the entry point index.d.ts
    positions?: ICalloutPositionedInfo;
    theme: ITheme;
}

// @public (undocumented)
export interface ICalloutContentStyles {
    beak: IStyle;
    beakCurtain: IStyle;
    calloutMain: IStyle;
    container: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface ICalloutProps extends React.HTMLAttributes<HTMLDivElement> {
    alignTargetEdge?: boolean;
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    backgroundColor?: string;
    beakWidth?: number;
    bounds?: IRectangle;
    calloutMaxHeight?: number;
    calloutMaxWidth?: number;
    calloutWidth?: number;
    className?: string;
    coverTarget?: boolean;
    directionalHint?: DirectionalHint;
    directionalHintFixed?: boolean;
    directionalHintForRTL?: DirectionalHint;
    doNotLayer?: boolean;
    finalHeight?: number;
    gapSpace?: number;
    hidden?: boolean;
    hideOverflow?: boolean;
    isBeakVisible?: boolean;
    layerProps?: ILayerProps;
    minPagePadding?: number;
    onDismiss?: (ev?: any) => void;
    onLayerMounted?: () => void;
    onPositioned?: (positions?: ICalloutPositionedInfo) => void;
    onScroll?: () => void;
    preventDismissOnLostFocus?: boolean;
    preventDismissOnResize?: boolean;
    preventDismissOnScroll?: boolean;
    role?: string;
    setInitialFocus?: boolean;
    shouldRestoreFocus?: boolean;
    style?: React.CSSProperties;
    styles?: IStyleFunctionOrObject<ICalloutContentStyleProps, ICalloutContentStyles>;
    target?: Target;
    theme?: ITheme;
}

// @public (undocumented)
export interface ICellStyleProps {
    // (undocumented)
    cellExtraRightPadding: number;
    // (undocumented)
    cellLeftPadding: number;
    // (undocumented)
    cellRightPadding: number;
}

// @public
export interface ICheckbox {
    checked: boolean;
    focus: () => void;
    indeterminate: boolean;
}

// @public
export interface ICheckboxProps extends React.ButtonHTMLAttributes<HTMLElement | HTMLInputElement> {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    ariaPositionInSet?: number;
    ariaSetSize?: number;
    boxSide?: 'start' | 'end';
    checked?: boolean;
    checkmarkIconProps?: IIconProps;
    className?: string;
    componentRef?: IRefObject<ICheckbox>;
    defaultChecked?: boolean;
    defaultIndeterminate?: boolean;
    disabled?: boolean;
    indeterminate?: boolean;
    inputProps?: React.ButtonHTMLAttributes<HTMLElement | HTMLButtonElement>;
    keytipProps?: IKeytipProps;
    label?: string;
    onChange?: (ev?: React.FormEvent<HTMLElement | HTMLInputElement>, checked?: boolean) => void;
    onRenderLabel?: IRenderFunction<ICheckboxProps>;
    styles?: IStyleFunctionOrObject<ICheckboxStyleProps, ICheckboxStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface ICheckboxState {
    isChecked?: boolean | undefined;
    // (undocumented)
    isIndeterminate?: boolean;
}

// @public (undocumented)
export interface ICheckboxStyleProps {
    // (undocumented)
    checked?: boolean;
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    indeterminate?: boolean;
    // (undocumented)
    isUsingCustomLabelRender: boolean;
    // (undocumented)
    reversed?: boolean;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface ICheckboxStyles {
    checkbox?: IStyle;
    checkmark?: IStyle;
    input?: IStyle;
    label?: IStyle;
    root?: IStyle;
    text?: IStyle;
}

// @public (undocumented)
export interface ICheckProps {
    // @deprecated (undocumented)
    alwaysShowCheck?: boolean;
    checked?: boolean;
    className?: string;
    componentRef?: IRefObject<ICheckProps>;
    styles?: IStyleFunctionOrObject<ICheckStyleProps, ICheckStyles>;
    theme?: ITheme;
    useFastIcons?: boolean;
}

// @public (undocumented)
export type ICheckStyleProps = Required<Pick<ICheckProps, 'theme'>> & Pick<ICheckProps, 'className' | 'checked'> & {
    height?: string;
    checkBoxHeight?: string;
};

// @public (undocumented)
export interface ICheckStyles {
    check: IStyle;
    // @deprecated
    checkHost: IStyle;
    circle: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface IChoiceGroup {
    checkedOption: IChoiceGroupOption | undefined;
    focus: () => void;
}

// @public (undocumented)
export interface IChoiceGroupOption extends React.InputHTMLAttributes<HTMLElement | HTMLInputElement> {
    ariaLabel?: string;
    // @deprecated
    checked?: boolean;
    disabled?: boolean;
    iconProps?: IIconProps;
    id?: string;
    imageAlt?: string;
    imageSize?: {
        width: number;
        height: number;
    };
    imageSrc?: string;
    key: string;
    labelId?: string;
    onRenderField?: IRenderFunction<IChoiceGroupOption>;
    onRenderLabel?: (option: IChoiceGroupOption) => JSX.Element;
    selectedImageSrc?: string;
    styles?: IStyleFunctionOrObject<IChoiceGroupOptionStyleProps, IChoiceGroupOptionStyles>;
    text: string;
}

// @public (undocumented)
export interface IChoiceGroupOptionProps extends IChoiceGroupOption {
    componentRef?: IRefObject<IChoiceGroupOption>;
    focused?: boolean;
    name?: string;
    onBlur?: (ev: React.FocusEvent<HTMLElement>, props?: IChoiceGroupOption) => void;
    onChange?: (evt?: React.FormEvent<HTMLElement | HTMLInputElement>, props?: IChoiceGroupOption) => void;
    onFocus?: (ev?: React.FocusEvent<HTMLElement | HTMLInputElement>, props?: IChoiceGroupOption) => void | undefined;
    required?: boolean;
    theme?: ITheme;
}

// @public
export interface IChoiceGroupOptionStyleProps {
    checked?: boolean;
    disabled?: boolean;
    focused?: boolean;
    hasIcon?: boolean;
    hasImage?: boolean;
    imageIsLarge?: boolean;
    imageSize?: {
        height: number;
        width: number;
    };
    theme: ITheme;
}

// @public (undocumented)
export interface IChoiceGroupOptionStyles {
    // (undocumented)
    choiceFieldWrapper?: IStyle;
    // (undocumented)
    field?: IStyle;
    // (undocumented)
    iconWrapper?: IStyle;
    // (undocumented)
    imageWrapper?: IStyle;
    // (undocumented)
    innerField?: IStyle;
    // (undocumented)
    input?: IStyle;
    // (undocumented)
    labelWrapper?: IStyle;
    // (undocumented)
    root?: IStyle;
    // (undocumented)
    selectedImageWrapper?: IStyle;
}

// @public (undocumented)
export interface IChoiceGroupProps extends React.InputHTMLAttributes<HTMLElement | HTMLInputElement> {
    ariaLabelledBy?: string;
    componentRef?: IRefObject<IChoiceGroup>;
    defaultSelectedKey?: string | number;
    label?: string;
    onChange?: (ev?: React.FormEvent<HTMLElement | HTMLInputElement>, option?: IChoiceGroupOption) => void;
    // @deprecated
    onChanged?: (option: IChoiceGroupOption, evt?: React.FormEvent<HTMLElement | HTMLInputElement>) => void;
    options?: IChoiceGroupOption[];
    selectedKey?: string | number;
    styles?: IStyleFunctionOrObject<IChoiceGroupStyleProps, IChoiceGroupStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IChoiceGroupState {
    keyChecked?: string | number;
    keyFocused?: string | number;
}

// @public (undocumented)
export interface IChoiceGroupStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    optionsContainIconOrImage?: boolean;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface IChoiceGroupStyles {
    // @deprecated
    applicationRole?: IStyle;
    // (undocumented)
    flexContainer?: IStyle;
    // (undocumented)
    label?: IStyle;
    root?: IStyle;
}

// @public
export interface ICircle extends IShimmerElement {
    height?: number;
}

// @public (undocumented)
export interface ICoachmark {
    dismiss?: (ev?: any) => void;
}

// @public
export interface ICoachmarkProps extends React.ClassAttributes<CoachmarkBase> {
    ariaAlertText?: string;
    ariaDescribedBy?: string;
    ariaDescribedByText?: string;
    ariaLabelledBy?: string;
    ariaLabelledByText?: string;
    beaconColorOne?: string;
    beaconColorTwo?: string;
    // @deprecated
    beakHeight?: number;
    // @deprecated
    beakWidth?: number;
    className?: string;
    // @deprecated
    collapsed?: boolean;
    color?: string;
    componentRef?: IRefObject<ICoachmark>;
    delayBeforeCoachmarkAnimation?: number;
    delayBeforeMouseOpen?: number;
    // @deprecated
    height?: number;
    isCollapsed?: boolean;
    isPositionForced?: boolean;
    mouseProximityOffset?: number;
    onAnimationOpenEnd?: () => void;
    onAnimationOpenStart?: () => void;
    onDismiss?: (ev?: any) => void;
    onMouseMove?: (e: MouseEvent) => void;
    positioningContainerProps?: IPositioningContainerProps;
    preventDismissOnLostFocus?: boolean;
    preventFocusOnMount?: boolean;
    styles?: IStyleFunctionOrObject<ICoachmarkStyleProps, ICoachmarkStyles>;
    target: HTMLElement | string | null;
    // @deprecated
    teachingBubbleRef?: ITeachingBubble;
    theme?: ITheme;
    // @deprecated
    width?: number;
}

// @public (undocumented)
export interface ICoachmarkState {
    alertText?: string;
    beakBottom?: string;
    beakLeft?: string;
    beakRight?: string;
    beakTop?: string;
    entityInnerHostRect: IEntityRect;
    isBeaconAnimating: boolean;
    isCollapsed: boolean;
    isMeasured: boolean;
    isMeasuring: boolean;
    isMouseInProximity: boolean;
    // Warning: (ae-forgotten-export) The symbol "RectangleEdge" needs to be exported by the entry point index.d.ts
    targetAlignment?: RectangleEdge;
    targetPosition?: RectangleEdge;
    transformOrigin?: string;
}

// @public
export interface ICoachmarkStyleProps {
    beaconColorOne?: string;
    beaconColorTwo?: string;
    className?: string;
    // @deprecated
    collapsed?: boolean;
    color?: string;
    delayBeforeCoachmarkAnimation?: string;
    entityHostHeight?: string;
    entityHostWidth?: string;
    height?: string;
    isBeaconAnimating: boolean;
    isCollapsed: boolean;
    isMeasured: boolean;
    isMeasuring: boolean;
    theme?: ITheme;
    transformOrigin?: string;
    width?: string;
}

// @public
export interface ICoachmarkStyles {
    ariaContainer?: IStyle;
    childrenContainer: IStyle;
    collapsed?: IStyle;
    entityHost?: IStyle;
    entityInnerHost: IStyle;
    pulsingBeacon?: IStyle;
    root?: IStyle;
    rotateAnimationLayer?: IStyle;
    scaleAnimationLayer?: IStyle;
    translateAnimationContainer?: IStyle;
}

// @public @deprecated (undocumented)
export type ICoachmarkTypes = ICoachmarkProps;

// @public (undocumented)
export interface IColor extends IRGB, IHSV {
    hex: string;
    str: string;
}

// @public (undocumented)
export interface IColorCellProps {
    color?: string;
    id: string;
    index?: number;
    label?: string;
}

// @public (undocumented)
export interface IColorPicker {
    color: IColor;
}

// @public (undocumented)
export interface IColorPickerGridCellProps {
    borderWidth?: number;
    circle?: boolean;
    color?: string;
    disabled?: boolean;
    height?: number;
    id: string;
    index?: number;
    item: IColorCellProps;
    label?: string;
    onClick?: (item: IColorCellProps) => void;
    onFocus?: (item: IColorCellProps) => void;
    onHover?: (item?: IColorCellProps) => void;
    onKeyDown?: (ev: React.KeyboardEvent<HTMLButtonElement>) => void;
    onMouseEnter?: (ev: React.MouseEvent<HTMLButtonElement>) => boolean;
    onMouseLeave?: (ev: React.MouseEvent<HTMLButtonElement>) => void;
    onMouseMove?: (ev: React.MouseEvent<HTMLButtonElement>) => boolean;
    onWheel?: (ev: React.MouseEvent<HTMLButtonElement>) => void;
    selected: boolean;
    styles?: IStyleFunctionOrObject<IColorPickerGridCellStyleProps, IColorPickerGridCellStyles>;
    theme?: ITheme;
    width?: number;
}

// @public
export interface IColorPickerGridCellStyleProps {
    borderWidth?: number;
    circle?: boolean;
    disabled?: boolean;
    height?: number;
    isWhite?: boolean;
    selected?: boolean;
    theme: ITheme;
    width?: number;
}

// @public
export interface IColorPickerGridCellStyles {
    colorCell: IStyle;
    svg: IStyle;
}

// @public (undocumented)
export interface IColorPickerProps {
    alphaLabel?: string;
    alphaSliderHidden?: boolean;
    blueLabel?: string;
    className?: string;
    color: IColor | string;
    componentRef?: IRefObject<IColorPicker>;
    greenLabel?: string;
    hexLabel?: string;
    onChange?: (ev: React.SyntheticEvent<HTMLElement>, color: IColor) => void;
    redLabel?: string;
    styles?: IStyleFunctionOrObject<IColorPickerStyleProps, IColorPickerStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IColorPickerState {
    // (undocumented)
    color: IColor;
    // (undocumented)
    editingColor?: {
        component: keyof IRGBHex;
        value: string;
    };
}

// @public (undocumented)
export interface IColorPickerStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IColorPickerStyles {
    input?: IStyle;
    panel?: IStyle;
    root?: IStyle;
    table?: IStyle;
    tableHeader?: IStyle;
    tableHexCell?: IStyle;
}

// @public (undocumented)
export interface IColorRectangle {
    color: IColor;
}

// @public (undocumented)
export interface IColorRectangleProps {
    className?: string;
    color: IColor;
    componentRef?: IRefObject<IColorRectangle>;
    minSize?: number;
    onChange?: (ev: React.MouseEvent<HTMLElement>, color: IColor) => void;
    styles?: IStyleFunctionOrObject<IColorRectangleStyleProps, IColorRectangleStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IColorRectangleStyleProps {
    className?: string;
    minSize?: number;
    theme: ITheme;
}

// @public (undocumented)
export interface IColorRectangleStyles {
    dark?: IStyle;
    light?: IStyle;
    root?: IStyle;
    thumb?: IStyle;
}

// @public (undocumented)
export interface IColorSlider {
}

// @public (undocumented)
export interface IColorSliderProps {
    className?: string;
    componentRef?: IRefObject<IColorSlider>;
    isAlpha?: boolean;
    maxValue?: number;
    minValue?: number;
    onChange?: (event: React.MouseEvent<HTMLElement>, newValue?: number) => void;
    overlayStyle?: any;
    styles?: IStyleFunctionOrObject<IColorSliderStyleProps, IColorSliderStyles>;
    theme?: ITheme;
    thumbColor?: string;
    value?: number;
}

// @public (undocumented)
export interface IColorSliderStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IColorSliderStyles {
    root?: IStyle;
    sliderOverlay?: IStyle;
    sliderThumb?: IStyle;
}

// @public (undocumented)
export interface IColumn {
    ariaLabel?: string;
    calculatedWidth?: number;
    className?: string;
    columnActionsMode?: ColumnActionsMode;
    currentWidth?: number;
    data?: any;
    fieldName?: string;
    filterAriaLabel?: string;
    getValueKey?: (item?: any, index?: number, column?: IColumn) => string;
    groupAriaLabel?: string;
    headerClassName?: string;
    iconClassName?: string;
    iconName?: string;
    // @deprecated
    isCollapsable?: boolean;
    isCollapsible?: boolean;
    isFiltered?: boolean;
    isGrouped?: boolean;
    isIconOnly?: boolean;
    isMenuOpen?: boolean;
    isMultiline?: boolean;
    isPadded?: boolean;
    isResizable?: boolean;
    isRowHeader?: boolean;
    isSorted?: boolean;
    isSortedDescending?: boolean;
    key: string;
    maxWidth?: number;
    minWidth: number;
    name: string;
    onColumnClick?: (ev: React.MouseEvent<HTMLElement>, column: IColumn) => void;
    onColumnContextMenu?: (column?: IColumn, ev?: React.MouseEvent<HTMLElement>) => void;
    onColumnResize?: (width?: number) => void;
    onRender?: (item?: any, index?: number, column?: IColumn) => any;
    onRenderDivider?: IRenderFunction<IDetailsColumnProps>;
    sortAscendingAriaLabel?: string;
    sortDescendingAriaLabel?: string;
}

// @public (undocumented)
export interface IColumnDragDropDetails {
    draggedIndex: number;
    targetIndex: number;
}

// @public (undocumented)
export interface IColumnReorderHeaderProps extends IColumnReorderOptions {
    onColumnDragEnd?: (props: {
        dropLocation?: ColumnDragEndLocation;
    }, event: MouseEvent) => void;
}

// @public (undocumented)
export interface IColumnReorderOptions {
    frozenColumnCountFromEnd?: number;
    frozenColumnCountFromStart?: number;
    // @deprecated
    handleColumnReorder?: (draggedIndex: number, targetIndex: number) => void;
    onColumnDragStart?: (dragStarted: boolean) => void;
    onColumnDrop?: (dragDropDetails: IColumnDragDropDetails) => void;
    onDragEnd?: (columnDropLocationDetails: ColumnDragEndLocation) => void;
}

// @public (undocumented)
export interface IColumnResizeDetails {
    // (undocumented)
    columnIndex: number;
    // (undocumented)
    columnMinWidth: number;
    // (undocumented)
    originX?: number;
}

// @public (undocumented)
export interface IComboBox {
    dismissMenu: () => void;
    focus(shouldOpenOnFocus?: boolean, useFocusAsync?: boolean): boolean;
    readonly selectedOptions: IComboBoxOption[];
}

// @public (undocumented)
export interface IComboBoxOption extends ISelectableOption {
    styles?: Partial<IComboBoxOptionStyles>;
    useAriaLabelAsText?: boolean;
}

// @public (undocumented)
export interface IComboBoxOptionStyles extends IButtonStyles {
    optionText: IStyle;
    optionTextWrapper: IStyle;
}

// @public (undocumented)
export interface IComboBoxProps extends ISelectableDroppableTextProps<IComboBox, IComboBox> {
    allowFreeform?: boolean;
    ariaDescribedBy?: string;
    autoComplete?: 'on' | 'off';
    autofill?: IAutofillProps;
    buttonIconProps?: IIconProps;
    caretDownButtonStyles?: Partial<IButtonStyles>;
    comboBoxOptionStyles?: Partial<IComboBoxOptionStyles>;
    componentRef?: IRefObject<IComboBox>;
    dropdownMaxWidth?: number;
    dropdownWidth?: number;
    // Warning: (ae-forgotten-export) The symbol "IComboBoxClassNames" needs to be exported by the entry point index.d.ts
    getClassNames?: (theme: ITheme, isOpen: boolean, disabled: boolean, required: boolean, focused: boolean, allowFreeForm: boolean, hasErrorMessage: boolean, className?: string) => IComboBoxClassNames;
    iconButtonProps?: IButtonProps;
    isButtonAriaHidden?: boolean;
    keytipProps?: IKeytipProps;
    multiSelect?: boolean;
    onChange?: (event: React.FormEvent<IComboBox>, option?: IComboBoxOption, index?: number, value?: string) => void;
    onItemClick?: (event: React.FormEvent<IComboBox>, option?: IComboBoxOption, index?: number) => void;
    onMenuDismiss?: () => void;
    onMenuDismissed?: () => void;
    onMenuOpen?: () => void;
    onPendingValueChanged?: (option?: IComboBoxOption, index?: number, value?: string) => void;
    onRenderLowerContent?: IRenderFunction<IComboBoxProps>;
    onResolveOptions?: (options: IComboBoxOption[]) => IComboBoxOption[] | PromiseLike<IComboBoxOption[]>;
    onScrollToItem?: (itemIndex: number) => void;
    options: IComboBoxOption[];
    persistMenu?: boolean;
    scrollSelectedToTop?: boolean;
    shouldRestoreFocus?: boolean;
    styles?: Partial<IComboBoxStyles>;
    text?: string;
    theme?: ITheme;
    useComboBoxAsMenuWidth?: boolean;
}

// @public (undocumented)
export interface IComboBoxState {
    currentOptions: IComboBoxOption[];
    currentPendingValue?: string;
    currentPendingValueValidIndex: number;
    currentPendingValueValidIndexOnHover: number;
    focused?: boolean;
    isOpen?: boolean;
    selectedIndices?: number[];
    suggestedDisplayValue?: string;
}

// @public (undocumented)
export interface IComboBoxStyles {
    callout: IStyle;
    container: IStyle;
    divider: IStyle;
    errorMessage: IStyle;
    header: IStyle;
    input: IStyle;
    inputDisabled: IStyle;
    label: IStyle;
    labelDisabled: IStyle;
    optionsContainer: IStyle;
    optionsContainerWrapper: IStyle;
    root: IStyle;
    rootDisabled: IStyle;
    rootDisallowFreeForm: IStyle;
    rootError: IStyle;
    rootFocused: IStyle;
    rootHovered: IStyle;
    rootPressed: IStyle;
}

// @public (undocumented)
export interface ICommandBar {
    focus(): void;
    remeasure(): void;
}

// @public (undocumented)
export interface ICommandBarData {
    cacheKey: string;
    farItems: ICommandBarItemProps[] | undefined;
    minimumOverflowItems: number;
    overflowItems: ICommandBarItemProps[];
    primaryItems: ICommandBarItemProps[];
}

// @public
export interface ICommandBarItemProps extends IContextualMenuItem {
    buttonStyles?: IButtonStyles;
    cacheKey?: string;
    commandBarButtonAs?: IComponentAs<ICommandBarItemProps>;
    iconOnly?: boolean;
    renderedInOverflow?: boolean;
    tooltipHostProps?: ITooltipHostProps;
}

// @public (undocumented)
export interface ICommandBarProps extends React.HTMLAttributes<HTMLDivElement> {
    ariaLabel?: string;
    buttonAs?: IComponentAs<IButtonProps>;
    className?: string;
    componentRef?: IRefObject<ICommandBar>;
    dataDidRender?: (renderedData: any) => void;
    farItems?: ICommandBarItemProps[];
    items: ICommandBarItemProps[];
    onDataGrown?: (movedItem: ICommandBarItemProps) => void;
    onDataReduced?: (movedItem: ICommandBarItemProps) => void;
    onGrowData?: (data: ICommandBarData) => ICommandBarData;
    onReduceData?: (data: ICommandBarData) => ICommandBarData | undefined;
    overflowButtonAs?: IComponentAs<IButtonProps>;
    overflowButtonProps?: IButtonProps;
    overflowItems?: ICommandBarItemProps[];
    shiftOnReduce?: Boolean;
    styles?: IStyleFunctionOrObject<ICommandBarStyleProps, ICommandBarStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface ICommandBarStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface ICommandBarStyles {
    // (undocumented)
    primarySet?: IStyle;
    // (undocumented)
    root?: IStyle;
    // (undocumented)
    secondarySet?: IStyle;
}

// @public
export const Icon: React.StatelessComponent<IIconProps>;

// @public (undocumented)
export class IconBase extends React.Component<IIconProps, IIconState> {
    constructor(props: IIconProps);
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export class IconButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public (undocumented)
export interface IContextualMenu {
}

// @public (undocumented)
export interface IContextualMenuItem {
    [propertyName: string]: any;
    ariaLabel?: string;
    canCheck?: boolean;
    checked?: boolean;
    className?: string;
    componentRef?: IRefObject<IContextualMenuRenderItem>;
    customOnRenderListLength?: number;
    data?: any;
    disabled?: boolean;
    // Warning: (ae-forgotten-export) The symbol "IMenuItemClassNames" needs to be exported by the entry point index.d.ts
    // 
    // @deprecated
    getItemClassNames?: (theme: ITheme, disabled: boolean, expanded: boolean, checked: boolean, isAnchorLink: boolean, knownIcon: boolean, itemClassName?: string, dividerClassName?: string, iconClassName?: string, subMenuClassName?: string, primaryDisabled?: boolean) => IMenuItemClassNames;
    getSplitButtonVerticalDividerClassNames?: (theme: ITheme) => IVerticalDividerClassNames;
    href?: string;
    iconProps?: IIconProps;
    // @deprecated
    inactive?: boolean;
    itemProps?: Partial<IContextualMenuItemProps>;
    // (undocumented)
    itemType?: ContextualMenuItemType;
    key: string;
    keytipProps?: IKeytipProps;
    // @deprecated
    name?: string;
    onClick?: (ev?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>, item?: IContextualMenuItem) => boolean | void;
    onMouseDown?: (item: IContextualMenuItem, event: React.MouseEvent<HTMLElement>) => void;
    onRender?: (item: any, dismissMenu: (ev?: any, dismissAll?: boolean) => void) => React.ReactNode;
    onRenderIcon?: IRenderFunction<IContextualMenuItemProps>;
    primaryDisabled?: boolean;
    rel?: string;
    role?: string;
    secondaryText?: string;
    sectionProps?: IContextualMenuSection;
    shortCut?: string;
    split?: boolean;
    // @deprecated
    style?: React.CSSProperties;
    submenuIconProps?: IIconProps;
    subMenuProps?: IContextualMenuProps;
    target?: string;
    text?: string;
    title?: string;
}

// @public (undocumented)
export interface IContextualMenuItemProps extends React.HTMLAttributes<IContextualMenuItemProps> {
    className?: string;
    classNames: IMenuItemClassNames;
    componentRef?: IRefObject<IContextualMenuRenderItem>;
    dismissMenu?: (ev?: any, dismissAll?: boolean) => void;
    dismissSubMenu?: () => void;
    getSubmenuTarget?: () => HTMLElement | undefined;
    hasIcons: boolean | undefined;
    index: number;
    item: IContextualMenuItem;
    onCheckmarkClick?: (item: IContextualMenuItem, ev: React.MouseEvent<HTMLElement>) => void;
    openSubMenu?: (item: any, target: HTMLElement) => void;
    styles?: IStyleFunctionOrObject<IContextualMenuItemStyleProps, IContextualMenuItemStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IContextualMenuItemStyleProps {
    checked: boolean;
    className?: string;
    disabled: boolean;
    dividerClassName?: string;
    expanded: boolean;
    iconClassName?: string;
    isAnchorLink: boolean;
    itemClassName?: string;
    knownIcon: boolean;
    primaryDisabled?: boolean;
    subMenuClassName?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IContextualMenuItemStyles extends IButtonStyles {
    anchorLink: IStyle;
    checkmarkIcon: IStyle;
    divider: IStyle;
    icon: IStyle;
    iconColor: IStyle;
    item: IStyle;
    label: IStyle;
    linkContent: IStyle;
    linkContentMenu: IStyle;
    root: IStyle;
    secondaryText: IStyle;
    splitContainer: IStyle;
    splitMenu: IStyle;
    splitPrimary: IStyle;
    subMenuIcon: IStyle;
}

// @public (undocumented)
export interface IContextualMenuListProps {
    // (undocumented)
    hasCheckmarks: boolean;
    // (undocumented)
    hasIcons: boolean;
    // (undocumented)
    items: IContextualMenuItem[];
    // (undocumented)
    totalItemCount: number;
}

// Warning: (ae-forgotten-export) The symbol "IWithResponsiveModeState" needs to be exported by the entry point index.d.ts
// 
// @public
export interface IContextualMenuProps extends IBaseProps<IContextualMenu>, IWithResponsiveModeState {
    alignTargetEdge?: boolean;
    ariaLabel?: string;
    beakWidth?: number;
    bounds?: IRectangle;
    calloutProps?: ICalloutProps;
    className?: string;
    componentRef?: IRefObject<IContextualMenu>;
    contextualMenuItemAs?: React.ComponentClass<IContextualMenuItemProps> | React.StatelessComponent<IContextualMenuItemProps>;
    coverTarget?: boolean;
    delayUpdateFocusOnHover?: boolean;
    directionalHint?: DirectionalHint;
    directionalHintFixed?: boolean;
    directionalHintForRTL?: DirectionalHint;
    doNotLayer?: boolean;
    focusZoneProps?: IFocusZoneProps;
    gapSpace?: number;
    // Warning: (ae-forgotten-export) The symbol "IContextualMenuClassNames" needs to be exported by the entry point index.d.ts
    // 
    // @deprecated
    getMenuClassNames?: (theme: ITheme, className?: string) => IContextualMenuClassNames;
    hidden?: boolean;
    id?: string;
    isBeakVisible?: boolean;
    isSubMenu?: boolean;
    items: IContextualMenuItem[];
    labelElementId?: string;
    onDismiss?: (ev?: any, dismissAll?: boolean) => void;
    onItemClick?: (ev?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>, item?: IContextualMenuItem) => boolean | void;
    onMenuDismissed?: (contextualMenu?: IContextualMenuProps) => void;
    onMenuOpened?: (contextualMenu?: IContextualMenuProps) => void;
    onRenderMenuList?: IRenderFunction<IContextualMenuListProps>;
    onRenderSubMenu?: IRenderFunction<IContextualMenuProps>;
    shouldFocusOnContainer?: boolean;
    shouldFocusOnMount?: boolean;
    styles?: IStyleFunctionOrObject<IContextualMenuStyleProps, IContextualMenuStyles>;
    subMenuHoverDelay?: number;
    target?: Target;
    theme?: ITheme;
    title?: string;
    useTargetAsMinWidth?: boolean;
    useTargetWidth?: boolean;
}

// @public (undocumented)
export interface IContextualMenuRenderItem {
    dismissMenu: (dismissAll?: boolean) => void;
    dismissSubMenu: () => void;
    openSubMenu: () => void;
}

// @public
export interface IContextualMenuSection extends React.ClassAttributes<any> {
    bottomDivider?: boolean;
    items: IContextualMenuItem[];
    title?: string;
    topDivider?: boolean;
}

// @public (undocumented)
export interface IContextualMenuState {
    // (undocumented)
    contextualMenuItems?: IContextualMenuItem[];
    // (undocumented)
    contextualMenuTarget?: Element;
    // (undocumented)
    dismissedMenuItemKey?: string;
    expandedByMouseClick?: boolean;
    // (undocumented)
    expandedMenuItemKey?: string;
    // (undocumented)
    positions?: any;
    // (undocumented)
    slideDirectionalClassName?: string;
    // (undocumented)
    submenuDirection?: DirectionalHint;
    // (undocumented)
    subMenuId?: string;
    // (undocumented)
    submenuTarget?: Element;
}

// @public (undocumented)
export interface IContextualMenuStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IContextualMenuStyles {
    container: IStyle;
    header: IStyle;
    list: IStyle;
    root: IStyle;
    subComponentStyles: IContextualMenuSubComponentStyles;
    title: IStyle;
}

// @public (undocumented)
export interface IContextualMenuSubComponentStyles {
    callout: IStyleFunctionOrObject<ICalloutContentStyleProps, any>;
    menuItem: IStyleFunctionOrObject<IContextualMenuItemStyleProps, any>;
}

// @public @deprecated (undocumented)
export enum IconType {
    // @deprecated
    Default = 100000,
    // @deprecated
    default = 0,
    // @deprecated
    Image = 100001,
    // @deprecated
    image = 1
}

// @public (undocumented)
export interface IDatePicker {
    focus(): void;
    reset(): void;
}

// @public (undocumented)
export interface IDatePickerProps extends IBaseProps<IDatePicker>, React.HTMLAttributes<HTMLElement> {
    allFocusable?: boolean;
    allowTextInput?: boolean;
    ariaLabel?: string;
    borderless?: boolean;
    calendarAs?: IComponentAs<ICalendarProps>;
    calendarProps?: ICalendarProps;
    calloutProps?: ICalloutProps;
    className?: string;
    componentRef?: IRefObject<IDatePicker>;
    dateTimeFormatter?: ICalendarFormatDateCallbacks;
    disableAutoFocus?: boolean;
    disabled?: boolean;
    firstDayOfWeek?: DayOfWeek;
    firstWeekOfYear?: FirstWeekOfYear;
    formatDate?: (date?: Date) => string;
    highlightCurrentMonth?: boolean;
    highlightSelectedMonth?: boolean;
    initialPickerDate?: Date;
    isMonthPickerVisible?: boolean;
    isRequired?: boolean;
    label?: string;
    maxDate?: Date;
    minDate?: Date;
    onAfterMenuDismiss?: () => void;
    onSelectDate?: (date: Date | null | undefined) => void;
    parseDateFromString?: (dateStr: string) => Date | null;
    pickerAriaLabel?: string;
    placeholder?: string;
    showCloseButton?: boolean;
    showGoToToday?: boolean;
    showMonthPickerAsOverlay?: boolean;
    showWeekNumbers?: boolean;
    strings?: IDatePickerStrings;
    styles?: IStyleFunction<IDatePickerStyleProps, IDatePickerStyles>;
    tabIndex?: number;
    textField?: ITextFieldProps;
    theme?: ITheme;
    today?: Date;
    underlined?: boolean;
    value?: Date;
}

// @public (undocumented)
export interface IDatePickerState {
    // (undocumented)
    errorMessage?: string;
    // (undocumented)
    formattedDate?: string;
    // (undocumented)
    isDatePickerShown?: boolean;
    // (undocumented)
    selectedDate?: Date;
}

// @public (undocumented)
export interface IDatePickerStrings extends ICalendarStrings {
    invalidInputErrorMessage?: string;
    isOutOfBoundsErrorMessage?: string;
    isRequiredErrorMessage?: string;
}

// @public (undocumented)
export interface IDatePickerStyleProps {
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    isDatePickerShown?: boolean;
    // (undocumented)
    label?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDatePickerStyles {
    // (undocumented)
    callout: IStyle;
    // (undocumented)
    icon: IStyle;
    root: IStyle;
    // (undocumented)
    textField: IStyle;
}

// @public (undocumented)
export interface IDetailsCheckboxProps {
    // (undocumented)
    checked: boolean;
    // (undocumented)
    theme?: ITheme;
}

// @public (undocumented)
export interface IDetailsColumnProps extends React.ClassAttributes<DetailsColumnBase> {
    cellStyleProps?: ICellStyleProps;
    column: IColumn;
    columnIndex: number;
    componentRef?: () => void;
    dragDropHelper?: IDragDropHelper | null;
    isDraggable?: boolean;
    isDropped?: boolean;
    onColumnClick?: (ev: React.MouseEvent<HTMLElement>, column: IColumn) => void;
    onColumnContextMenu?: (column: IColumn, ev: React.MouseEvent<HTMLElement>) => void;
    onRenderColumnHeaderTooltip?: IRenderFunction<ITooltipHostProps>;
    parentId?: string;
    // @deprecated (undocumented)
    setDraggedItemIndex?: (itemIndex: number) => void;
    styles?: IStyleFunctionOrObject<IDetailsColumnStyleProps, IDetailsColumnStyles>;
    theme?: ITheme;
    updateDragInfo?: (props: {
        itemIndex: number;
    }, event?: MouseEvent) => void;
    useFastIcons?: boolean;
}

// @public (undocumented)
export type IDetailsColumnStyleProps = Required<Pick<IDetailsColumnProps, 'theme' | 'cellStyleProps'>> & {
    headerClassName?: string;
    isActionable?: boolean;
    isEmpty?: boolean;
    isIconVisible?: boolean;
    isPadded?: boolean;
    isIconOnly?: boolean;
    iconClassName?: string;
    transitionDurationDrag?: number;
    transitionDurationDrop?: number;
};

// @public (undocumented)
export interface IDetailsColumnStyles {
    accessibleLabel: IStyle;
    borderAfterDropping: IStyle;
    borderWhileDragging: IStyle;
    cellName: IStyle;
    cellTitle: IStyle;
    cellTooltip: IStyle;
    filterChevron: IStyle;
    gripperBarVerticalStyle: IStyle;
    iconClassName: IStyle;
    nearIcon: IStyle;
    noBorderAfterDropping: IStyle;
    noBorderWhileDragging: IStyle;
    root: IStyle;
    sortIcon: IStyle;
}

// @public (undocumented)
export interface IDetailsFooterBaseProps extends IDetailsItemProps {
}

// @public (undocumented)
export interface IDetailsFooterProps extends IDetailsFooterBaseProps {
    columns: IColumn[];
    selection: ISelection;
    selectionMode: SelectionMode;
}

// @public (undocumented)
export interface IDetailsGroupDividerProps extends IGroupDividerProps, IDetailsItemProps {
}

// @public (undocumented)
export interface IDetailsGroupRenderProps extends IGroupRenderProps {
    // (undocumented)
    onRenderFooter?: IRenderFunction<IDetailsGroupDividerProps>;
    // (undocumented)
    onRenderHeader?: IRenderFunction<IDetailsGroupDividerProps>;
}

// @public (undocumented)
export interface IDetailsHeader {
    focus: () => boolean;
}

// @public (undocumented)
export interface IDetailsHeaderBaseProps extends React.ClassAttributes<DetailsHeaderBase>, IDetailsItemProps {
    ariaLabel?: string;
    ariaLabelForSelectAllCheckbox?: string;
    ariaLabelForSelectionColumn?: string;
    ariaLabelForToggleAllGroupsButton?: string;
    className?: string;
    collapseAllVisibility?: CollapseAllVisibility;
    columnReorderOptions?: IColumnReorderOptions;
    columnReorderProps?: IColumnReorderHeaderProps;
    componentRef?: IRefObject<IDetailsHeader>;
    isAllCollapsed?: boolean;
    layoutMode: DetailsListLayoutMode;
    minimumPixelsForDrag?: number;
    onColumnAutoResized?: (column: IColumn, columnIndex: number) => void;
    onColumnClick?: (ev: React.MouseEvent<HTMLElement>, column: IColumn) => void;
    onColumnContextMenu?: (column: IColumn, ev: React.MouseEvent<HTMLElement>) => void;
    onColumnIsSizingChanged?: (column: IColumn, isSizing: boolean) => void;
    onColumnResized?: (column: IColumn, newWidth: number, columnIndex: number) => void;
    onRenderColumnHeaderTooltip?: IRenderFunction<ITooltipHostProps>;
    onRenderDetailsCheckbox?: IRenderFunction<IDetailsCheckboxProps>;
    onToggleCollapseAll?: (isAllCollapsed: boolean) => void;
    selectAllVisibility?: SelectAllVisibility;
    styles?: IStyleFunctionOrObject<IDetailsHeaderStyleProps, IDetailsHeaderStyles>;
    theme?: ITheme;
    useFastIcons?: boolean;
}

// @public (undocumented)
export interface IDetailsHeaderProps extends IDetailsHeaderBaseProps {
    columns: IColumn[];
    selection: ISelection;
    selectionMode: SelectionMode;
}

// @public (undocumented)
export interface IDetailsHeaderState {
    // (undocumented)
    columnResizeDetails?: IColumnResizeDetails;
    // (undocumented)
    isAllCollapsed?: boolean;
    // (undocumented)
    isAllSelected?: boolean;
    // (undocumented)
    isSizing?: boolean;
}

// @public (undocumented)
export type IDetailsHeaderStyleProps = Required<Pick<IDetailsHeaderProps, 'theme'>> & Pick<IDetailsHeaderProps, 'className'> & {
    isSelectAllHidden?: boolean;
    isAllSelected?: boolean;
    isResizingColumn?: boolean;
    isAllCollapsed?: boolean;
    isSizing?: boolean;
    isCheckboxHidden?: boolean;
    cellStyleProps?: ICellStyleProps;
};

// @public (undocumented)
export interface IDetailsHeaderStyles {
    // (undocumented)
    accessibleLabel: IStyle;
    // @deprecated (undocumented)
    cellIsActionable: IStyle;
    // (undocumented)
    cellIsCheck: IStyle;
    // @deprecated (undocumented)
    cellIsEmpty: IStyle;
    // (undocumented)
    cellIsGroupExpander: IStyle;
    // (undocumented)
    cellIsResizing: IStyle;
    // (undocumented)
    cellSizer: IStyle;
    // (undocumented)
    cellSizerEnd: IStyle;
    // (undocumented)
    cellSizerStart: IStyle;
    // @deprecated (undocumented)
    cellWrapperPadded: IStyle;
    // (undocumented)
    check: IStyle;
    // (undocumented)
    checkTooltip: IStyle;
    // (undocumented)
    collapseButton: IStyle;
    // (undocumented)
    dropHintCaretStyle: IStyle;
    // (undocumented)
    dropHintCircleStyle: IStyle;
    // (undocumented)
    dropHintLineStyle: IStyle;
    // (undocumented)
    dropHintStyle: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    sizingOverlay: IStyle;
}

// @public (undocumented)
export interface IDetailsItemProps {
    cellStyleProps?: ICellStyleProps;
    checkboxVisibility?: CheckboxVisibility | undefined;
    columns?: IColumn[];
    groupNestingDepth?: number;
    indentWidth?: number | undefined;
    rowWidth?: number;
    selection?: ISelection | undefined;
    selectionMode?: SelectionMode | undefined;
    // @deprecated
    viewport?: IViewport | undefined;
}

// @public (undocumented)
export interface IDetailsList extends IList {
    focusIndex: (index: number, forceIntoFirstElement?: boolean, measureItem?: (itemIndex: number) => number, scrollToMode?: ScrollToMode) => void;
    forceUpdate: () => void;
    getStartItemIndexInView: () => number;
}

// @public (undocumented)
export interface IDetailsListCheckboxProps extends IDetailsCheckboxProps {
}

// @public (undocumented)
export interface IDetailsListProps extends IBaseProps<IDetailsList>, IWithViewportProps {
    ariaLabel?: string;
    ariaLabelForGrid?: string;
    ariaLabelForListHeader?: string;
    ariaLabelForSelectAllCheckbox?: string;
    ariaLabelForSelectionColumn?: string;
    cellStyleProps?: ICellStyleProps;
    checkboxCellClassName?: string;
    checkboxVisibility?: CheckboxVisibility;
    checkButtonAriaLabel?: string;
    className?: string;
    columnReorderOptions?: IColumnReorderOptions;
    columns?: IColumn[];
    compact?: boolean;
    componentRef?: IRefObject<IDetailsList>;
    constrainMode?: ConstrainMode;
    disableSelectionZone?: boolean;
    dragDropEvents?: IDragDropEvents;
    enableUpdateAnimations?: boolean;
    enterModalSelectionOnTouch?: boolean;
    getCellValueKey?: (item?: any, index?: number, column?: IColumn) => string;
    getGroupHeight?: IGroupedListProps['getGroupHeight'];
    getKey?: (item: any, index?: number) => string;
    getRowAriaDescribedBy?: (item: any) => string;
    getRowAriaLabel?: (item: any) => string;
    groupProps?: IDetailsGroupRenderProps;
    groups?: IGroup[];
    indentWidth?: number;
    initialFocusedIndex?: number;
    isHeaderVisible?: boolean;
    isPlaceholderData?: boolean;
    items: any[];
    layoutMode?: DetailsListLayoutMode;
    listProps?: IListProps;
    minimumPixelsForDrag?: number;
    onActiveItemChanged?: (item?: any, index?: number, ev?: React.FocusEvent<HTMLElement>) => void;
    onColumnHeaderClick?: (ev?: React.MouseEvent<HTMLElement>, column?: IColumn) => void;
    onColumnHeaderContextMenu?: (column?: IColumn, ev?: React.MouseEvent<HTMLElement>) => void;
    onColumnResize?: (column?: IColumn, newWidth?: number, columnIndex?: number) => void;
    onDidUpdate?: (detailsList?: DetailsListBase) => void;
    onItemContextMenu?: (item?: any, index?: number, ev?: Event) => void | boolean;
    onItemInvoked?: (item?: any, index?: number, ev?: Event) => void;
    onRenderCheckbox?: IRenderFunction<IDetailsListCheckboxProps>;
    onRenderDetailsFooter?: IRenderFunction<IDetailsFooterProps>;
    onRenderDetailsHeader?: IRenderFunction<IDetailsHeaderProps>;
    onRenderItemColumn?: (item?: any, index?: number, column?: IColumn) => React.ReactNode;
    onRenderMissingItem?: (index?: number, rowProps?: IDetailsRowProps) => React.ReactNode;
    onRenderRow?: IRenderFunction<IDetailsRowProps>;
    onRowDidMount?: (item?: any, index?: number) => void;
    onRowWillUnmount?: (item?: any, index?: number) => void;
    onShouldVirtualize?: (props: IListProps) => boolean;
    rowElementEventMap?: {
        eventName: string;
        callback: (context: IDragDropContext, event?: any) => void;
    }[];
    selection?: ISelection;
    selectionMode?: SelectionMode;
    selectionPreservedOnEmptyClick?: boolean;
    selectionZoneProps?: ISelectionZoneProps;
    setKey?: string;
    shouldApplyApplicationRole?: boolean;
    styles?: IStyleFunctionOrObject<IDetailsListStyleProps, IDetailsListStyles>;
    theme?: ITheme;
    useFastIcons?: boolean;
    usePageCache?: boolean;
    useReducedRowRenderer?: boolean;
    viewport?: IViewport;
}

// @public (undocumented)
export interface IDetailsListState {
    // (undocumented)
    adjustedColumns: IColumn[];
    // (undocumented)
    focusedItemIndex: number;
    // (undocumented)
    isCollapsed?: boolean;
    // (undocumented)
    isDropping?: boolean;
    // (undocumented)
    isSizing?: boolean;
    // (undocumented)
    isSomeGroupExpanded?: boolean;
    // (undocumented)
    lastSelectionMode?: SelectionMode;
    // (undocumented)
    lastWidth?: number;
}

// @public (undocumented)
export type IDetailsListStyleProps = Required<Pick<IDetailsListProps, 'theme'>> & Pick<IDetailsListProps, 'className'> & {
    isHorizontalConstrained?: boolean;
    compact?: boolean;
    isFixed?: boolean;
};

// @public (undocumented)
export interface IDetailsListStyles {
    // (undocumented)
    contentWrapper: IStyle;
    // (undocumented)
    focusZone: IStyle;
    // (undocumented)
    headerWrapper: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDetailsRow {
}

// @public (undocumented)
export interface IDetailsRowBaseProps extends Pick<IDetailsListProps, 'onRenderItemColumn' | 'getCellValueKey'>, IBaseProps<IDetailsRow>, IDetailsItemProps {
    cellsByColumn?: {
        [columnKey: string]: React.ReactNode;
    };
    checkboxCellClassName?: string;
    checkButtonAriaLabel?: string;
    className?: string;
    collapseAllVisibility?: CollapseAllVisibility;
    compact?: boolean;
    componentRef?: IRefObject<IDetailsRow>;
    dragDropEvents?: IDragDropEvents;
    dragDropHelper?: IDragDropHelper;
    enableUpdateAnimations?: boolean;
    eventsToRegister?: {
        eventName: string;
        callback: (item?: any, index?: number, event?: any) => void;
    }[];
    getRowAriaDescribedBy?: (item: any) => string;
    getRowAriaLabel?: (item: any) => string;
    item: any;
    itemIndex: number;
    onDidMount?: (row?: DetailsRowBase) => void;
    onRenderCheck?: (props: IDetailsRowCheckProps) => JSX.Element;
    onRenderDetailsCheckbox?: IRenderFunction<IDetailsCheckboxProps>;
    onWillUnmount?: (row?: DetailsRowBase) => void;
    rowFieldsAs?: React.ComponentType<IDetailsRowFieldsProps>;
    styles?: IStyleFunctionOrObject<IDetailsRowStyleProps, IDetailsRowStyles>;
    theme?: ITheme;
    useFastIcons?: boolean;
    useReducedRowRenderer?: boolean;
}

// @public (undocumented)
export interface IDetailsRowCheckProps extends React.HTMLAttributes<HTMLElement> {
    anySelected?: boolean;
    canSelect: boolean;
    checkClassName?: string;
    className?: string;
    compact?: boolean;
    isHeader?: boolean;
    isVisible?: boolean;
    onRenderDetailsCheckbox?: IRenderFunction<IDetailsCheckboxProps>;
    selected?: boolean;
    styles?: IStyleFunctionOrObject<IDetailsRowCheckStyleProps, IDetailsRowCheckStyles>;
    theme?: ITheme;
    useFastIcons?: boolean;
}

// @public (undocumented)
export type IDetailsRowCheckStyleProps = Required<Pick<IDetailsRowCheckProps, 'theme'>> & Pick<IDetailsRowCheckProps, 'compact' | 'isHeader' | 'selected' | 'anySelected' | 'canSelect' | 'className'> & {
    isVisible?: boolean;
};

// @public (undocumented)
export interface IDetailsRowCheckStyles {
    // @deprecated (undocumented)
    check: IStyle;
    // (undocumented)
    isDisabled: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public
export interface IDetailsRowFieldsProps extends IOverrideColumnRenderProps {
    cellStyleProps?: ICellStyleProps;
    columns: IColumn[];
    columnStartIndex: number;
    compact?: boolean;
    // (undocumented)
    enableUpdateAnimations?: boolean;
    item: any;
    itemIndex: number;
    rowClassNames: {
        [k in keyof Pick<IDetailsRowStyles, 'isMultiline' | 'isRowHeader' | 'cell' | 'cellAnimation' | 'cellPadded' | 'cellUnpadded' | 'fields'>]: string;
    };
}

// @public (undocumented)
export interface IDetailsRowProps extends IDetailsRowBaseProps {
    columns: IColumn[];
    selection: ISelection;
    selectionMode: SelectionMode;
}

// @public (undocumented)
export interface IDetailsRowSelectionState {
    // (undocumented)
    isSelected: boolean;
    // (undocumented)
    isSelectionModal: boolean;
}

// @public (undocumented)
export interface IDetailsRowState {
    // (undocumented)
    columnMeasureInfo?: {
        index: number;
        column: IColumn;
        onMeasureDone: (measuredWidth: number) => void;
    };
    // (undocumented)
    isDropping?: boolean;
    // (undocumented)
    selectionState: IDetailsRowSelectionState;
}

// @public (undocumented)
export type IDetailsRowStyleProps = Required<Pick<IDetailsRowProps, 'theme'>> & {
    isSelected?: boolean;
    anySelected?: boolean;
    canSelect?: boolean;
    droppingClassName?: string;
    isCheckVisible?: boolean;
    isRowHeader?: boolean;
    checkboxCellClassName?: string;
    className?: string;
    compact?: boolean;
    cellStyleProps?: ICellStyleProps;
    enableUpdateAnimations?: boolean;
};

// @public (undocumented)
export interface IDetailsRowStyles {
    // (undocumented)
    cell: IStyle;
    // (undocumented)
    cellAnimation: IStyle;
    // (undocumented)
    cellMeasurer: IStyle;
    // (undocumented)
    cellPadded: IStyle;
    // (undocumented)
    cellUnpadded: IStyle;
    // (undocumented)
    check: IStyle;
    // (undocumented)
    checkCell: IStyle;
    // (undocumented)
    checkCover: IStyle;
    // (undocumented)
    fields: IStyle;
    // (undocumented)
    isMultiline: IStyle;
    // (undocumented)
    isRowHeader: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDialog {
}

// @public (undocumented)
export interface IDialogContent {
}

// @public (undocumented)
export interface IDialogContentProps extends React.ClassAttributes<DialogContentBase> {
    className?: string;
    closeButtonAriaLabel?: string;
    componentRef?: IRefObject<IDialogContent>;
    draggableHeaderClassName?: string;
    isMultiline?: boolean;
    onDismiss?: (ev?: React.MouseEvent<HTMLButtonElement>) => any;
    responsiveMode?: ResponsiveMode;
    showCloseButton?: boolean;
    styles?: IStyleFunctionOrObject<IDialogContentStyleProps, IDialogContentStyles>;
    subText?: string;
    subTextId?: string;
    theme?: ITheme;
    title?: string | JSX.Element;
    titleId?: string;
    topButtonsProps?: IButtonProps[];
    type?: DialogType;
}

// @public (undocumented)
export interface IDialogContentStyleProps {
    className?: string;
    draggableHeaderClassName?: string;
    // (undocumented)
    hidden?: boolean;
    // (undocumented)
    isClose?: boolean;
    // (undocumented)
    isLargeHeader?: boolean;
    isMultiline?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDialogContentStyles {
    // (undocumented)
    button: IStyle;
    content: IStyle;
    // (undocumented)
    header: IStyle;
    // (undocumented)
    inner: IStyle;
    // (undocumented)
    innerContent: IStyle;
    // (undocumented)
    subText: IStyle;
    // (undocumented)
    title: IStyle;
    // (undocumented)
    topButton: IStyle;
}

// @public (undocumented)
export interface IDialogFooter {
}

// @public (undocumented)
export interface IDialogFooterProps extends React.Props<DialogFooterBase> {
    className?: string;
    componentRef?: IRefObject<IDialogFooter>;
    styles?: IStyleFunctionOrObject<IDialogFooterStyleProps, IDialogFooterStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDialogFooterStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IDialogFooterStyles {
    // (undocumented)
    action: IStyle;
    actions: IStyle;
    // (undocumented)
    actionsRight: IStyle;
}

// Warning: (ae-forgotten-export) The symbol "IAccessiblePopupProps" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDialogProps extends React.ClassAttributes<DialogBase>, IWithResponsiveModeState, IAccessiblePopupProps {
    // @deprecated
    ariaDescribedById?: string;
    // @deprecated
    ariaLabelledById?: string;
    // @deprecated
    className?: string;
    // @deprecated
    componentRef?: IRefObject<IDialog>;
    // @deprecated
    containerClassName?: string;
    // @deprecated
    contentClassName?: string;
    dialogContentProps?: IDialogContentProps;
    hidden?: boolean;
    // @deprecated
    isBlocking?: boolean;
    // @deprecated
    isDarkOverlay?: boolean;
    // @deprecated
    isOpen?: boolean;
    maxWidth?: ICSSRule | ICSSPixelUnitRule;
    minWidth?: ICSSRule | ICSSPixelUnitRule;
    modalProps?: IModalProps;
    onDismiss?: (ev?: React.MouseEvent<HTMLButtonElement>) => any;
    // @deprecated
    onDismissed?: () => any;
    // @deprecated
    onLayerDidMount?: () => void;
    // @deprecated
    onLayerMounted?: () => void;
    styles?: IStyleFunctionOrObject<IDialogStyleProps, IDialogStyles>;
    // @deprecated
    subText?: string;
    theme?: ITheme;
    // @deprecated
    title?: string | JSX.Element;
    // @deprecated
    topButtonsProps?: IButtonProps[];
    // @deprecated
    type?: DialogType;
}

// @public (undocumented)
export interface IDialogState {
    // (undocumented)
    hasBeenOpened?: boolean;
    // (undocumented)
    id?: string;
    // (undocumented)
    isInKeyboardMoveMode?: boolean;
    // (undocumented)
    isModalMenuOpen?: boolean;
    // (undocumented)
    isOpen?: boolean;
    // (undocumented)
    isVisible?: boolean;
    // (undocumented)
    isVisibleClose?: boolean;
    // (undocumented)
    modalRectangleTop?: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @public (undocumented)
export interface IDialogStyleProps {
    className?: string;
    // @deprecated
    containerClassName?: string;
    // @deprecated
    contentClassName?: string;
    dialogDefaultMaxWidth?: string | ICSSRule | ICSSPixelUnitRule;
    dialogDefaultMinWidth?: string | ICSSRule | ICSSPixelUnitRule;
    hidden?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDialogStyles {
    // (undocumented)
    main: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface IDividerAsProps extends IIconProps {
    item?: IBreadcrumbItem;
}

// @public (undocumented)
export interface IDocumentCard {
    focus: () => void;
}

// @public (undocumented)
export interface IDocumentCardActions {
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardActionsBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardActionsProps extends React.ClassAttributes<DocumentCardActionsBase> {
    actions: IButtonProps[];
    className?: string;
    componentRef?: IRefObject<IDocumentCardActions>;
    styles?: IStyleFunctionOrObject<IDocumentCardActionsStyleProps, IDocumentCardActionsStyles>;
    theme?: ITheme;
    views?: Number;
}

// @public (undocumented)
export interface IDocumentCardActionsStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardActionsStyles {
    // (undocumented)
    action: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    views: IStyle;
    // (undocumented)
    viewsIcon: IStyle;
}

// @public (undocumented)
export interface IDocumentCardActivity {
}

// @public (undocumented)
export interface IDocumentCardActivityPerson {
    allowPhoneInitials?: boolean;
    initials?: string;
    initialsColor?: PersonaInitialsColor;
    name: string;
    profileImageSrc: string;
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardActivityBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardActivityProps extends React.ClassAttributes<DocumentCardActivityBase> {
    activity: string;
    className?: string;
    componentRef?: IRefObject<IDocumentCardActivity>;
    people: IDocumentCardActivityPerson[];
    styles?: IStyleFunctionOrObject<IDocumentCardActivityStyleProps, IDocumentCardActivityStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDocumentCardActivityStyleProps {
    className?: string;
    multiplePeople?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardActivityStyles {
    // (undocumented)
    activity: IStyle;
    // (undocumented)
    avatar: IStyle;
    // (undocumented)
    avatars: IStyle;
    // (undocumented)
    details: IStyle;
    // (undocumented)
    name: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardDetails {
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardDetailsBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardDetailsProps extends React.Props<DocumentCardDetailsBase> {
    className?: string;
    componentRef?: IRefObject<IDocumentCardDetails>;
    styles?: IStyleFunctionOrObject<IDocumentCardDetailsStyleProps, IDocumentCardDetailsStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDocumentCardDetailsStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardDetailsStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardImage {
}

// @public (undocumented)
export interface IDocumentCardImageProps extends IBaseProps<{}> {
    className?: string;
    componentRef?: IRefObject<IDocumentCardImage>;
    height?: number;
    iconProps?: IIconProps;
    imageFit?: ImageFit;
    imageSrc?: string;
    styles?: IStyleFunctionOrObject<IDocumentCardImageStyleProps, IDocumentCardImageStyles>;
    theme?: ITheme;
    width?: number;
}

// @public (undocumented)
export interface IDocumentCardImageStyleProps extends IDocumentCardImageProps {
}

// @public (undocumented)
export interface IDocumentCardImageStyles {
    // (undocumented)
    centeredIcon: IStyle;
    // (undocumented)
    centeredIconWrapper: IStyle;
    // (undocumented)
    cornerIcon: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardLocation {
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardLocationBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardLocationProps extends React.ClassAttributes<DocumentCardLocationBase> {
    ariaLabel?: string;
    className?: string;
    componentRef?: IRefObject<IDocumentCardLocation>;
    location: string;
    locationHref?: string;
    onClick?: (ev?: React.MouseEvent<HTMLElement>) => void;
    styles?: IStyleFunctionOrObject<IDocumentCardLocationStyleProps, IDocumentCardLocationStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDocumentCardLocationStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardLocationStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardLogo {
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardLogoBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardLogoProps extends React.ClassAttributes<DocumentCardLogoBase> {
    className?: string;
    componentRef?: IRefObject<IDocumentCardLogo>;
    logoIcon: string;
    logoName?: string;
    styles?: IStyleFunctionOrObject<IDocumentCardLogoStyleProps, IDocumentCardLogoStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDocumentCardLogoStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardLogoStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardPreview {
}

// @public (undocumented)
export interface IDocumentCardPreviewImage {
    // @deprecated
    accentColor?: string;
    componentRef?: IRefObject<{}>;
    // @deprecated
    errorImageSrc?: string;
    height?: number;
    iconSrc?: string;
    imageFit?: ImageFit;
    linkProps?: ILinkProps;
    name?: string;
    previewIconContainerClass?: string;
    previewIconProps?: IIconProps;
    previewImageSrc?: string;
    // @deprecated
    url?: string;
    width?: number;
}

// @public (undocumented)
export interface IDocumentCardPreviewProps extends IBaseProps<{}> {
    className?: string;
    componentRef?: IRefObject<IDocumentCardPreview>;
    getOverflowDocumentCountText?: (overflowCount: number) => string;
    previewImages: IDocumentCardPreviewImage[];
    styles?: IStyleFunctionOrObject<IDocumentCardPreviewStyleProps, IDocumentCardPreviewStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDocumentCardPreviewStyleProps {
    className?: string;
    isFileList?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardPreviewStyles {
    // (undocumented)
    fileList: IStyle;
    // (undocumented)
    fileListIcon: IStyle;
    // (undocumented)
    fileListOverflowText: IStyle;
    // (undocumented)
    icon: IStyle;
    // (undocumented)
    previewIcon: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardProps extends IBaseProps<IDocumentCard>, React.HTMLAttributes<HTMLDivElement> {
    // @deprecated
    accentColor?: string;
    children?: React.ReactNode;
    className?: string;
    componentRef?: IRefObject<IDocumentCard>;
    onClick?: (ev?: React.SyntheticEvent<HTMLElement>) => void;
    onClickHref?: string;
    role?: string;
    styles?: IStyleFunctionOrObject<IDocumentCardStyleProps, IDocumentCardStyles>;
    theme?: ITheme;
    type?: DocumentCardType;
}

// @public (undocumented)
export interface IDocumentCardStatus {
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardStatusBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardStatusProps extends React.Props<DocumentCardStatusBase> {
    className?: string;
    componentRef?: IRefObject<IDocumentCardStatus>;
    status: string;
    statusIcon?: string;
    styles?: IStyleFunctionOrObject<IDocumentCardStatusStyleProps, IDocumentCardStatusStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDocumentCardStatusStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardStatusStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardStyleProps {
    actionable?: boolean;
    className?: string;
    compact?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IDocumentCardTitle {
}

// Warning: (ae-forgotten-export) The symbol "DocumentCardTitleBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IDocumentCardTitleProps extends React.ClassAttributes<DocumentCardTitleBase> {
    className?: string;
    componentRef?: IRefObject<IDocumentCardTitle>;
    shouldTruncate?: boolean;
    showAsSecondaryTitle?: boolean;
    styles?: IStyleFunctionOrObject<IDocumentCardTitleStyleProps, IDocumentCardTitleStyles>;
    theme?: ITheme;
    title: string;
}

// @public (undocumented)
export interface IDocumentCardTitleStyleProps {
    className?: string;
    showAsSecondaryTitle?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IDocumentCardTitleStyles {
    // (undocumented)
    root: IStyle;
}

// @public
export interface IDragDropContext {
    data: any;
    index: number;
    isGroup?: boolean;
}

// @public
export interface IDragDropEvents {
    canDrag?: (item?: any) => boolean;
    canDrop?: (dropContext?: IDragDropContext, dragContext?: IDragDropContext) => boolean;
    onDragEnd?: (item?: any, event?: DragEvent) => void;
    onDragEnter?: (item?: any, event?: DragEvent) => string;
    onDragLeave?: (item?: any, event?: DragEvent) => void;
    onDragStart?: (item?: any, itemIndex?: number, selectedItems?: any[], event?: MouseEvent) => void;
    onDrop?: (item?: any, event?: DragEvent) => void;
}

// @public
export interface IDragDropHelper {
    dispose: () => void;
    subscribe: (root: HTMLElement, events: EventGroup, options: IDragDropOptions) => {
        key: string;
        dispose: () => void;
    };
    unsubscribe: (root: HTMLElement, key: string) => void;
}

// @public
export interface IDragDropOptions {
    canDrag?: (item?: any) => boolean;
    canDrop?: (dropContext?: IDragDropContext, dragContext?: IDragDropContext) => boolean;
    context: IDragDropContext;
    eventMap?: {
        eventName: string;
        callback: (context: IDragDropContext, event?: any) => void;
    }[];
    key?: string;
    onDragEnd?: (item?: any, event?: DragEvent) => void;
    onDragOver?: (item?: any, event?: DragEvent) => void;
    onDragStart?: (item?: any, itemIndex?: number, selectedItems?: any[], event?: MouseEvent) => void;
    onDrop?: (item?: any, event?: DragEvent) => void;
    selectionIndex: number;
    updateDropState: (isDropping: boolean, event: DragEvent) => void;
}

// @public (undocumented)
export interface IDragOptions {
    closeMenuItemText: string;
    dragHandleSelector?: string;
    keyboardMoveIconProps?: IIconProps;
    menu: React.StatelessComponent<IContextualMenuProps>;
    moveMenuItemText: string;
}

// @public (undocumented)
export interface IDropdown {
    // (undocumented)
    focus: (shouldOpenOnFocus?: boolean) => void;
    readonly selectedOptions: IDropdownOption[];
}

// @public
export interface IDropdownInternalProps extends IDropdownProps, IWithResponsiveModeState {
}

// @public (undocumented)
export interface IDropdownOption extends ISelectableOption {
    // @deprecated
    isSelected?: boolean;
}

// @public (undocumented)
export interface IDropdownProps extends ISelectableDroppableTextProps<IDropdown, HTMLDivElement> {
    defaultSelectedKeys?: string[] | number[];
    dropdownWidth?: number;
    // @deprecated
    isDisabled?: boolean;
    keytipProps?: IKeytipProps;
    multiSelect?: boolean;
    multiSelectDelimiter?: string;
    notifyOnReselect?: boolean;
    onChange?: (event: React.FormEvent<HTMLDivElement>, option?: IDropdownOption, index?: number) => void;
    // @deprecated (undocumented)
    onChanged?: (option: IDropdownOption, index?: number) => void;
    onDismiss?: () => void;
    onRenderCaretDown?: IRenderFunction<IDropdownProps>;
    onRenderLabel?: IRenderFunction<IDropdownProps>;
    // @deprecated
    onRenderPlaceHolder?: IRenderFunction<IDropdownProps>;
    onRenderPlaceholder?: IRenderFunction<IDropdownProps>;
    onRenderTitle?: IRenderFunction<IDropdownOption[]>;
    options: IDropdownOption[];
    // @deprecated
    placeHolder?: string;
    responsiveMode?: ResponsiveMode;
    selectedKeys?: string[] | number[] | null;
    styles?: IStyleFunctionOrObject<IDropdownStyleProps, IDropdownStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IDropdownState {
    // (undocumented)
    calloutRenderEdge?: RectangleEdge;
    hasFocus: boolean;
    // (undocumented)
    isOpen: boolean;
    // (undocumented)
    selectedIndices: number[];
}

// @public
export type IDropdownStyleProps = Pick<IDropdownProps, 'theme' | 'className' | 'disabled' | 'required'> & {
    hasError: boolean;
    hasLabel: boolean;
    isOpen: boolean;
    isRenderingPlaceholder: boolean;
    panelClassName?: string;
    calloutClassName?: string;
    calloutRenderEdge?: RectangleEdge;
};

// @public
export interface IDropdownStyles {
    callout: IStyle;
    caretDown: IStyle;
    caretDownWrapper: IStyle;
    dropdown: IStyle;
    dropdownDivider: IStyle;
    dropdownItem: IStyle;
    dropdownItemDisabled: IStyle;
    dropdownItemHeader: IStyle;
    dropdownItemHidden: IStyle;
    dropdownItems: IStyle;
    dropdownItemSelected: IStyle;
    dropdownItemSelectedAndDisabled: IStyle;
    dropdownItemsWrapper: IStyle;
    dropdownOptionText: IStyle;
    errorMessage: IStyle;
    label: IStyle;
    panel: IStyle;
    root: IStyle;
    subComponentStyles: IDropdownSubComponentStyles;
    title: IStyle;
}

// @public (undocumented)
export interface IDropdownSubComponentStyles {
    label: IStyleFunctionOrObject<ILabelStyleProps, any>;
    panel: IStyleFunctionOrObject<IPanelStyleProps, any>;
}

// @public (undocumented)
export interface IDropHintDetails {
    // (undocumented)
    dropHintElementRef: HTMLElement;
    // (undocumented)
    endX: number;
    // (undocumented)
    originX: number;
    // (undocumented)
    startX: number;
}

// @public
export interface IEntityRect {
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
}

// @public (undocumented)
export interface IExpandingCard {
}

// Warning: (ae-forgotten-export) The symbol "IBaseCardProps" needs to be exported by the entry point index.d.ts
// 
// @public
export interface IExpandingCardProps extends IBaseCardProps<IExpandingCard, IExpandingCardStyles, IExpandingCardStyleProps> {
    compactCardHeight?: number;
    expandedCardHeight?: number;
    mode?: ExpandingCardMode;
    onRenderCompactCard?: IRenderFunction<any>;
    onRenderExpandedCard?: IRenderFunction<any>;
}

// @public (undocumented)
export interface IExpandingCardState {
    // (undocumented)
    firstFrameRendered: boolean;
    // (undocumented)
    needsScroll: boolean;
}

// Warning: (ae-forgotten-export) The symbol "IBaseCardStyleProps" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IExpandingCardStyleProps extends IBaseCardStyleProps {
    compactCardHeight?: number;
    expandedCardFirstFrameRendered?: boolean;
    expandedCardHeight?: number;
    needsScroll?: boolean;
}

// Warning: (ae-forgotten-export) The symbol "IBaseCardStyles" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IExpandingCardStyles extends IBaseCardStyles {
    compactCard?: IStyle;
    expandedCard?: IStyle;
    expandedCardScroll?: IStyle;
}

// @public (undocumented)
export interface IExtendedPeoplePickerProps extends IBaseExtendedPickerProps<IPersonaProps> {
}

// @public (undocumented)
export interface IExtendedPersonaProps extends IPersonaProps {
    // (undocumented)
    blockRecipientRemoval?: boolean;
    // (undocumented)
    canExpand?: boolean;
    // (undocumented)
    isEditing?: boolean;
    // (undocumented)
    isValid: boolean;
    // (undocumented)
    key?: React.Key;
    // (undocumented)
    shouldBlockSelection?: boolean;
}

// @public (undocumented)
export interface IFabricProps extends React.HTMLAttributes<HTMLDivElement> {
    // (undocumented)
    componentRef?: IRefObject<{}>;
    // (undocumented)
    styles?: IStyleFunctionOrObject<IFabricStyleProps, IFabricStyles>;
    // (undocumented)
    theme?: ITheme;
}

// @public (undocumented)
export interface IFabricStyleProps extends IFabricProps {
    // (undocumented)
    isFocusVisible: boolean;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface IFabricStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IFacepile {
}

// @public (undocumented)
export interface IFacepilePersona extends React.ButtonHTMLAttributes<HTMLButtonElement | HTMLDivElement> {
    allowPhoneInitials?: boolean;
    data?: any;
    imageInitials?: string;
    imageUrl?: string;
    initialsColor?: PersonaInitialsColor;
    keytipProps?: IKeytipProps;
    onClick?: (ev?: React.MouseEvent<HTMLElement>, persona?: IFacepilePersona) => void;
    onMouseMove?: (ev?: React.MouseEvent<HTMLElement>, persona?: IFacepilePersona) => void;
    onMouseOut?: (ev?: React.MouseEvent<HTMLElement>, persona?: IFacepilePersona) => void;
    personaName?: string;
}

// @public (undocumented)
export interface IFacepileProps extends React.ClassAttributes<FacepileBase> {
    addButtonProps?: IButtonProps;
    ariaDescription?: string;
    // @deprecated
    chevronButtonProps?: IButtonProps;
    className?: string;
    componentRef?: IRefObject<IFacepile>;
    getPersonaProps?: (persona: IFacepilePersona) => IPersonaSharedProps;
    maxDisplayablePersonas?: number;
    onRenderPersona?: IRenderFunction<IFacepilePersona>;
    onRenderPersonaCoin?: IRenderFunction<IFacepilePersona>;
    overflowButtonProps?: IButtonProps;
    overflowButtonType?: OverflowButtonType;
    overflowPersonas?: IFacepilePersona[];
    personas: IFacepilePersona[];
    personaSize?: PersonaSize;
    showAddButton?: boolean;
    styles?: IStyleFunctionOrObject<IFacepileStyleProps, IFacepileStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IFacepileStyleProps {
    className?: string;
    spacingAroundItemButton?: number;
    theme: ITheme;
}

// @public (undocumented)
export interface IFacepileStyles {
    // (undocumented)
    addButton: IStyle;
    // (undocumented)
    descriptiveOverflowButton: IStyle;
    // (undocumented)
    itemButton: IStyle;
    // (undocumented)
    itemContainer: IStyle;
    // (undocumented)
    member: IStyle;
    // (undocumented)
    members: IStyle;
    // (undocumented)
    overflowButton: IStyle;
    // (undocumented)
    overflowInitialsIcon: IStyle;
    root: IStyle;
    // (undocumented)
    screenReaderOnly: IStyle;
}

// @public (undocumented)
export interface IFocusTrapCalloutProps extends ICalloutProps {
    focusTrapProps?: IFocusTrapZoneProps;
}

// @public (undocumented)
export interface IFocusTrapZone {
    focus: () => void;
}

// @public (undocumented)
export interface IFocusTrapZoneProps extends React.HTMLAttributes<HTMLDivElement> {
    ariaLabelledBy?: string;
    componentRef?: IRefObject<IFocusTrapZone>;
    disabled?: boolean;
    disableFirstFocus?: boolean;
    elementToFocusOnDismiss?: HTMLElement;
    firstFocusableSelector?: string | (() => string);
    focusPreviouslyFocusedInnerElement?: boolean;
    forceFocusInsideTrap?: boolean;
    ignoreExternalFocusing?: boolean;
    isClickableOutsideFocusTrap?: boolean;
}

// @public
export interface IFocusZone {
    focus(forceIntoFirstElement?: boolean): boolean;
    focusElement(childElement?: HTMLElement): boolean;
    setFocusAlignment(point: IPoint): void;
}

// @public
export interface IFocusZoneProps extends React.HTMLAttributes<HTMLElement | FocusZone> {
    allowFocusRoot?: boolean;
    // @deprecated
    allowTabKey?: boolean;
    // @deprecated
    ariaDescribedBy?: string;
    // @deprecated
    ariaLabelledBy?: string;
    as?: React.ReactType;
    checkForNoWrap?: boolean;
    className?: string;
    componentRef?: IRefObject<IFocusZone>;
    defaultActiveElement?: string;
    direction?: FocusZoneDirection;
    disabled?: boolean;
    doNotAllowFocusEventToPropagate?: boolean;
    // @deprecated
    elementType?: any;
    handleTabKey?: FocusZoneTabbableElements;
    isCircularNavigation?: boolean;
    isInnerZoneKeystroke?: (ev: React.KeyboardEvent<HTMLElement>) => boolean;
    onActiveElementChanged?: (element?: HTMLElement, ev?: React.FocusEvent<HTMLElement>) => void;
    onBeforeFocus?: (childElement?: HTMLElement) => boolean;
    onFocusNotification?: () => void;
    // @deprecated
    rootProps?: React.HTMLAttributes<HTMLDivElement>;
    shouldInputLoseFocusOnArrowKey?: (inputElement: HTMLInputElement) => boolean;
}

// @public
export interface IFontIconProps extends React.HTMLAttributes<HTMLElement> {
    className?: string;
    iconName?: string;
}

// @public
export interface IGap extends IShimmerElement {
    height?: number;
    width?: number | string;
}

// @public (undocumented)
export interface IGenericItem {
    // (undocumented)
    imageInitials: string;
    // (undocumented)
    primaryText: string;
    // (undocumented)
    ValidationState: ValidationState;
}

// @public (undocumented)
export interface IGrid {
}

// @public (undocumented)
export interface IGridCellProps<T> {
    cellDisabledStyle?: string[];
    cellIsSelectedStyle?: string[];
    className?: string;
    disabled?: boolean;
    getClassNames?: (theme: ITheme, className: string, variantClassName: string, iconClassName: string | undefined, menuIconClassName: string | undefined, disabled: boolean, checked: boolean, expanded: boolean, isSplit: boolean | undefined) => IButtonClassNames;
    id: string;
    index?: number;
    item: T;
    label?: string;
    onClick?: (item: T) => void;
    onFocus?: (item: T) => void;
    onHover?: (item?: T) => void;
    onKeyDown?: (ev: React.KeyboardEvent<HTMLButtonElement>) => void;
    onMouseEnter?: (ev: React.MouseEvent<HTMLButtonElement>) => boolean;
    onMouseLeave?: (ev: React.MouseEvent<HTMLButtonElement>) => void;
    onMouseMove?: (ev: React.MouseEvent<HTMLButtonElement>) => boolean;
    onRenderItem: (item: T) => JSX.Element;
    onWheel?: (ev: React.MouseEvent<HTMLButtonElement>) => void;
    role?: string;
    selected?: boolean;
}

// @public (undocumented)
export interface IGridProps {
    columnCount: number;
    componentRef?: IRefObject<IGrid>;
    // @deprecated
    containerClassName?: string;
    doNotContainWithinFocusZone?: boolean;
    items: any[];
    onBlur?: () => void;
    onRenderItem: (item: any, index: number) => JSX.Element;
    positionInSet?: number;
    setSize?: number;
    shouldFocusCircularNavigate?: boolean;
    styles?: IStyleFunctionOrObject<IGridStyleProps, IGridStyles>;
    theme?: ITheme;
}

// @public
export interface IGridStyleProps {
    theme: ITheme;
}

// @public
export interface IGridStyles {
    focusedContainer?: IStyle;
    root: IStyle;
    tableCell: IStyle;
}

// @public (undocumented)
export interface IGroup {
    ariaLabel?: string;
    children?: IGroup[];
    count: number;
    data?: any;
    hasMoreData?: boolean;
    isCollapsed?: boolean;
    isDropEnabled?: boolean;
    // @deprecated
    isSelected?: boolean;
    isShowingAll?: boolean;
    key: string;
    level?: number;
    name: string;
    startIndex: number;
}

// @public (undocumented)
export interface IGroupDividerProps {
    className?: string;
    compact?: boolean;
    // (undocumented)
    componentRef?: IRefObject<{}>;
    // @deprecated
    expandButtonProps?: React.HTMLAttributes<HTMLButtonElement>;
    footerText?: string;
    group?: IGroup;
    groupIndex?: number;
    groupLevel?: number;
    groups?: IGroup[];
    indentWidth?: number;
    isCollapsedGroupSelectVisible?: boolean;
    isGroupLoading?: (group: IGroup) => boolean;
    // @deprecated
    isSelected?: boolean;
    loadingText?: string;
    onGroupHeaderClick?: (group: IGroup) => void;
    onRenderTitle?: IRenderFunction<IGroupHeaderProps>;
    onToggleCollapse?: (group: IGroup) => void;
    onToggleSelectGroup?: (group: IGroup) => void;
    onToggleSummarize?: (group: IGroup) => void;
    selected?: boolean;
    selectionMode?: SelectionMode;
    showAllLinkText?: string;
    theme?: ITheme;
    viewport?: IViewport;
}

// @public (undocumented)
export interface IGroupedList extends IList {
    forceUpdate: () => void;
    toggleCollapseAll: (allCollapsed: boolean) => void;
}

// @public (undocumented)
export interface IGroupedListProps extends React.ClassAttributes<GroupedListBase> {
    className?: string;
    compact?: boolean;
    componentRef?: IRefObject<IGroupedList>;
    dragDropEvents?: IDragDropEvents;
    dragDropHelper?: IDragDropHelper;
    eventsToRegister?: {
        eventName: string;
        callback: (context: IDragDropContext, event?: any) => void;
    }[];
    getGroupHeight?: (group: IGroup, groupIndex: number) => number;
    groupProps?: IGroupRenderProps;
    groups?: IGroup[];
    items: any[];
    listProps?: IListProps;
    onGroupExpandStateChanged?: (isSomeGroupExpanded: boolean) => void;
    onRenderCell: (nestingDepth?: number, item?: any, index?: number) => React.ReactNode;
    onShouldVirtualize?: (props: IListProps) => boolean;
    selection?: ISelection;
    selectionMode?: SelectionMode;
    styles?: IStyleFunctionOrObject<IGroupedListStyleProps, IGroupedListStyles>;
    theme?: ITheme;
    usePageCache?: boolean;
    viewport?: IViewport;
}

// @public (undocumented)
export interface IGroupedListState {
    // (undocumented)
    groups?: IGroup[];
    // (undocumented)
    lastSelectionMode?: SelectionMode;
    // (undocumented)
    lastWidth?: number;
}

// @public (undocumented)
export type IGroupedListStyleProps = Required<Pick<IGroupedListProps, 'theme'>> & Pick<IGroupedListProps, 'className'> & {
    isCollapsed?: boolean;
    compact?: boolean;
};

// @public (undocumented)
export interface IGroupedListStyles {
    // (undocumented)
    group: IStyle;
    // (undocumented)
    groupIsDropping: IStyle;
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IGroupFooterProps extends IGroupDividerProps {
    styles?: IStyleFunctionOrObject<IGroupFooterStyleProps, IGroupFooterStyles>;
}

// @public (undocumented)
export type IGroupFooterStyleProps = Required<Pick<IGroupFooterProps, 'theme'>> & Pick<IGroupFooterProps, 'selected' | 'className'> & {
    isCollapsed?: boolean;
};

// @public (undocumented)
export interface IGroupFooterStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IGroupHeaderProps extends IGroupDividerProps {
    expandButtonProps?: React.HTMLAttributes<HTMLButtonElement>;
    groupedListId?: string;
    selectAllButtonProps?: React.HTMLAttributes<HTMLButtonElement>;
    styles?: IStyleFunctionOrObject<IGroupHeaderStyleProps, IGroupHeaderStyles>;
}

// @public (undocumented)
export type IGroupHeaderStyleProps = Required<Pick<IGroupHeaderProps, 'theme'>> & Pick<IGroupHeaderProps, 'selected' | 'className'> & {
    isCollapsed?: boolean;
    compact?: boolean;
};

// @public (undocumented)
export interface IGroupHeaderStyles {
    // (undocumented)
    check: IStyle;
    // (undocumented)
    dropIcon: IStyle;
    // (undocumented)
    expand: IStyle;
    // (undocumented)
    expandIsCollapsed: IStyle;
    // (undocumented)
    groupHeaderContainer: IStyle;
    // (undocumented)
    headerCount: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    title: IStyle;
}

// @public (undocumented)
export interface IGroupRenderProps {
    collapseAllVisibility?: CollapseAllVisibility;
    footerProps?: IGroupFooterProps;
    getGroupItemLimit?: (group: IGroup) => number;
    headerProps?: IGroupHeaderProps;
    isAllGroupsCollapsed?: boolean;
    onRenderFooter?: IRenderFunction<IGroupFooterProps>;
    onRenderHeader?: IRenderFunction<IGroupHeaderProps>;
    onRenderShowAll?: IRenderFunction<IGroupShowAllProps>;
    onToggleCollapseAll?: (isAllCollapsed: boolean) => void;
    showAllProps?: IGroupShowAllProps;
    showEmptyGroups?: boolean;
}

// @public (undocumented)
export interface IGroupShowAllProps extends IGroupDividerProps {
    showAllLinkText?: string;
    styles?: IStyleFunctionOrObject<IGroupShowAllStyleProps, IGroupShowAllStyles>;
}

// @public (undocumented)
export type IGroupShowAllStyleProps = Required<Pick<IGroupShowAllProps, 'theme'>>;

// @public (undocumented)
export interface IGroupShowAllStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IGroupSpacerProps {
    count: number;
    indentWidth?: number;
    // @deprecated
    styles?: IStyleFunctionOrObject<IGroupSpacerStyleProps, IGroupSpacerStyles>;
    // @deprecated
    theme?: ITheme;
}

// @public @deprecated (undocumented)
export type IGroupSpacerStyleProps = Required<Pick<IGroupSpacerProps, 'theme'>> & {
    width?: number;
};

// @public @deprecated (undocumented)
export interface IGroupSpacerStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IHoverCard {
    dismiss: (withTimeOut?: boolean) => void;
}

// @public
export interface IHoverCardProps extends React.HTMLAttributes<HTMLDivElement> {
    cardDismissDelay?: number;
    cardOpenDelay?: number;
    className?: string;
    componentRef?: IRefObject<IHoverCard>;
    eventListenerTarget?: HTMLElement | string | null;
    expandedCardOpenDelay?: number;
    expandingCardProps?: IExpandingCardProps;
    instantOpenOnClick?: boolean;
    onCardExpand?: () => void;
    onCardHide?: () => void;
    onCardVisible?: () => void;
    openHotKey?: KeyCodes;
    plainCardProps?: IPlainCardProps;
    setAriaDescribedBy?: boolean;
    setInitialFocus?: boolean;
    shouldBlockHoverCard?: () => void;
    sticky?: boolean;
    styles?: IStyleFunctionOrObject<IHoverCardStyleProps, IHoverCardStyles>;
    target?: HTMLElement | string | null;
    theme?: ITheme;
    trapFocus?: boolean;
    type?: HoverCardType;
}

// @public (undocumented)
export interface IHoverCardState {
    // (undocumented)
    isHoverCardVisible?: boolean;
    // (undocumented)
    mode?: ExpandingCardMode;
    // (undocumented)
    openMode?: OpenCardMode;
}

// @public (undocumented)
export interface IHoverCardStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IHoverCardStyles {
    host?: IStyle;
}

// @public (undocumented)
export interface IHSL {
    h: number;
    l: number;
    s: number;
}

// @public (undocumented)
export interface IHSV {
    h: number;
    s: number;
    v: number;
}

// @public (undocumented)
export interface IIconProps extends IBaseProps, React.HTMLAttributes<HTMLElement> {
    // @deprecated
    ariaLabel?: string;
    iconName?: string;
    // @deprecated
    iconType?: IconType;
    imageErrorAs?: React.ComponentType<IImageProps>;
    imageProps?: IImageProps;
    styles?: IStyleFunctionOrObject<IIconStyleProps, IIconStyles>;
    // (undocumented)
    theme?: ITheme;
}

// @public (undocumented)
export interface IIconState {
    // (undocumented)
    imageLoadError: boolean;
}

// @public (undocumented)
export interface IIconStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    iconClassName?: string;
    // (undocumented)
    isImage: boolean;
    // (undocumented)
    isPlaceholder: boolean;
    // (undocumented)
    styles?: Partial<IIconStyles>;
    // (undocumented)
    theme?: ITheme;
}

// @public (undocumented)
export interface IIconStyles {
    // @deprecated
    imageContainer?: IStyle;
    // (undocumented)
    root?: IStyle;
}

// @public (undocumented)
export interface IImage {
}

// @public
export interface IImageIconProps extends React.HTMLAttributes<HTMLElement> {
    className?: string;
    imageProps: IImageProps;
}

// @public (undocumented)
export interface IImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
    className?: string;
    coverStyle?: ImageCoverStyle;
    // @deprecated
    errorSrc?: string;
    imageFit?: ImageFit;
    maximizeFrame?: boolean;
    onLoadingStateChange?: (loadState: ImageLoadState) => void;
    shouldFadeIn?: boolean;
    shouldStartVisible?: boolean;
    styles?: IStyleFunctionOrObject<IImageStyleProps, IImageStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IImageState {
    // (undocumented)
    loadState?: ImageLoadState;
}

// @public (undocumented)
export interface IImageStyleProps {
    className?: string;
    height?: number | string;
    isCenter?: boolean;
    // (undocumented)
    isCenterContain?: boolean;
    // (undocumented)
    isCenterCover?: boolean;
    // (undocumented)
    isContain?: boolean;
    // (undocumented)
    isCover?: boolean;
    isError?: boolean;
    isLandscape?: boolean;
    isLoaded?: boolean;
    // (undocumented)
    isNone?: boolean;
    isNotImageFit?: boolean;
    maximizeFrame?: boolean;
    shouldFadeIn?: boolean;
    shouldStartVisible?: boolean;
    theme: ITheme;
    width?: number | string;
}

// @public (undocumented)
export interface IImageStyles {
    image: IStyle;
    root: IStyle;
}

// @public
export interface IInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
    'aria-label'?: string;
    defaultVisibleValue?: string;
}

// @public (undocumented)
export interface IKeytipLayer {
}

// @public (undocumented)
export interface IKeytipLayerProps extends React.ClassAttributes<IKeytipLayer> {
    componentRef?: IRefObject<IKeytipLayer>;
    content: string;
    keytipExitSequences?: IKeytipTransitionKey[];
    keytipReturnSequences?: IKeytipTransitionKey[];
    // Warning: (ae-forgotten-export) The symbol "IKeytipTransitionKey" needs to be exported by the entry point index.d.ts
    keytipStartSequences?: IKeytipTransitionKey[];
    onEnterKeytipMode?: () => void;
    onExitKeytipMode?: (ev?: React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement>) => void;
    styles?: IStyleFunctionOrObject<IKeytipLayerStyleProps, IKeytipLayerStyles>;
}

// @public (undocumented)
export interface IKeytipLayerState {
    // (undocumented)
    inKeytipMode: boolean;
    // (undocumented)
    keytips: IKeytipProps[];
    // (undocumented)
    visibleKeytips: IKeytipProps[];
}

// @public (undocumented)
export interface IKeytipLayerStyleProps {
}

// @public (undocumented)
export interface IKeytipLayerStyles {
    // (undocumented)
    innerContent: IStyle;
}

// @public (undocumented)
export interface IKeytipProps {
    calloutProps?: ICalloutProps;
    content: string;
    disabled?: boolean;
    hasDynamicChildren?: boolean;
    hasMenu?: boolean;
    keySequences: string[];
    offset?: IPoint;
    onExecute?: (executeTarget: HTMLElement | null, target: HTMLElement | null) => void;
    onReturn?: (executeTarget: HTMLElement | null, target: HTMLElement | null) => void;
    overflowSetSequence?: string[];
    styles?: IStyleFunctionOrObject<IKeytipStyleProps, IKeytipStyles>;
    theme?: ITheme;
    visible?: boolean;
}

// @public
export interface IKeytipStyleProps {
    disabled?: boolean;
    theme: ITheme;
    visible?: boolean;
}

// @public (undocumented)
export interface IKeytipStyles {
    container: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface ILabel {
}

// @public (undocumented)
export interface ILabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
    as?: IComponentAs<React.AllHTMLAttributes<HTMLElement>>;
    componentRef?: IRefObject<ILabel>;
    disabled?: boolean;
    required?: boolean;
    styles?: IStyleFunctionOrObject<ILabelStyleProps, ILabelStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface ILabelStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    required?: boolean;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface ILabelStyles {
    root: IStyle;
}

// @public (undocumented)
export interface ILayer {
}

// @public (undocumented)
export type ILayerBaseState = {
    hasMounted: boolean;
};

// @public (undocumented)
export interface ILayerProps extends React.HTMLAttributes<HTMLDivElement | LayerBase> {
    className?: string;
    componentRef?: IRefObject<ILayer>;
    eventBubblingEnabled?: boolean;
    hostId?: string;
    insertFirst?: boolean;
    onLayerDidMount?: () => void;
    onLayerMounted?: () => void;
    onLayerWillUnmount?: () => void;
    styles?: IStyleFunctionOrObject<ILayerStyleProps, ILayerStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface ILayerStyleProps {
    className?: string;
    isNotHost?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface ILayerStyles {
    content?: IStyle;
    root?: IStyle;
}

// @public
export interface ILine extends IShimmerElement {
    height?: number;
    width?: number | string;
}

// @public (undocumented)
export interface ILink {
    focus(): void;
}

// @public (undocumented)
export interface ILinkHTMLAttributes<T> extends React.HTMLAttributes<T> {
    // (undocumented)
    [index: string]: any;
    // (undocumented)
    autoFocus?: boolean;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    download?: any;
    // (undocumented)
    form?: string;
    // (undocumented)
    formAction?: string;
    // (undocumented)
    formEncType?: string;
    // (undocumented)
    formMethod?: string;
    // (undocumented)
    formNoValidate?: boolean;
    // (undocumented)
    formTarget?: string;
    // (undocumented)
    href?: string;
    // (undocumented)
    hrefLang?: string;
    // (undocumented)
    media?: string;
    // (undocumented)
    name?: string;
    // (undocumented)
    rel?: string;
    // (undocumented)
    target?: string;
    // (undocumented)
    type?: string;
    // (undocumented)
    value?: string | string[] | number;
}

// @public (undocumented)
export interface ILinkProps extends ILinkHTMLAttributes<HTMLAnchorElement | HTMLButtonElement | HTMLElement | LinkBase> {
    as?: string | React.ComponentClass | React.StatelessComponent;
    componentRef?: IRefObject<ILink>;
    disabled?: boolean;
    keytipProps?: IKeytipProps;
    styles?: IStyleFunctionOrObject<ILinkStyleProps, ILinkStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface ILinkStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    isButton?: boolean;
    // (undocumented)
    isDisabled?: boolean;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface ILinkStyles {
    // (undocumented)
    root: IStyle;
}

// @public (undocumented)
export interface IList {
    forceUpdate: () => void;
    getStartItemIndexInView: () => number;
    getTotalListHeight?: () => number;
    scrollToIndex: (index: number, measureItem?: (itemIndex: number) => number, scrollToMode?: ScrollToMode) => void;
}

// @public (undocumented)
export interface IListProps<T = any> extends React.HTMLAttributes<List<T> | HTMLDivElement> {
    className?: string;
    componentRef?: IRefObject<IList>;
    getItemCountForPage?: (itemIndex?: number, visibleRect?: IRectangle) => number;
    getKey?: (item: T, index?: number) => string;
    getPageHeight?: (itemIndex?: number, visibleRect?: IRectangle, itemCount?: number) => number;
    getPageSpecification?: (itemIndex?: number, visibleRect?: IRectangle) => IPageSpecification;
    getPageStyle?: (page: IPage<T>) => any;
    items?: T[];
    onPageAdded?: (page: IPage<T>) => void;
    onPageRemoved?: (page: IPage<T>) => void;
    onPagesUpdated?: (pages: IPage<T>[]) => void;
    onRenderCell?: (item?: T, index?: number, isScrolling?: boolean) => React.ReactNode;
    onRenderPage?: (pageProps: IPageProps<T>, defaultRender?: IRenderFunction<IPageProps<T>>) => React.ReactNode;
    onShouldVirtualize?: (props: IListProps<T>) => boolean;
    renderCount?: number;
    renderedWindowsAhead?: number;
    renderedWindowsBehind?: number;
    role?: string;
    startIndex?: number;
    usePageCache?: boolean;
}

// @public (undocumented)
export interface IListState<T = any> {
    // (undocumented)
    isScrolling?: boolean;
    measureVersion?: number;
    // (undocumented)
    pages?: IPage<T>[];
}

// @public (undocumented)
export const Image: React.StatelessComponent<IImageProps>;

// @public (undocumented)
export class ImageBase extends React.Component<IImageProps, IImageState> {
    constructor(props: IImageProps);
    // (undocumented)
    componentDidUpdate(prevProps: IImageProps, prevState: IImageState): void;
    // (undocumented)
    static defaultProps: {
        shouldFadeIn: boolean;
    };
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: IImageProps): void;
}

// @public
export enum ImageCoverStyle {
    landscape = 0,
    portrait = 1
}

// @public
export enum ImageFit {
    center = 0,
    centerContain = 5,
    centerCover = 4,
    contain = 1,
    cover = 2,
    none = 3
}

// @public
export const ImageIcon: React.FunctionComponent<IImageIconProps>;

// @public (undocumented)
export enum ImageLoadState {
    error = 2,
    // @deprecated
    errorLoaded = 3,
    loaded = 1,
    notLoaded = 0
}

// @public (undocumented)
export interface IMarqueeSelection {
}

// @public (undocumented)
export interface IMarqueeSelectionProps extends React.HTMLAttributes<HTMLDivElement> {
    className?: string;
    componentRef?: IRefObject<IMarqueeSelection>;
    isDraggingConstrainedToRoot?: boolean;
    isEnabled?: boolean;
    onShouldStartSelection?: (ev: MouseEvent) => boolean;
    rootProps?: React.HTMLAttributes<HTMLDivElement>;
    selection: ISelection;
    styles?: IStyleFunction<IMarqueeSelectionStyleProps, IMarqueeSelectionStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IMarqueeSelectionStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface IMarqueeSelectionStyles {
    // (undocumented)
    box?: IStyle;
    // (undocumented)
    boxFill?: IStyle;
    // (undocumented)
    dragMask?: IStyle;
    // (undocumented)
    root?: IStyle;
}

// @public
export interface IMaskedTextFieldState {
    displayValue: string;
    maskCursorPosition?: number;
}

// @public (undocumented)
export interface IMenuItemStyles extends IButtonStyles {
    anchorLink: IStyle;
    checkmarkIcon: IStyle;
    divider: IStyle;
    iconColor: IStyle;
    item: IStyle;
    linkContent: IStyle;
    subMenuIcon: IStyle;
}

// @public (undocumented)
export interface IMessageBar {
}

// @public (undocumented)
export interface IMessageBarProps extends React.HTMLAttributes<HTMLElement> {
    actions?: JSX.Element;
    // @deprecated
    ariaLabel?: string;
    className?: string;
    componentRef?: IRefObject<IMessageBar>;
    dismissButtonAriaLabel?: string;
    isMultiline?: boolean;
    messageBarType?: MessageBarType;
    onDismiss?: (ev?: React.MouseEvent<HTMLElement | BaseButton | Button>) => any;
    overflowButtonAriaLabel?: string;
    styles?: IStyleFunctionOrObject<IMessageBarStyleProps, IMessageBarStyles>;
    theme?: ITheme;
    truncated?: boolean;
}

// @public (undocumented)
export interface IMessageBarState {
    // (undocumented)
    expandSingleLine?: boolean;
    // (undocumented)
    labelId?: string;
    // (undocumented)
    showContent?: boolean;
}

// @public (undocumented)
export interface IMessageBarStyleProps {
    actions?: boolean;
    className?: string;
    expandSingleLine?: boolean;
    isMultiline?: boolean;
    messageBarType?: MessageBarType;
    onDismiss?: boolean;
    theme: ITheme;
    truncated?: boolean;
}

// @public (undocumented)
export interface IMessageBarStyles {
    actions?: IStyle;
    content?: IStyle;
    dismissal?: IStyle;
    dismissSingleLine?: IStyle;
    expand?: IStyle;
    expandSingleLine?: IStyle;
    icon?: IStyle;
    iconContainer?: IStyle;
    innerText?: IStyle;
    root?: IStyle;
    text?: IStyle;
}

// @public (undocumented)
export interface IModal {
    focus: () => void;
}

// @public (undocumented)
export interface IModalProps extends React.ClassAttributes<ModalBase>, IWithResponsiveModeState, IAccessiblePopupProps {
    className?: string;
    componentRef?: IRefObject<IModal>;
    containerClassName?: string;
    dragOptions?: IDragOptions;
    isBlocking?: boolean;
    isDarkOverlay?: boolean;
    isModeless?: boolean;
    isOpen?: boolean;
    layerProps?: ILayerProps;
    onDismiss?: (ev?: React.MouseEvent<HTMLButtonElement>) => any;
    onDismissed?: () => any;
    // @deprecated
    onLayerDidMount?: () => void;
    overlay?: IOverlayProps;
    scrollableContentClassName?: string;
    styles?: IStyleFunctionOrObject<IModalStyleProps, IModalStyles>;
    subtitleAriaId?: string;
    theme?: ITheme;
    titleAriaId?: string;
    topOffsetFixed?: boolean;
}

// @public (undocumented)
export type IModalStyleProps = Required<Pick<IModalProps, 'theme'>> & Pick<IModalProps, 'className' | 'containerClassName' | 'scrollableContentClassName' | 'topOffsetFixed' | 'isModeless'> & {
    isOpen?: boolean;
    isVisible?: boolean;
    hasBeenOpened?: boolean;
    modalRectangleTop?: number;
    layerClassName?: string;
    isDefaultDragHandle?: boolean;
};

// @public (undocumented)
export interface IModalStyles {
    // (undocumented)
    keyboardMoveIcon: IStyle;
    // (undocumented)
    keyboardMoveIconContainer: IStyle;
    // (undocumented)
    layer: IStyle;
    // (undocumented)
    main: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    scrollableContent: IStyle;
}

// @public (undocumented)
export interface INav {
    selectedKey: string | undefined;
}

// @public (undocumented)
export interface INavLink {
    [propertyName: string]: any;
    ariaLabel?: string;
    automationId?: string;
    disabled?: boolean;
    forceAnchor?: boolean;
    icon?: string;
    // @deprecated
    iconClassName?: string;
    iconProps?: IIconProps;
    isExpanded?: boolean;
    key?: string;
    links?: INavLink[];
    name: string;
    onClick?: (ev?: React.MouseEvent<HTMLElement>, item?: INavLink) => void;
    target?: string;
    title?: string;
    url: string;
}

// @public (undocumented)
export interface INavLinkGroup {
    automationId?: string;
    collapseByDefault?: boolean;
    links: INavLink[];
    name?: string;
    onHeaderClick?: (ev?: React.MouseEvent<HTMLElement>, isCollapsing?: boolean) => void;
}

// @public (undocumented)
export interface INavProps {
    ariaLabel?: string;
    className?: string;
    componentRef?: IRefObject<INav>;
    expandButtonAriaLabel?: string;
    groups: INavLinkGroup[] | null;
    initialSelectedKey?: string;
    isOnTop?: boolean;
    linkAs?: IComponentAs<IButtonProps>;
    onLinkClick?: (ev?: React.MouseEvent<HTMLElement>, item?: INavLink) => void;
    onLinkExpandClick?: (ev?: React.MouseEvent<HTMLElement>, item?: INavLink) => void;
    onRenderGroupHeader?: IRenderFunction<INavLinkGroup>;
    onRenderLink?: IRenderFunction<INavLink>;
    selectedAriaLabel?: string;
    selectedKey?: string;
    styles?: IStyleFunctionOrObject<INavStyleProps, INavStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface INavState {
    // (undocumented)
    isGroupCollapsed: {
        [key: string]: boolean;
    };
    // (undocumented)
    isLinkExpandStateChanged?: boolean;
    // (undocumented)
    selectedKey?: string;
}

// @public (undocumented)
export interface INavStyleProps {
    className?: string;
    groups: INavLinkGroup[] | null;
    isButtonEntry?: boolean;
    isDisabled?: boolean;
    isExpanded?: boolean;
    isGroup?: boolean;
    isLink?: boolean;
    isOnTop?: boolean;
    isSelected?: boolean;
    leftPadding?: number;
    leftPaddingExpanded?: number;
    navHeight?: number;
    position?: number;
    rightPadding?: number;
    theme: ITheme;
}

// @public (undocumented)
export interface INavStyles {
    chevronButton: IStyle;
    chevronIcon: IStyle;
    compositeLink: IStyle;
    group: IStyle;
    groupContent: IStyle;
    link: IStyle;
    linkText: IStyle;
    navItem: IStyle;
    navItems: IStyle;
    root: IStyle;
}

export { IObjectWithKey }

// @public (undocumented)
export interface IOverflowSet {
    focus(forceIntoFirstElement?: boolean): boolean;
    focusElement(childElement?: HTMLElement): boolean;
}

// @public (undocumented)
export interface IOverflowSetItemProps {
    [propertyName: string]: any;
    key: string;
    keytipProps?: IKeytipProps;
}

// @public (undocumented)
export interface IOverflowSetProps extends React.ClassAttributes<OverflowSetBase> {
    className?: string;
    componentRef?: IRefObject<IOverflowSet>;
    doNotContainWithinFocusZone?: boolean;
    focusZoneProps?: IFocusZoneProps;
    items?: IOverflowSetItemProps[];
    itemSubMenuProvider?: (item: IOverflowSetItemProps) => any[] | undefined;
    keytipSequences?: string[];
    onRenderItem: (item: IOverflowSetItemProps) => any;
    onRenderOverflowButton: IRenderFunction<any[]>;
    overflowItems?: IOverflowSetItemProps[];
    role?: string;
    styles?: IStyleFunctionOrObject<IOverflowSetProps, IOverflowSetStyles>;
    vertical?: boolean;
}

// @public
export type IOverflowSetStyleProps = Pick<IOverflowSetProps, 'vertical' | 'className'>;

// @public (undocumented)
export interface IOverflowSetStyles {
    item?: IStyle;
    overflowButton?: IStyle;
    root?: IStyle;
}

// @public (undocumented)
export interface IOverlay {
}

// @public (undocumented)
export interface IOverlayProps extends React.HTMLAttributes<HTMLElement> {
    className?: string;
    componentRef?: IRefObject<IOverlay>;
    isDarkThemed?: boolean;
    // (undocumented)
    onClick?: () => void;
    styles?: IStyleFunctionOrObject<IOverlayStyleProps, IOverlayStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IOverlayStyleProps {
    className?: string;
    isDark?: boolean;
    isNone?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IOverlayStyles {
    root: IStyle;
}

// @public
export type IOverrideColumnRenderProps = Pick<IDetailsListProps, 'onRenderItemColumn' | 'getCellValueKey'> & Pick<IDetailsRowProps, 'cellsByColumn'>;

// @public (undocumented)
export interface IPage<T = any> {
    // (undocumented)
    data?: any;
    // (undocumented)
    height: number;
    // (undocumented)
    isSpacer?: boolean;
    // (undocumented)
    isVisible?: boolean;
    // (undocumented)
    itemCount: number;
    // (undocumented)
    items: T[] | undefined;
    // (undocumented)
    key: string;
    // (undocumented)
    startIndex: number;
    // (undocumented)
    style: React.CSSProperties;
    // (undocumented)
    top: number;
}

// @public (undocumented)
export interface IPageProps<T = any> extends React.HTMLAttributes<HTMLDivElement>, React.ClassAttributes<HTMLDivElement> {
    page: IPage<T>;
    role?: string;
}

// @public (undocumented)
export interface IPageSpecification {
    data?: any;
    height?: number;
    itemCount?: number;
    key?: string;
}

// @public (undocumented)
export interface IPanel {
    dismiss: (ev?: React.KeyboardEvent<HTMLElement>) => void;
    open: () => void;
}

// @public
export interface IPanelHeaderRenderer extends IRenderFunction<IPanelProps> {
    // (undocumented)
    (props?: IPanelProps, defaultRender?: IPanelHeaderRenderer, headerTextId?: string | undefined): JSX.Element | null;
}

// Warning: (ae-forgotten-export) The symbol "PanelBase" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export interface IPanelProps extends React.HTMLAttributes<PanelBase> {
    className?: string;
    closeButtonAriaLabel?: string;
    // @deprecated
    componentId?: string;
    componentRef?: IRefObject<IPanel>;
    customWidth?: string;
    elementToFocusOnDismiss?: HTMLElement;
    // @deprecated
    firstFocusableSelector?: string;
    focusTrapZoneProps?: IFocusTrapZoneProps;
    // @deprecated
    forceFocusInsideTrap?: boolean;
    hasCloseButton?: boolean;
    headerClassName?: string;
    headerText?: string;
    // @deprecated
    ignoreExternalFocusing?: boolean;
    isBlocking?: boolean;
    isFooterAtBottom?: boolean;
    isHiddenOnDismiss?: boolean;
    isLightDismiss?: boolean;
    isOpen?: boolean;
    layerProps?: ILayerProps;
    onDismiss?: (ev?: React.SyntheticEvent<HTMLElement>) => void;
    onDismissed?: () => void;
    onLightDismissClick?: () => void;
    onOpen?: () => void;
    onOpened?: () => void;
    onOuterClick?: () => void;
    onRenderBody?: IRenderFunction<IPanelProps>;
    onRenderFooter?: IRenderFunction<IPanelProps>;
    onRenderFooterContent?: IRenderFunction<IPanelProps>;
    onRenderHeader?: IPanelHeaderRenderer;
    onRenderNavigation?: IRenderFunction<IPanelProps>;
    onRenderNavigationContent?: IRenderFunction<IPanelProps>;
    overlayProps?: IOverlayProps;
    styles?: IStyleFunctionOrObject<IPanelStyleProps, IPanelStyles>;
    theme?: ITheme;
    type?: PanelType;
}

// @public (undocumented)
export interface IPanelStyleProps {
    className?: string;
    focusTrapZoneClassName?: string;
    hasCloseButton?: boolean;
    headerClassName?: string;
    isAnimating?: boolean;
    isFooterAtBottom?: boolean;
    isFooterSticky?: boolean;
    isHiddenOnDismiss?: boolean;
    isOnRightSide?: boolean;
    isOpen?: boolean;
    theme: ITheme;
    type?: PanelType;
}

// @public (undocumented)
export interface IPanelStyles {
    closeButton: IStyle;
    commands: IStyle;
    content: IStyle;
    contentInner: IStyle;
    footer: IStyle;
    footerInner: IStyle;
    header: IStyle;
    headerText: IStyle;
    hiddenPanel: IStyle;
    main: IStyle;
    navigation: IStyle;
    overlay: IStyle;
    root: IStyle;
    scrollableContent: IStyle;
}

// @public (undocumented)
export interface IPeopleFloatingPickerProps extends IBaseFloatingPickerProps<IPersonaProps> {
}

// @public (undocumented)
export interface IPeoplePickerItemProps extends IPickerItemProps<IExtendedPersonaProps> {
}

// @public
export interface IPeoplePickerItemSelectedProps extends IPickerItemProps<IPersonaProps & {
    ValidationState: ValidationState;
}>, IPeoplePickerItemSharedProps {
    styles?: IStyleFunctionOrObject<IPeoplePickerItemSelectedStyleProps, IPeoplePickerItemSelectedStyles>;
}

// @public
export type IPeoplePickerItemSelectedStyleProps = Required<Pick<IPeoplePickerItemSelectedProps, 'theme'>> & Pick<IPeoplePickerItemSelectedProps, 'className' | 'selected' | 'disabled'> & {
    invalid?: boolean;
};

// @public
export interface IPeoplePickerItemSelectedStyles {
    itemContent: IStyle;
    removeButton: IStyle;
    root: IStyle;
    subComponentStyles: IPeoplePickerItemSelectedSubComponentStyles;
}

// @public
export interface IPeoplePickerItemSelectedSubComponentStyles {
    persona: IStyleFunctionOrObject<IPersonaStyleProps, any>;
    personaCoin?: IStyleFunctionOrObject<IPersonaCoinStyleProps, any>;
}

// @public
export interface IPeoplePickerItemSharedProps {
    className?: string;
    theme?: ITheme;
}

// @public (undocumented)
export interface IPeoplePickerItemState {
    // (undocumented)
    contextualMenuVisible: boolean;
}

// @public
export interface IPeoplePickerItemSuggestionProps extends IPeoplePickerItemSharedProps {
    compact?: boolean;
    personaProps?: IPersonaProps;
    styles?: IStyleFunctionOrObject<IPeoplePickerItemSuggestionStyleProps, IPeoplePickerItemSuggestionStyles>;
    suggestionsProps?: IBasePickerSuggestionsProps;
}

// @public
export type IPeoplePickerItemSuggestionStyleProps = Required<Pick<IPeoplePickerItemSuggestionProps, 'theme'>> & Pick<IPeoplePickerItemSuggestionProps, 'className'> & {};

// @public
export interface IPeoplePickerItemSuggestionStyles {
    personaWrapper: IStyle;
    root: IStyle;
    subComponentStyles: IPeoplePickerItemSelectedSubComponentStyles;
}

// @public @deprecated
export interface IPeoplePickerItemWithMenuProps extends IPickerItemProps<IPersonaWithMenu> {
}

// @public
export interface IPeoplePickerProps extends IBasePickerProps<IPersonaProps> {
}

// @public (undocumented)
export interface IPersona {
}

// @public (undocumented)
export interface IPersonaCoinProps extends IPersonaSharedProps {
    className?: string;
    componentRef?: IRefObject<{}>;
    styles?: IStyleFunctionOrObject<IPersonaCoinStyleProps, IPersonaCoinStyles>;
}

// @public (undocumented)
export interface IPersonaCoinStyleProps {
    className?: string;
    coinSize?: number;
    showUnknownPersonaCoin?: boolean;
    size?: PersonaSize;
    theme: ITheme;
}

// @public (undocumented)
export interface IPersonaCoinStyles {
    // (undocumented)
    coin: IStyle;
    // (undocumented)
    image: IStyle;
    // (undocumented)
    imageArea: IStyle;
    // (undocumented)
    initials: IStyle;
    // (undocumented)
    size10WithoutPresenceIcon: IStyle;
}

// @public (undocumented)
export interface IPersonaPresenceProps extends IPersonaSharedProps {
    componentRef?: IRefObject<{}>;
    styles?: IStyleFunctionOrObject<IPersonaPresenceStyleProps, IPersonaPresenceStyles>;
}

// @public (undocumented)
export type IPersonaPresenceStyleProps = Required<Pick<IPersonaSharedProps, 'theme'>> & Pick<IPersonaSharedProps, 'presence' | 'isOutOfOffice' | 'size'> & Pick<IPersonaProps, 'className'>;

// @public (undocumented)
export interface IPersonaPresenceStyles {
    // (undocumented)
    presence: IStyle;
    // (undocumented)
    presenceIcon: IStyle;
}

// @public (undocumented)
export interface IPersonaProps extends IPersonaSharedProps {
    className?: string;
    componentRef?: IRefObject<IPersona>;
    onRenderOptionalText?: IRenderFunction<IPersonaProps>;
    onRenderPrimaryText?: IRenderFunction<IPersonaProps>;
    onRenderSecondaryText?: IRenderFunction<IPersonaProps>;
    onRenderTertiaryText?: IRenderFunction<IPersonaProps>;
    styles?: IStyleFunctionOrObject<IPersonaStyleProps, IPersonaStyles>;
}

// @public (undocumented)
export interface IPersonaSharedProps extends React.HTMLAttributes<PersonaBase | PersonaCoinBase | HTMLDivElement> {
    allowPhoneInitials?: boolean;
    coinProps?: IPersonaCoinProps;
    coinSize?: number;
    hidePersonaDetails?: boolean;
    imageAlt?: string;
    imageInitials?: string;
    imageShouldFadeIn?: boolean;
    imageShouldStartVisible?: boolean;
    imageUrl?: string;
    initialsColor?: PersonaInitialsColor | string;
    isOutOfOffice?: boolean;
    onPhotoLoadingStateChange?: (newImageLoadState: ImageLoadState) => void;
    // @deprecated
    onRenderCoin?: IRenderFunction<IPersonaSharedProps>;
    onRenderInitials?: IRenderFunction<IPersonaSharedProps>;
    onRenderPersonaCoin?: IRenderFunction<IPersonaSharedProps>;
    optionalText?: string;
    presence?: PersonaPresence;
    presenceTitle?: string;
    // @deprecated
    primaryText?: string;
    secondaryText?: string;
    showInitialsUntilImageLoads?: boolean;
    // (undocumented)
    showSecondaryText?: boolean;
    showUnknownPersonaCoin?: boolean;
    size?: PersonaSize;
    tertiaryText?: string;
    text?: string;
    theme?: ITheme;
}

// @public (undocumented)
export interface IPersonaState {
    // (undocumented)
    isImageError?: boolean;
    // (undocumented)
    isImageLoaded?: boolean;
}

// @public (undocumented)
export interface IPersonaStyleProps {
    className?: string;
    coinSize?: number;
    presence?: PersonaPresence;
    // (undocumented)
    showSecondaryText?: boolean;
    size?: PersonaSize;
    theme: ITheme;
}

// @public (undocumented)
export interface IPersonaStyles {
    // (undocumented)
    details: IStyle;
    // (undocumented)
    optionalText: IStyle;
    // (undocumented)
    primaryText: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    secondaryText: IStyle;
    // (undocumented)
    tertiaryText: IStyle;
    // (undocumented)
    textContent: IStyle;
}

// @public @deprecated
export interface IPersonaWithMenu extends IPersonaProps {
    menuItems?: IContextualMenuItem[];
}

// @public
export type IPickerAriaIds = {
    selectedSuggestionAlert: string;
    selectedItems: string;
    suggestionList: string;
};

// @public
export interface IPickerItem {
}

// @public
export interface IPickerItemProps<T> extends React.AllHTMLAttributes<HTMLElement> {
    componentRef?: IRefObject<IPickerItem>;
    index: number;
    item: T;
    key?: string | number;
    onItemChange?: (item: T, index: number) => void;
    onRemoveItem?: () => void;
    removeButtonAriaLabel?: string;
    selected?: boolean;
}

// @public (undocumented)
export interface IPivot {
    focus(): void;
}

// @public (undocumented)
export interface IPivotItemProps extends React.HTMLAttributes<HTMLDivElement> {
    ariaLabel?: string;
    componentRef?: IRefObject<{}>;
    headerButtonProps?: {
        [key: string]: string | number | boolean;
    };
    headerText?: string;
    itemCount?: number | string;
    itemIcon?: string;
    itemKey?: string;
    keytipProps?: IKeytipProps;
    // @deprecated
    linkText?: string;
    onRenderItemLink?: IRenderFunction<IPivotItemProps>;
}

// @public (undocumented)
export interface IPivotProps extends React.ClassAttributes<PivotBase>, React.HTMLAttributes<HTMLDivElement> {
    className?: string;
    componentRef?: IRefObject<IPivot>;
    defaultSelectedIndex?: number;
    defaultSelectedKey?: string;
    getTabId?: (itemKey: string, index: number) => string;
    headersOnly?: boolean;
    // @deprecated
    initialSelectedIndex?: number;
    // @deprecated
    initialSelectedKey?: string;
    linkFormat?: PivotLinkFormat;
    linkSize?: PivotLinkSize;
    onLinkClick?: (item?: PivotItem, ev?: React.MouseEvent<HTMLElement>) => void;
    selectedKey?: string | null;
    styles?: IStyleFunctionOrObject<IPivotStyleProps, IPivotStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IPivotState {
    // (undocumented)
    selectedKey: string | undefined;
}

// @public (undocumented)
export type IPivotStyleProps = Required<Pick<IPivotProps, 'theme'>> & Pick<IPivotProps, 'className'> & {
    rootIsLarge?: boolean;
    rootIsTabs?: boolean;
    linkIsSelected?: boolean;
};

// @public (undocumented)
export interface IPivotStyles {
    // (undocumented)
    count: IStyle;
    // (undocumented)
    icon: IStyle;
    // (undocumented)
    itemContainer?: IStyle;
    // (undocumented)
    link: IStyle;
    // (undocumented)
    linkContent: IStyle;
    // (undocumented)
    linkIsSelected: IStyle;
    root: IStyle;
    // (undocumented)
    text: IStyle;
}

// @public (undocumented)
export interface IPlainCard {
}

// @public
export interface IPlainCardProps extends IBaseCardProps<IPlainCard, IPlainCardStyles, IPlainCardStyleProps> {
    onRenderPlainCard?: IRenderFunction<any>;
}

// @public (undocumented)
export interface IPlainCardStyleProps extends IBaseCardStyleProps {
}

// @public (undocumented)
export interface IPlainCardStyles extends IBaseCardStyles {
}

// @public (undocumented)
export interface IPopupProps extends React.HTMLAttributes<Popup> {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    className?: string;
    onDismiss?: (ev?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => any;
    role?: string;
    shouldRestoreFocus?: boolean;
}

// @public (undocumented)
export interface IPopupState {
    // (undocumented)
    needsVerticalScrollBar?: boolean;
}

// @public (undocumented)
export interface IPositioningContainer {
}

// @public (undocumented)
export interface IPositioningContainerProps extends IBaseProps<IPositioningContainer> {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    backgroundColor?: string;
    bounds?: IRectangle;
    className?: string;
    componentRef?: IRefObject<IPositioningContainer>;
    coverTarget?: boolean;
    directionalHint?: DirectionalHint;
    directionalHintFixed?: boolean;
    directionalHintForRTL?: DirectionalHint;
    doNotLayer?: boolean;
    finalHeight?: number;
    minPagePadding?: number;
    offsetFromTarget?: number;
    onDismiss?: (ev?: any) => void;
    onLayerMounted?: () => void;
    // Warning: (ae-forgotten-export) The symbol "IPositionedData" needs to be exported by the entry point index.d.ts
    onPositioned?: (positions?: IPositionedData) => void;
    positioningContainerMaxHeight?: number;
    positioningContainerWidth?: number;
    preventDismissOnScroll?: boolean;
    role?: string;
    setInitialFocus?: boolean;
    target?: HTMLElement | string | MouseEvent | IPoint | null;
    // @deprecated
    targetPoint?: IPoint;
    // @deprecated
    useTargetPoint?: boolean;
}

// @public (undocumented)
export interface IPositioningContainerState {
    heightOffset?: number;
    positions?: IPositionedData;
}

// @public @deprecated (undocumented)
export type IPositioningContainerTypes = IPositioningContainerProps;

// @public (undocumented)
export interface IProgressIndicatorProps extends React.ClassAttributes<ProgressIndicatorBase> {
    ariaValueText?: string;
    barHeight?: number;
    className?: string;
    description?: React.ReactNode;
    label?: React.ReactNode;
    onRenderProgress?: IRenderFunction<IProgressIndicatorProps>;
    percentComplete?: number;
    progressHidden?: boolean;
    styles?: IStyleFunctionOrObject<IProgressIndicatorStyleProps, IProgressIndicatorStyles>;
    theme?: ITheme;
    // @deprecated
    title?: string;
}

// @public (undocumented)
export interface IProgressIndicatorStyleProps {
    // (undocumented)
    barHeight?: number;
    className?: string;
    // (undocumented)
    indeterminate?: boolean;
    theme: ITheme;
}

// @public (undocumented)
export interface IProgressIndicatorStyles {
    // (undocumented)
    itemDescription: IStyle;
    // (undocumented)
    itemName: IStyle;
    // (undocumented)
    itemProgress: IStyle;
    // (undocumented)
    progressBar: IStyle;
    // (undocumented)
    progressTrack: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface IRating {
}

// @public
export interface IRatingProps extends React.AllHTMLAttributes<HTMLElement> {
    allowZeroStars?: boolean;
    ariaLabelFormat?: string;
    // @deprecated
    ariaLabelId?: string;
    componentRef?: IRefObject<IRating>;
    // (undocumented)
    getAriaLabel?: (rating: number, max: number) => string;
    icon?: string;
    max?: number;
    // @deprecated
    min?: number;
    onChange?: (event: React.FocusEvent<HTMLElement>, rating?: number) => void;
    // @deprecated (undocumented)
    onChanged?: (rating: number) => void;
    rating?: number;
    readOnly?: boolean;
    size?: RatingSize;
    styles?: IStyleFunctionOrObject<IRatingStyleProps, IRatingStyles>;
    theme?: ITheme;
    unselectedIcon?: string;
}

// @public (undocumented)
export interface IRatingState {
    // (undocumented)
    rating: number | null | undefined;
}

// @public (undocumented)
export interface IRatingStyleProps {
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    readOnly?: boolean;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface IRatingStyles {
    // (undocumented)
    labelText: IStyle;
    // (undocumented)
    ratingButton: IStyle;
    // (undocumented)
    ratingFocusZone: IStyle;
    // (undocumented)
    ratingStar: IStyle;
    // (undocumented)
    ratingStarBack: IStyle;
    // (undocumented)
    ratingStarFront: IStyle;
    // (undocumented)
    ratingStarIsLarge: IStyle;
    // (undocumented)
    ratingStarIsSmall: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    rootIsLarge: IStyle;
    // (undocumented)
    rootIsSmall: IStyle;
}

// @public (undocumented)
export interface IResizeGroup {
    remeasure(): void;
}

// @public (undocumented)
export interface IResizeGroupProps extends React.HTMLAttributes<ResizeGroupBase | HTMLElement> {
    className?: string;
    componentRef?: IRefObject<IResizeGroup>;
    data: any;
    dataDidRender?: (renderedData: any) => void;
    direction?: ResizeGroupDirection;
    onGrowData?: (prevData: any) => any;
    onReduceData: (prevData: any) => any;
    onRenderData: (data: any) => JSX.Element;
    // @deprecated
    styles?: IStyleFunctionOrObject<IResizeGroupStyleProps, IResizeGroupStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IResizeGroupState {
    dataToMeasure?: any;
    measureContainer?: boolean;
    renderedData?: any;
    resizeDirection?: 'grow' | 'shrink';
}

// @public (undocumented)
export interface IResizeGroupStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface IResizeGroupStyles {
    root: IStyle;
}

// @public
export interface IRGB {
    a?: number;
    b: number;
    g: number;
    r: number;
}

// @public (undocumented)
export interface IScrollablePane {
    forceLayoutUpdate(): void;
    getScrollPosition(): number;
}

// @public (undocumented)
export interface IScrollablePaneContext {
    // (undocumented)
    scrollablePane?: {
        subscribe: (handler: (container: HTMLElement, stickyContainer: HTMLElement) => void) => void;
        unsubscribe: (handler: (container: HTMLElement, stickyContainer: HTMLElement) => void) => void;
        addSticky: (sticky: Sticky) => void;
        removeSticky: (sticky: Sticky) => void;
        updateStickyRefHeights: () => void;
        sortSticky: (sticky: Sticky, sortAgain?: boolean) => void;
        notifySubscribers: (sort?: boolean) => void;
        syncScrollSticky: (sticky: Sticky) => void;
    };
}

// @public (undocumented)
export interface IScrollablePaneProps extends React.HTMLAttributes<HTMLElement | ScrollablePaneBase> {
    className?: string;
    componentRef?: IRefObject<IScrollablePane>;
    initialScrollPosition?: number;
    // (undocumented)
    scrollbarVisibility?: ScrollbarVisibility;
    styles?: IStyleFunctionOrObject<IScrollablePaneStyleProps, IScrollablePaneStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IScrollablePaneState {
    // (undocumented)
    scrollbarHeight: number;
    // (undocumented)
    scrollbarWidth: number;
    // (undocumented)
    stickyBottomHeight: number;
    // (undocumented)
    stickyTopHeight: number;
}

// @public (undocumented)
export interface IScrollablePaneStyleProps {
    className?: string;
    // (undocumented)
    scrollbarVisibility?: IScrollablePaneProps['scrollbarVisibility'];
    theme: ITheme;
}

// @public (undocumented)
export interface IScrollablePaneStyles {
    contentContainer: IStyle;
    root: IStyle;
    stickyAbove: IStyle;
    stickyBelow: IStyle;
    stickyBelowItems: IStyle;
}

// @public (undocumented)
export function isDark(color: IColor): boolean;

// @public (undocumented)
export interface ISearchBox {
    focus(): void;
    hasFocus(): boolean;
}

// @public (undocumented)
export interface ISearchBoxProps extends React.InputHTMLAttributes<HTMLInputElement> {
    ariaLabel?: string;
    className?: string;
    clearButtonProps?: IButtonProps;
    componentRef?: IRefObject<ISearchBox>;
    // @deprecated
    defaultValue?: string;
    disableAnimation?: boolean;
    iconProps?: Pick<IIconProps, Exclude<keyof IIconProps, 'className'>>;
    // @deprecated
    labelText?: string;
    onChange?: (event?: React.ChangeEvent<HTMLInputElement>, newValue?: string) => void;
    // @deprecated
    onChanged?: (newValue: any) => void;
    onClear?: (ev?: any) => void;
    onEscape?: (ev?: any) => void;
    onSearch?: (newValue: any) => void;
    placeholder?: string;
    styles?: IStyleFunctionOrObject<ISearchBoxStyleProps, ISearchBoxStyles>;
    theme?: ITheme;
    underlined?: boolean;
    value?: string;
}

// @public (undocumented)
export interface ISearchBoxState {
    // (undocumented)
    hasFocus?: boolean;
    // (undocumented)
    value?: string;
}

// @public (undocumented)
export interface ISearchBoxStyleProps {
    // (undocumented)
    className?: string;
    // (undocumented)
    disableAnimation?: boolean;
    // (undocumented)
    disabled?: boolean;
    // (undocumented)
    hasFocus?: boolean;
    // (undocumented)
    hasInput?: boolean;
    // (undocumented)
    theme: ITheme;
    // (undocumented)
    underlined?: boolean;
}

// @public (undocumented)
export interface ISearchBoxStyles {
    // (undocumented)
    clearButton?: IStyle;
    // (undocumented)
    field?: IStyle;
    // (undocumented)
    icon?: IStyle;
    // (undocumented)
    iconContainer?: IStyle;
    // (undocumented)
    root?: IStyle;
}

// @public
export interface ISelectableDroppableTextProps<TComponent, TListenerElement> extends React.HTMLAttributes<TListenerElement> {
    ariaLabel?: string;
    calloutProps?: ICalloutProps;
    className?: string;
    componentRef?: IRefObject<TComponent>;
    defaultSelectedKey?: string | number | string[] | number[] | null;
    disabled?: boolean;
    errorMessage?: string;
    id?: string;
    label?: string;
    onRenderContainer?: IRenderFunction<ISelectableDroppableTextProps<TComponent, TListenerElement>>;
    onRenderItem?: IRenderFunction<ISelectableOption>;
    onRenderList?: IRenderFunction<ISelectableDroppableTextProps<TComponent, TListenerElement>>;
    onRenderOption?: IRenderFunction<ISelectableOption>;
    openOnKeyboardFocus?: boolean;
    options?: any;
    panelProps?: IPanelProps;
    placeholder?: string;
    required?: boolean;
    selectedKey?: string | number | string[] | number[] | null;
}

// @public (undocumented)
export interface ISelectableOption {
    ariaLabel?: string;
    data?: any;
    disabled?: boolean;
    hidden?: boolean;
    index?: number;
    itemType?: SelectableOptionMenuItemType;
    key: string | number;
    selected?: boolean;
    text: string;
    title?: string;
}

// @public (undocumented)
export interface ISelectedItemProps<T> extends IPickerItemProps<T> {
    // (undocumented)
    onCopyItem: (item: T) => void;
}

// @public (undocumented)
export interface ISelectedPeopleItemProps extends ISelectedItemProps<IExtendedPersonaProps> {
    // (undocumented)
    onExpandItem?: () => void;
    // (undocumented)
    renderPersonaCoin?: IRenderFunction<IPersonaProps>;
    // (undocumented)
    renderPrimaryText?: IRenderFunction<IPersonaProps>;
}

// @public (undocumented)
export interface ISelectedPeopleProps extends IBaseSelectedItemsListProps<IExtendedPersonaProps> {
    // (undocumented)
    copyMenuItemText?: string;
    // (undocumented)
    editMenuItemText?: string;
    // (undocumented)
    floatingPickerProps?: IBaseFloatingPickerProps<IPersonaProps>;
    // (undocumented)
    getEditingItemText?: (item: IExtendedPersonaProps) => string;
    // (undocumented)
    onExpandGroup?: (item: IExtendedPersonaProps) => void;
    // (undocumented)
    onRenderFloatingPicker?: React.ComponentType<IBaseFloatingPickerProps<IPersonaProps>>;
    // (undocumented)
    removeMenuItemText?: string;
}

export { ISelection }

export { ISelectionOptions }

// @public (undocumented)
export interface ISelectionZone {
    ignoreNextFocus: () => void;
}

// @public (undocumented)
export interface ISelectionZoneProps extends React.ClassAttributes<SelectionZone> {
    componentRef?: () => void;
    disableAutoSelectOnInputElements?: boolean;
    enterModalOnTouch?: boolean;
    isSelectedOnFocus?: boolean;
    // @deprecated (undocumented)
    layout?: {};
    onItemContextMenu?: (item?: any, index?: number, ev?: Event) => void | boolean;
    onItemInvoked?: (item?: IObjectWithKey, index?: number, ev?: Event) => void;
    selection: ISelection;
    selectionMode?: SelectionMode;
    selectionPreservedOnEmptyClick?: boolean;
}

// @public (undocumented)
export interface ISeparator {
}

// @public (undocumented)
export interface ISeparatorProps extends React.HTMLAttributes<HTMLElement> {
    alignContent?: 'start' | 'center' | 'end';
    styles?: IStyleFunctionOrObject<ISeparatorStyleProps, ISeparatorStyles>;
    theme?: ITheme;
    vertical?: boolean;
}

// @public (undocumented)
export type ISeparatorStyleProps = Required<Pick<ISeparatorProps, 'theme'>> & Pick<ISeparatorProps, 'className' | 'alignContent' | 'vertical'>;

// @public (undocumented)
export interface ISeparatorStyles {
    content: IStyle;
    root: IStyle;
}

// @public (undocumented)
export interface IShimmer {
}

// @public (undocumented)
export interface IShimmerCircle {
}

// @public
export interface IShimmerCircleProps extends React.AllHTMLAttributes<HTMLElement> {
    // @deprecated
    borderStyle?: IRawStyle;
    componentRef?: IRefObject<IShimmerCircle>;
    height?: number;
    styles?: IStyleFunctionOrObject<IShimmerCircleStyleProps, IShimmerCircleStyles>;
    theme?: ITheme;
}

// @public
export type IShimmerCircleStyleProps = {
    theme: ITheme;
    height?: number;
    borderStyle?: IRawStyle;
};

// @public
export interface IShimmerCircleStyles {
    root?: IStyle;
    svg?: IStyle;
}

// @public
export interface IShimmerColors {
    background?: string;
    shimmer?: string;
    shimmerWave?: string;
}

// @public
export interface IShimmeredDetailsListProps extends Omit<IDetailsListProps, 'styles'> {
    ariaLabelForShimmer?: string;
    detailsListStyles?: IDetailsListProps['styles'];
    enableShimmer?: boolean;
    onRenderCustomPlaceholder?: (rowProps: IDetailsRowProps, index?: number, defaultRender?: (props: IDetailsRowProps) => React.ReactNode) => React.ReactNode;
    removeFadingOverlay?: boolean;
    shimmerLines?: number;
    // @deprecated
    shimmerOverlayStyles?: IStyleFunctionOrObject<IShimmeredDetailsListStyleProps, IShimmeredDetailsListStyles>;
    styles?: IStyleFunctionOrObject<IShimmeredDetailsListStyleProps, IShimmeredDetailsListStyles>;
}

// @public
export type IShimmeredDetailsListStyleProps = Required<Pick<IShimmeredDetailsListProps, 'theme'>>;

// @public
export interface IShimmeredDetailsListStyles {
    root: IStyle;
}

// @public
export interface IShimmerElement {
    height?: number;
    type: ShimmerElementType;
    verticalAlign?: 'top' | 'center' | 'bottom';
    width?: number | string;
}

// @public (undocumented)
export interface IShimmerElementsGroup {
}

// @public
export interface IShimmerElementsGroupProps extends React.AllHTMLAttributes<HTMLElement> {
    backgroundColor?: string;
    componentRef?: IRefObject<IShimmerElementsGroup>;
    flexWrap?: boolean;
    rowHeight?: number;
    shimmerElements?: IShimmerElement[];
    styles?: IStyleFunctionOrObject<IShimmerElementsGroupStyleProps, IShimmerElementsGroupStyles>;
    theme?: ITheme;
    width?: string;
}

// @public
export interface IShimmerElementsGroupStyleProps {
    flexWrap?: boolean;
    theme: ITheme;
}

// @public
export interface IShimmerElementsGroupStyles {
    root?: IStyle;
}

// @public (undocumented)
export interface IShimmerGap {
}

// @public
export interface IShimmerGapProps extends React.AllHTMLAttributes<HTMLElement> {
    // @deprecated
    borderStyle?: IRawStyle;
    componentRef?: IRefObject<IShimmerGap>;
    height?: number;
    styles?: IStyleFunctionOrObject<IShimmerGapStyleProps, IShimmerGapStyles>;
    theme?: ITheme;
    width?: number | string;
}

// @public
export type IShimmerGapStyleProps = {
    theme: ITheme;
    height?: number;
    borderStyle?: IRawStyle;
};

// @public
export interface IShimmerGapStyles {
    root?: IStyle;
}

// @public (undocumented)
export interface IShimmerLine {
}

// @public
export interface IShimmerLineProps extends React.AllHTMLAttributes<HTMLElement> {
    // @deprecated
    borderStyle?: IRawStyle;
    componentRef?: IRefObject<IShimmerLine>;
    height?: number;
    styles?: IStyleFunctionOrObject<IShimmerLineStyleProps, IShimmerLineStyles>;
    theme?: ITheme;
    width?: number | string;
}

// @public
export type IShimmerLineStyleProps = {
    theme: ITheme;
    height?: number;
    borderStyle?: IRawStyle;
};

// @public
export interface IShimmerLineStyles {
    bottomLeftCorner?: IStyle;
    bottomRightCorner?: IStyle;
    root?: IStyle;
    topLeftCorner?: IStyle;
    topRightCorner?: IStyle;
}

// @public
export interface IShimmerProps extends React.AllHTMLAttributes<HTMLElement> {
    ariaLabel?: string;
    className?: string;
    componentRef?: IRefObject<IShimmer>;
    customElementsGroup?: React.ReactNode;
    isDataLoaded?: boolean;
    shimmerColors?: IShimmerColors;
    shimmerElements?: IShimmerElement[];
    styles?: IStyleFunctionOrObject<IShimmerStyleProps, IShimmerStyles>;
    theme?: ITheme;
    width?: number | string;
}

// @public (undocumented)
export interface IShimmerState {
    contentLoaded?: boolean;
}

// @public
export interface IShimmerStyleProps {
    className?: string;
    isDataLoaded?: boolean;
    shimmerColor?: string;
    shimmerWaveColor?: string;
    theme: ITheme;
    transitionAnimationInterval?: number;
}

// @public
export interface IShimmerStyles {
    dataWrapper?: IStyle;
    root?: IStyle;
    screenReaderText?: IStyle;
    shimmerGradient?: IStyle;
    shimmerWrapper?: IStyle;
}

// @public (undocumented)
export interface ISlider {
    // (undocumented)
    focus: () => void;
    // (undocumented)
    value: number | undefined;
}

// @public (undocumented)
export interface ISliderProps extends React.ClassAttributes<SliderBase> {
    ariaLabel?: string;
    ariaValueText?: (value: number) => string;
    buttonProps?: React.HTMLAttributes<HTMLButtonElement>;
    className?: string;
    componentRef?: IRefObject<ISlider>;
    defaultValue?: number;
    disabled?: boolean;
    label?: string;
    max?: number;
    min?: number;
    onChange?: (value: number) => void;
    onChanged?: (event: MouseEvent | TouchEvent | KeyboardEvent, value: number) => void;
    originFromZero?: boolean;
    showValue?: boolean;
    snapToStep?: boolean;
    step?: number;
    styles?: IStyleFunctionOrObject<ISliderStyleProps, ISliderStyles>;
    theme?: ITheme;
    value?: number;
    valueFormat?: (value: number) => string;
    vertical?: boolean;
}

// @public (undocumented)
export interface ISliderState {
    // (undocumented)
    renderedValue?: number;
    // (undocumented)
    value?: number;
}

// @public (undocumented)
export type ISliderStyleProps = Required<Pick<ISliderProps, 'theme'>> & Pick<ISliderProps, 'className' | 'disabled' | 'vertical'> & {
    showTransitions?: boolean;
    showValue?: boolean;
    titleLabelClassName?: string;
};

// @public (undocumented)
export interface ISliderStyles {
    activeSection: IStyle;
    container: IStyle;
    inactiveSection: IStyle;
    line: IStyle;
    lineContainer: IStyle;
    root: IStyle;
    slideBox: IStyle;
    thumb: IStyle;
    titleLabel: IStyle;
    valueLabel: IStyle;
    zeroTick: IStyle;
}

// @public (undocumented)
export interface ISpinButton {
    focus: () => void;
    value?: string;
}

// @public (undocumented)
export interface ISpinButtonProps {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaPositionInSet?: number;
    ariaSetSize?: number;
    ariaValueNow?: number;
    // (undocumented)
    ariaValueText?: string;
    className?: string;
    componentRef?: IRefObject<ISpinButton>;
    decrementButtonAriaLabel?: string;
    decrementButtonIcon?: IIconProps;
    defaultValue?: string;
    disabled?: boolean;
    downArrowButtonStyles?: Partial<IButtonStyles>;
    // Warning: (ae-forgotten-export) The symbol "ISpinButtonClassNames" needs to be exported by the entry point index.d.ts
    getClassNames?: (theme: ITheme, disabled: boolean, isFocused: boolean, keyboardSpinDirection: KeyboardSpinDirection, labelPosition?: Position, className?: string) => ISpinButtonClassNames;
    iconButtonProps?: IButtonProps;
    iconProps?: IIconProps;
    incrementButtonAriaLabel?: string;
    incrementButtonIcon?: IIconProps;
    inputProps?: React.InputHTMLAttributes<HTMLElement | HTMLInputElement>;
    keytipProps?: IKeytipProps;
    label?: string;
    // Warning: (ae-forgotten-export) The symbol "Position" needs to be exported by the entry point index.d.ts
    // 
    // (undocumented)
    labelPosition?: Position;
    max?: number;
    min?: number;
    onBlur?: React.FocusEventHandler<HTMLInputElement>;
    onDecrement?: (value: string) => string | void;
    onFocus?: React.FocusEventHandler<HTMLInputElement>;
    onIncrement?: (value: string) => string | void;
    onValidate?: (value: string, event?: React.SyntheticEvent<HTMLElement>) => string | void;
    precision?: number;
    step?: number;
    styles?: Partial<ISpinButtonStyles>;
    theme?: ITheme;
    title?: string;
    upArrowButtonStyles?: Partial<IButtonStyles>;
    value?: string;
}

// @public (undocumented)
export interface ISpinButtonState {
    isFocused: boolean;
    keyboardSpinDirection: KeyboardSpinDirection;
    value: string;
}

// @public (undocumented)
export interface ISpinButtonStyles {
    arrowButtonsContainer: IStyle;
    arrowButtonsContainerDisabled: IStyle;
    icon: IStyle;
    iconDisabled: IStyle;
    input: IStyle;
    inputDisabled: IStyle;
    inputTextSelected: IStyle;
    label: IStyle;
    // @deprecated
    labelDisabled: IStyle;
    labelWrapper: IStyle;
    labelWrapperBottom: IStyle;
    labelWrapperEnd: IStyle;
    labelWrapperStart: IStyle;
    labelWrapperTop: IStyle;
    root: IStyle;
    spinButtonWrapper: IStyle;
    spinButtonWrapperDisabled: IStyle;
    spinButtonWrapperFocused: IStyle;
    spinButtonWrapperHovered: IStyle;
    spinButtonWrapperTopBottom: IStyle;
}

// @public (undocumented)
export interface ISpinner {
}

// @public
export interface ISpinnerProps extends React.HTMLAttributes<HTMLElement> {
    ariaLabel?: string;
    ariaLive?: 'assertive' | 'polite' | 'off';
    className?: string;
    componentRef?: IRefObject<ISpinner>;
    label?: string;
    labelPosition?: SpinnerLabelPosition;
    size?: SpinnerSize;
    styles?: IStyleFunctionOrObject<ISpinnerStyleProps, ISpinnerStyles>;
    theme?: ITheme;
    // @deprecated
    type?: SpinnerType;
}

// @public
export interface ISpinnerStyleProps {
    className?: string;
    labelPosition?: SpinnerLabelPosition;
    size?: SpinnerSize;
    theme: ITheme;
}

// @public
export interface ISpinnerStyles {
    circle?: IStyle;
    label?: IStyle;
    root?: IStyle;
    screenReaderText?: IStyle;
}

// @public (undocumented)
export function isRelativeUrl(url: string): boolean;

// @public (undocumented)
export type IStackComponent = IComponent<IStackProps, IStackTokens, IStackStyles>;

// @public (undocumented)
export type IStackItemComponent = IComponent<IStackItemProps, IStackItemTokens, IStackItemStyles>;

// @public (undocumented)
export interface IStackItemProps extends IStackItemSlots, IStyleableComponentProps<IStackItemProps, IStackItemTokens, IStackItemStyles> {
    align?: 'auto' | 'stretch' | 'baseline' | 'start' | 'center' | 'end';
    className?: string;
    disableShrink?: boolean;
    grow?: boolean | number | 'inherit' | 'initial' | 'unset';
    order?: number | string;
    shrink?: boolean | number | 'inherit' | 'initial' | 'unset';
    verticalFill?: boolean;
}

// @public (undocumented)
export type IStackItemSlot = ISlotProp<IStackItemProps>;

// @public (undocumented)
export interface IStackItemSlots {
    // (undocumented)
    root?: IHTMLSlot;
}

// @public (undocumented)
export type IStackItemStyles = IComponentStyles<IStackItemSlots>;

// @public (undocumented)
export type IStackItemStylesReturnType = ReturnType<Extract<IStackItemComponent['styles'], Function>>;

// @public (undocumented)
export type IStackItemTokenReturnType = ReturnType<Extract<IStackItemComponent['tokens'], Function>>;

// @public (undocumented)
export interface IStackItemTokens {
    margin?: number | string;
    padding?: number | string;
}

// @public (undocumented)
export interface IStackProps extends ISlottableProps<IStackSlots>, IStyleableComponentProps<IStackProps, IStackTokens, IStackStyles>, React.HTMLAttributes<HTMLElement> {
    as?: React.ReactType<React.HTMLAttributes<HTMLElement>>;
    disableShrink?: boolean;
    // @deprecated
    gap?: number | string;
    grow?: boolean | number | 'inherit' | 'initial' | 'unset';
    horizontal?: boolean;
    horizontalAlign?: Alignment;
    // @deprecated
    maxHeight?: number | string;
    // @deprecated
    maxWidth?: number | string;
    // @deprecated
    padding?: number | string;
    reversed?: boolean;
    verticalAlign?: Alignment;
    verticalFill?: boolean;
    wrap?: boolean;
}

// @public (undocumented)
export type IStackSlot = ISlotProp<IStackProps>;

// @public (undocumented)
export interface IStackSlots {
    inner?: IHTMLSlot;
    root?: IHTMLSlot;
}

// @public (undocumented)
export type IStackStyles = IComponentStyles<IStackSlots>;

// @public (undocumented)
export type IStackStylesReturnType = ReturnType<Extract<IStackComponent['styles'], Function>>;

// @public (undocumented)
export type IStackTokenReturnType = ReturnType<Extract<IStackComponent['tokens'], Function>>;

// @public (undocumented)
export interface IStackTokens {
    childrenGap?: number | string;
    maxHeight?: number | string;
    maxWidth?: number | string;
    padding?: number | string;
}

// @public (undocumented)
export interface IStickyContext {
    // (undocumented)
    scrollablePane: PropTypes.Requireable<object>;
}

// @public (undocumented)
export interface IStickyProps extends React.Props<Sticky> {
    componentRef?: IRefObject<IStickyProps>;
    isScrollSynced?: boolean;
    stickyBackgroundColor?: string;
    stickyClassName?: string;
    stickyPosition?: StickyPositionType;
}

// @public (undocumented)
export interface IStickyState {
    // (undocumented)
    distanceFromTop?: number;
    // (undocumented)
    isStickyBottom: boolean;
    // (undocumented)
    isStickyTop: boolean;
}

// @public
export interface ISuggestionItemProps<T> {
    className?: string;
    componentRef?: IRefObject<ISuggestionsItem>;
    id?: string;
    isSelectedOverride?: boolean;
    onClick: (ev: React.MouseEvent<HTMLButtonElement>) => void;
    onRemoveItem: (ev: React.MouseEvent<HTMLButtonElement>) => void;
    removeButtonAriaLabel?: string;
    RenderSuggestion: (item: T, suggestionItemProps: ISuggestionItemProps<T>) => JSX.Element;
    showRemoveButton?: boolean;
    styles?: IStyleFunctionOrObject<ISuggestionsItemStyleProps, ISuggestionsItemStyles>;
    suggestionModel: ISuggestionModel<T>;
    theme?: ITheme;
}

// @public
export interface ISuggestionModel<T> {
    ariaLabel?: string;
    item: T;
    selected: boolean;
}

// @public
export interface ISuggestions<T> {
    executeSelectedAction: () => void;
    focusAboveSuggestions: () => void;
    focusBelowSuggestions: () => void;
    focusSearchForMoreButton: () => void;
    hasSuggestedAction: () => boolean;
    hasSuggestedActionSelected: () => boolean;
    tryHandleKeyDown: (keyCode: number, currentSuggestionIndex: number) => boolean;
}

// @public (undocumented)
export interface ISuggestionsControlProps<T> extends React.ClassAttributes<any>, ISuggestionsCoreProps<T> {
    className?: string;
    completeSuggestion: () => void;
    footerItemsProps?: ISuggestionsHeaderFooterProps[];
    headerItemsProps?: ISuggestionsHeaderFooterProps[];
    shouldSelectFirstItem?: () => boolean;
    suggestionsFooterContainerAriaLabel?: string;
    suggestionsHeaderContainerAriaLabel?: string;
}

// @public (undocumented)
export interface ISuggestionsControlState<T> {
    // (undocumented)
    selectedFooterIndex: number;
    // (undocumented)
    selectedHeaderIndex: number;
    // (undocumented)
    suggestions: ISuggestionModel<T>[];
}

// @public (undocumented)
export interface ISuggestionsCoreProps<T> extends React.ClassAttributes<any> {
    componentRef?: IRefObject<{}>;
    onRenderSuggestion?: (props: T, suggestionItemProps: ISuggestionItemProps<T>) => JSX.Element;
    onSuggestionClick: (ev?: React.MouseEvent<HTMLElement>, item?: any, index?: number) => void;
    onSuggestionRemove?: (ev?: React.MouseEvent<HTMLElement>, item?: IPersonaProps, index?: number) => void;
    resultsMaximumNumber?: number;
    shouldLoopSelection: boolean;
    showRemoveButtons?: boolean;
    suggestions: ISuggestionModel<T>[];
    suggestionsAvailableAlertText?: string;
    suggestionsContainerAriaLabel?: string;
    suggestionsItemClassName?: string;
}

// @public (undocumented)
export interface ISuggestionsHeaderFooterItemProps {
    // (undocumented)
    className: string | undefined;
    // (undocumented)
    componentRef?: IRefObject<{}>;
    // (undocumented)
    id: string;
    // (undocumented)
    isSelected: boolean;
    // (undocumented)
    onExecute?: () => void;
    // (undocumented)
    renderItem: () => JSX.Element;
}

// @public (undocumented)
export interface ISuggestionsHeaderFooterProps {
    // (undocumented)
    ariaLabel?: string;
    // (undocumented)
    className?: string;
    // (undocumented)
    onExecute?: () => void;
    // (undocumented)
    renderItem: () => JSX.Element;
    // (undocumented)
    shouldShow: () => boolean;
}

// @public
export interface ISuggestionsItem {
}

// @public
export type ISuggestionsItemStyleProps = Required<Pick<ISuggestionItemProps<any>, 'theme'>> & Pick<ISuggestionItemProps<any>, 'className'> & {
    suggested?: boolean;
};

// @public
export interface ISuggestionsItemStyles {
    closeButton: IStyle;
    itemButton: IStyle;
    root: IStyle;
}

// @public
export interface ISuggestionsProps<T> extends React.Props<any> {
    className?: string;
    componentRef?: IRefObject<ISuggestions<T>>;
    createGenericItem?: () => void;
    forceResolveText?: string;
    isLoading?: boolean;
    isMostRecentlyUsedVisible?: boolean;
    isResultsFooterVisible?: boolean;
    isSearching?: boolean;
    loadingText?: string;
    moreSuggestionsAvailable?: boolean;
    mostRecentlyUsedHeaderText?: string;
    noResultsFoundText?: string;
    onGetMoreResults?: () => void;
    onRenderNoResultFound?: IRenderFunction<void>;
    onRenderSuggestion: (props: T, suggestionItemProps: ISuggestionItemProps<T>) => JSX.Element;
    onSuggestionClick: (ev?: React.MouseEvent<HTMLElement>, item?: any, index?: number) => void;
    onSuggestionRemove?: (ev?: React.MouseEvent<HTMLElement>, item?: T | IPersonaProps, index?: number) => void;
    refocusSuggestions?: (keyCode: KeyCodes) => void;
    removeSuggestionAriaLabel?: string;
    resultsFooter?: (props: ISuggestionsProps<T>) => JSX.Element;
    resultsFooterFull?: (props: ISuggestionsProps<T>) => JSX.Element;
    resultsMaximumNumber?: number;
    searchErrorText?: string;
    searchForMoreText?: string;
    searchingText?: string;
    showForceResolve?: () => boolean;
    showRemoveButtons?: boolean;
    styles?: IStyleFunctionOrObject<any, any>;
    suggestions: ISuggestionModel<T>[];
    suggestionsAvailableAlertText?: string;
    suggestionsClassName?: string;
    suggestionsContainerAriaLabel?: string;
    suggestionsHeaderText?: string;
    suggestionsItemClassName?: string;
    suggestionsListId?: string;
    theme?: ITheme;
}

// @public (undocumented)
export interface ISuggestionsState {
    // (undocumented)
    selectedActionType: SuggestionActionType;
}

// @public
export type ISuggestionsStyleProps = Required<Pick<ISuggestionsProps<any>, 'theme'>> & Pick<ISuggestionsProps<any>, 'className' | 'suggestionsClassName'> & {
    forceResolveButtonSelected?: boolean;
    searchForMoreButtonSelected?: boolean;
};

// @public
export interface ISuggestionsStyles {
    forceResolveButton: IStyle;
    noSuggestions: IStyle;
    root: IStyle;
    searchForMoreButton: IStyle;
    subComponentStyles: ISuggestionsSubComponentStyles;
    suggestionsAvailable: IStyle;
    suggestionsContainer: IStyle;
    title: IStyle;
}

// @public
export interface ISuggestionsSubComponentStyles {
    spinner: IStyleFunctionOrObject<ISpinnerStyleProps, any>;
}

// @public
export function isValidShade(shade?: Shade): boolean;

// @public (undocumented)
export interface ISwatchColorPickerProps {
    cellBorderWidth?: number;
    cellHeight?: number;
    cellMargin?: number;
    cellShape?: 'circle' | 'square';
    cellWidth?: number;
    className?: string;
    colorCells: IColorCellProps[];
    columnCount: number;
    disabled?: boolean;
    doNotContainWithinFocusZone?: boolean;
    focusOnHover?: boolean;
    getColorGridCellStyles?: IStyleFunctionOrObject<IColorPickerGridCellStyleProps, IColorPickerGridCellStyles>;
    id?: string;
    isControlled?: boolean;
    mouseLeaveParentSelector?: string | undefined;
    onCellFocused?: (id?: string, color?: string) => void;
    onCellHovered?: (id?: string, color?: string) => void;
    onColorChanged?: (id?: string, color?: string) => void;
    positionInSet?: number;
    selectedId?: string;
    setSize?: number;
    shouldFocusCircularNavigate?: boolean;
    styles?: IStyleFunctionOrObject<ISwatchColorPickerStyleProps, ISwatchColorPickerStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface ISwatchColorPickerState {
    // (undocumented)
    selectedIndex?: number;
}

// @public
export interface ISwatchColorPickerStyleProps {
    cellMargin?: number;
    className?: string;
    theme: ITheme;
}

// @public
export interface ISwatchColorPickerStyles {
    focusedContainer?: IStyle;
    root: IStyle;
    tableCell: IStyle;
}

// @public
export interface ITag {
    key: string;
    name: string;
}

// @public
export interface ITagItemProps extends IPickerItemProps<ITag> {
    className?: string;
    enableTagFocusInDisabledPicker?: boolean;
    styles?: IStyleFunctionOrObject<ITagItemStyleProps, ITagItemStyles>;
    theme?: ITheme;
}

// @public
export type ITagItemStyleProps = Required<Pick<ITagItemProps, 'theme'>> & Pick<ITagItemProps, 'className' | 'selected' | 'disabled'> & {};

// @public
export interface ITagItemStyles {
    close: IStyle;
    root: IStyle;
    text: IStyle;
}

// @public
export interface ITagItemSuggestionProps extends React.AllHTMLAttributes<HTMLElement> {
    className?: string;
    styles?: IStyleFunctionOrObject<ITagItemSuggestionStyleProps, ITagItemSuggestionStyles>;
    theme?: ITheme;
}

// @public
export type ITagItemSuggestionStyleProps = Required<Pick<ITagItemSuggestionProps, 'theme'>> & Pick<ITagItemSuggestionProps, 'className'> & {};

// @public
export interface ITagItemSuggestionStyles {
    suggestionTextOverflow?: IStyle;
}

// @public
export interface ITagPickerProps extends IBasePickerProps<ITag> {
}

// @public (undocumented)
export interface ITeachingBubble {
    focus(): void;
}

// @public
export interface ITeachingBubbleProps extends React.ClassAttributes<TeachingBubbleBase | TeachingBubbleContentBase>, IAccessiblePopupProps {
    ariaDescribedBy?: string;
    ariaLabelledBy?: string;
    calloutProps?: ICalloutProps;
    componentRef?: IRefObject<ITeachingBubble>;
    footerContent?: string | JSX.Element;
    hasCloseIcon?: boolean;
    hasCondensedHeadline?: boolean;
    hasSmallHeadline?: boolean;
    headline?: string;
    illustrationImage?: IImageProps;
    isWide?: boolean;
    onDismiss?: (ev?: any) => void;
    primaryButtonProps?: IButtonProps;
    secondaryButtonProps?: IButtonProps;
    styles?: IStyleFunctionOrObject<ITeachingBubbleStyleProps, ITeachingBubbleStyles>;
    target?: Target;
    // @deprecated (undocumented)
    targetElement?: HTMLElement;
    theme?: ITheme;
}

// @public (undocumented)
export interface ITeachingBubbleState {
    // (undocumented)
    isTeachingBubbleVisible?: boolean;
}

// @public (undocumented)
export type ITeachingBubbleStyleProps = Required<Pick<ITeachingBubbleProps, 'theme'>> & Pick<ITeachingBubbleProps, 'hasCondensedHeadline' | 'hasSmallHeadline' | 'isWide'> & {
    calloutClassName?: string;
    primaryButtonClassName?: string;
    secondaryButtonClassName?: string;
};

// @public (undocumented)
export interface ITeachingBubbleStyles {
    // (undocumented)
    body: IStyle;
    // (undocumented)
    bodyContent: IStyle;
    // (undocumented)
    closeButton: IStyle;
    // (undocumented)
    content: IStyle;
    // (undocumented)
    footer: IStyle;
    // (undocumented)
    header: IStyle;
    // (undocumented)
    headline: IStyle;
    // (undocumented)
    imageContent: IStyle;
    // (undocumented)
    primaryButton: IStyle;
    // (undocumented)
    root: IStyle;
    // (undocumented)
    secondaryButton: IStyle;
    // (undocumented)
    subComponentStyles?: ITeachingBubbleSubComponentStyles;
    // (undocumented)
    subText: IStyle;
}

// @public (undocumented)
export interface ITeachingBubbleSubComponentStyles {
    callout: IStyleFunctionOrObject<any, any>;
}

// @public (undocumented)
export type ITextComponent = IComponent<ITextProps, ITextTokens, ITextStyles>;

// @public (undocumented)
export interface ITextField {
    blur: () => void;
    focus: () => void;
    select: () => void;
    selectionEnd: number | null;
    selectionStart: number | null;
    setSelectionEnd: (value: number) => void;
    setSelectionRange: (start: number, end: number) => void;
    setSelectionStart: (value: number) => void;
    value: string | undefined;
}

// @public
export interface ITextFieldProps extends React.AllHTMLAttributes<HTMLInputElement | HTMLTextAreaElement> {
    ariaLabel?: string;
    autoAdjustHeight?: boolean;
    autoComplete?: string;
    borderless?: boolean;
    className?: string;
    componentRef?: IRefObject<ITextField>;
    defaultValue?: string;
    deferredValidationTime?: number;
    description?: string;
    disabled?: boolean;
    errorMessage?: string | JSX.Element;
    iconProps?: IIconProps;
    inputClassName?: string;
    label?: string;
    mask?: string;
    maskChar?: string;
    maskFormat?: {
        [key: string]: RegExp;
    };
    multiline?: boolean;
    onChange?: (event: React.FormEvent<HTMLInputElement | HTMLTextAreaElement>, newValue?: string) => void;
    onGetErrorMessage?: (value: string) => string | JSX.Element | PromiseLike<string | JSX.Element> | undefined;
    onNotifyValidationResult?: (errorMessage: string | JSX.Element, value: string | undefined) => void;
    onRenderDescription?: IRenderFunction<ITextFieldProps>;
    onRenderLabel?: IRenderFunction<ITextFieldProps>;
    onRenderPrefix?: IRenderFunction<ITextFieldProps>;
    onRenderSuffix?: IRenderFunction<ITextFieldProps>;
    prefix?: string;
    readOnly?: boolean;
    resizable?: boolean;
    styles?: IStyleFunctionOrObject<ITextFieldStyleProps, ITextFieldStyles>;
    suffix?: string;
    theme?: ITheme;
    underlined?: boolean;
    validateOnFocusIn?: boolean;
    validateOnFocusOut?: boolean;
    validateOnLoad?: boolean;
    value?: string;
}

// Warning: (ae-internal-missing-underscore) The name "ITextFieldSnapshot" should be prefixed with an underscore because the declaration is marked as @internal
// 
// @internal (undocumented)
export interface ITextFieldSnapshot {
    selection?: [number | null, number | null];
}

// Warning: (ae-internal-missing-underscore) The name "ITextFieldState" should be prefixed with an underscore because the declaration is marked as @internal
// 
// @internal (undocumented)
export interface ITextFieldState {
    errorMessage: string | JSX.Element;
    isFocused?: boolean;
    uncontrolledValue: string | undefined;
}

// @public (undocumented)
export type ITextFieldStyleProps = Required<Pick<ITextFieldProps, 'theme'>> & Pick<ITextFieldProps, 'className' | 'disabled' | 'inputClassName' | 'required' | 'multiline' | 'borderless' | 'resizable' | 'underlined' | 'autoAdjustHeight'> & {
    hasErrorMessage?: boolean;
    hasIcon?: boolean;
    hasLabel?: boolean;
    focused?: boolean;
};

// @public (undocumented)
export interface ITextFieldStyles extends IStyleSet<ITextFieldStyles> {
    description: IStyle;
    errorMessage: IStyle;
    field: IStyle;
    fieldGroup: IStyle;
    icon: IStyle;
    prefix: IStyle;
    root: IStyle;
    subComponentStyles: ITextFieldSubComponentStyles;
    suffix: IStyle;
    wrapper: IStyle;
}

// @public (undocumented)
export interface ITextFieldSubComponentStyles {
    label: IStyleFunctionOrObject<any, any>;
}

// @public
export interface ITextProps extends ISlottableProps<ITextSlots>, IStyleableComponentProps<ITextProps, ITextTokens, ITextStyles>, React.HTMLAttributes<HTMLElement> {
    as?: React.ReactType<React.HTMLAttributes<HTMLElement>>;
    block?: boolean;
    nowrap?: boolean;
    variant?: keyof IFontStyles;
}

// @public (undocumented)
export type ITextSlot = ISlotProp<ITextProps, string>;

// @public (undocumented)
export interface ITextSlots {
    // (undocumented)
    root?: IHTMLSlot;
}

// @public (undocumented)
export type ITextStyles = IComponentStyles<ITextSlots>;

// @public (undocumented)
export type ITextStylesReturnType = ReturnType<Extract<ITextComponent['styles'], Function>>;

// @public (undocumented)
export type ITextTokenReturnType = ReturnType<Extract<ITextComponent['tokens'], Function>>;

// @public (undocumented)
export interface ITextTokens {
}

// @public (undocumented)
export interface IThemeRules {
    // (undocumented)
    [key: string]: IThemeSlotRule;
}

// @public (undocumented)
export interface IThemeSlotRule {
    // (undocumented)
    asShade?: Shade;
    // (undocumented)
    color?: IColor;
    // (undocumented)
    dependentRules: IThemeSlotRule[];
    // (undocumented)
    inherits?: IThemeSlotRule;
    // (undocumented)
    isBackgroundShade?: boolean;
    // (undocumented)
    isCustomized?: boolean;
    // (undocumented)
    name: string;
    // (undocumented)
    value?: string;
}

// @public (undocumented)
export interface IToggle {
    // (undocumented)
    focus: () => void;
}

// @public
export interface IToggleProps extends React.HTMLAttributes<HTMLElement> {
    ariaLabel?: string;
    as?: IComponentAs<React.HTMLAttributes<HTMLElement>>;
    checked?: boolean;
    componentRef?: IRefObject<IToggle>;
    defaultChecked?: boolean;
    disabled?: boolean;
    inlineLabel?: boolean;
    keytipProps?: IKeytipProps;
    label?: string | JSX.Element;
    // @deprecated (undocumented)
    offAriaLabel?: string;
    offText?: string;
    // @deprecated (undocumented)
    onAriaLabel?: string;
    onChange?: (event: React.MouseEvent<HTMLElement>, checked?: boolean) => void;
    // @deprecated (undocumented)
    onChanged?: (checked: boolean) => void;
    onText?: string;
    styles?: IStyleFunctionOrObject<IToggleStyleProps, IToggleStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export interface IToggleState {
    // (undocumented)
    checked: boolean;
}

// @public
export interface IToggleStyleProps {
    checked?: boolean;
    className?: string;
    disabled?: boolean;
    inlineLabel?: boolean;
    onOffMissing?: boolean;
    theme: ITheme;
}

// @public
export interface IToggleStyles {
    container: IStyle;
    label: IStyle;
    pill: IStyle;
    root: IStyle;
    text: IStyle;
    thumb: IStyle;
}

// @public (undocumented)
export interface ITooltip {
}

// @public (undocumented)
export interface ITooltipHost {
    dismiss: () => void;
    show: () => void;
}

// @public
export interface ITooltipHostProps extends React.HTMLAttributes<HTMLDivElement | TooltipHostBase> {
    calloutProps?: ICalloutProps;
    closeDelay?: number;
    componentRef?: IRefObject<ITooltipHost>;
    content?: string | JSX.Element | JSX.Element[];
    delay?: TooltipDelay;
    directionalHint?: DirectionalHint;
    directionalHintForRTL?: DirectionalHint;
    hostClassName?: string;
    onTooltipToggle?(isTooltipVisible: boolean): void;
    overflowMode?: TooltipOverflowMode;
    setAriaDescribedBy?: boolean;
    styles?: IStyleFunctionOrObject<ITooltipHostStyleProps, ITooltipHostStyles>;
    theme?: ITheme;
    tooltipProps?: ITooltipProps;
}

// @public (undocumented)
export interface ITooltipHostState {
    // (undocumented)
    isTooltipVisible: boolean;
}

// @public (undocumented)
export interface ITooltipHostStyleProps {
    className?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface ITooltipHostStyles {
    root: IStyle;
}

// @public
export interface ITooltipProps extends React.HTMLAttributes<HTMLDivElement | TooltipBase> {
    calloutProps?: ICalloutProps;
    componentRef?: IRefObject<ITooltip>;
    content?: string | JSX.Element | JSX.Element[];
    delay?: TooltipDelay;
    directionalHint?: DirectionalHint;
    directionalHintForRTL?: DirectionalHint;
    maxWidth?: string | null;
    onRenderContent?: IRenderFunction<ITooltipProps>;
    styles?: IStyleFunctionOrObject<ITooltipStyleProps, ITooltipStyles>;
    targetElement?: HTMLElement;
    theme?: ITheme;
}

// @public (undocumented)
export interface ITooltipStyleProps {
    beakWidth?: number;
    className?: string;
    // @deprecated
    delay?: TooltipDelay;
    gapSpace?: number;
    maxWidth?: string;
    theme: ITheme;
}

// @public (undocumented)
export interface ITooltipStyles {
    content: IStyle;
    root: IStyle;
    subText: IStyle;
}

// @public @deprecated (undocumented)
export interface IVerticalDividerClassNames {
    divider: string;
    wrapper: string;
}

// @public
export interface IVerticalDividerProps {
    className?: string;
    // @deprecated (undocumented)
    getClassNames?: (theme: ITheme) => IVerticalDividerClassNames;
    styles?: IStyleFunctionOrObject<IVerticalDividerPropsStyles, IVerticalDividerStyles>;
    theme?: ITheme;
}

// @public
export type IVerticalDividerPropsStyles = Pick<IVerticalDividerProps, 'theme' | 'getClassNames' | 'className'>;

// @public
export interface IVerticalDividerStyles {
    divider: IStyle;
    wrapper: IStyle;
}

// @public
export interface IViewport {
    height: number;
    width: number;
}

// @public
export interface IWithViewportProps {
    skipViewportMeasures?: boolean;
}

// @public (undocumented)
export enum KeyboardSpinDirection {
    // (undocumented)
    down = -1,
    // (undocumented)
    notSpinning = 0,
    // (undocumented)
    up = 1
}

// @public
export class Keytip extends React.Component<IKeytipProps, {}> {
    // (undocumented)
    render(): JSX.Element;
}

// Warning: (ae-forgotten-export) The symbol "IKeytipDataProps" needs to be exported by the entry point index.d.ts
// 
// @public
export class KeytipData extends React.Component<IKeytipDataProps & IRenderComponent<{}>, {}> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IKeytipDataProps & IRenderComponent<{}>): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export const KeytipLayer: React.StatelessComponent<IKeytipLayerProps>;

// @public
export class KeytipLayerBase extends BaseComponent<IKeytipLayerProps, IKeytipLayerState> {
    constructor(props: IKeytipLayerProps, context: any);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: IKeytipLayerProps;
    // (undocumented)
    getCurrentSequence(): string;
    // Warning: (ae-forgotten-export) The symbol "KeytipTree" needs to be exported by the entry point index.d.ts
    // 
    // (undocumented)
    getKeytipTree(): KeytipTree;
    processInput(key: string, ev?: React.KeyboardEvent<HTMLElement>): void;
    processTransitionInput(transitionKey: IKeytipTransitionKey, ev?: React.KeyboardEvent<HTMLElement>): void;
    // (undocumented)
    render(): JSX.Element;
    showKeytips(ids: string[]): void;
    }

// @public (undocumented)
export const Label: React.StatelessComponent<ILabelProps>;

// @public (undocumented)
export class LabelBase extends React.Component<ILabelProps, {}> {
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const Layer: React.StatelessComponent<ILayerProps>;

// @public (undocumented)
export class LayerBase extends React.Component<ILayerProps, ILayerBaseState> {
    constructor(props: ILayerProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: ILayerProps;
    // (undocumented)
    render(): React.ReactNode;
    // (undocumented)
    UNSAFE_componentWillMount(): void;
    // (undocumented)
    UNSAFE_componentWillUpdate(): void;
}

// Warning: (ae-forgotten-export) The symbol "ILayerHostProps" needs to be exported by the entry point index.d.ts
// 
// @public (undocumented)
export class LayerHost extends React.Component<ILayerHostProps> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    shouldComponentUpdate(): boolean;
}

// @public (undocumented)
export const Link: React.StatelessComponent<ILinkProps>;

// @public (undocumented)
export class LinkBase extends BaseComponent<ILinkProps, any> implements ILink {
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
}

// @public
export class List<T = any> extends React.Component<IListProps<T>, IListState<T>> implements IList {
    constructor(props: IListProps<T>);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        startIndex: number;
        onRenderCell: (item: any, index: number, containsFocus: boolean) => JSX.Element;
        renderedWindowsAhead: number;
        renderedWindowsBehind: number;
    };
    // (undocumented)
    forceUpdate(): void;
    // (undocumented)
    getStartItemIndexInView(measureItem?: (itemIndex: number) => number): number;
    getTotalListHeight(): number;
    // (undocumented)
    refs: {
        [key: string]: React.ReactInstance;
    };
    // (undocumented)
    render(): JSX.Element;
    scrollToIndex(index: number, measureItem?: (itemIndex: number) => number, scrollToMode?: ScrollToMode): void;
    // (undocumented)
    shouldComponentUpdate(newProps: IListProps<T>, newState: IListState<T>): boolean;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IListProps<T>): void;
    }

// @public (undocumented)
export const ListPeoplePicker: React.FunctionComponent<IPeoplePickerProps>;

// @public
export class ListPeoplePickerBase extends MemberListPeoplePicker {
    static defaultProps: {
        onRenderItem: (props: IPeoplePickerItemSelectedProps) => JSX.Element;
        onRenderSuggestionsItem: (personaProps: IPersonaProps, suggestionsProps?: IBasePickerSuggestionsProps<any> | undefined) => JSX.Element;
        createGenericItem: typeof createGenericItem;
    };
}

// @public (undocumented)
export const MarqueeSelection: React.StatelessComponent<IMarqueeSelectionProps>;

// @public (undocumented)
export class MaskedTextField extends React.Component<ITextFieldProps, IMaskedTextFieldState> implements ITextField {
    constructor(props: ITextFieldProps);
    // (undocumented)
    blur(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    static defaultProps: ITextFieldProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    select(): void;
    // (undocumented)
    readonly selectionEnd: number | null;
    // (undocumented)
    readonly selectionStart: number | null;
    // (undocumented)
    setSelectionEnd(value: number): void;
    // (undocumented)
    setSelectionRange(start: number, end: number): void;
    // (undocumented)
    setSelectionStart(value: number): void;
    // (undocumented)
    setValue(newValue: string): void;
    protected _skipComponentRefResolution: boolean;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: ITextFieldProps): void;
    // (undocumented)
    readonly value: string | undefined;
}

// @public (undocumented)
export const MAX_COLOR_ALPHA = 100;

// @public (undocumented)
export const MAX_COLOR_HUE = 359;

// @public (undocumented)
export const MAX_COLOR_RGB = 255;

// @public @deprecated (undocumented)
export const MAX_COLOR_RGBA = 255;

// @public (undocumented)
export const MAX_COLOR_SATURATION = 100;

// @public (undocumented)
export const MAX_COLOR_VALUE = 100;

// @public
export const MAX_HEX_LENGTH = 6;

// @public
export const MAX_RGBA_LENGTH = 3;

// @public (undocumented)
export const MeasuredContext: React.Context<{
    isMeasured: boolean;
}>;

// @public (undocumented)
export class MemberListPeoplePicker extends BasePickerListBelow<IPersonaProps, IPeoplePickerProps> {
}

// @public (undocumented)
export const MessageBar: React.StatelessComponent<IMessageBarProps>;

// @public (undocumented)
export class MessageBarBase extends BaseComponent<IMessageBarProps, IMessageBarState> {
    constructor(props: IMessageBarProps);
    // (undocumented)
    static defaultProps: IMessageBarProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export class MessageBarButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export enum MessageBarType {
    blocked = 2,
    error = 1,
    info = 0,
    // @deprecated
    remove = 90000,
    severeWarning = 3,
    success = 4,
    warning = 5
}

// @public
export const MIN_HEX_LENGTH = 3;

// @public
export const MIN_RGBA_LENGTH = 1;

// @public (undocumented)
export const Modal: React.StatelessComponent<IModalProps>;

// @public (undocumented)
export class ModalBase extends BaseComponent<IModalProps, IDialogState> implements IModal {
    constructor(props: IModalProps);
    // (undocumented)
    componentDidUpdate(prevProps: IModalProps, prevState: IDialogState): void;
    // (undocumented)
    static defaultProps: IModalProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element | null;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: IModalProps): void;
}

// @public (undocumented)
export const mru: IExtendedPersonaProps[];

// @public (undocumented)
export const Nav: React.StatelessComponent<INavProps>;

// @public (undocumented)
export class NavBase extends React.Component<INavProps, INavState> implements INav {
    constructor(props: INavProps);
    // (undocumented)
    static defaultProps: INavProps;
    // (undocumented)
    render(): JSX.Element | null;
    // (undocumented)
    readonly selectedKey: string | undefined;
    }

// @public (undocumented)
export const NormalPeoplePicker: React.FunctionComponent<IPeoplePickerProps>;

// @public
export class NormalPeoplePickerBase extends BasePeoplePicker {
    static defaultProps: {
        onRenderItem: (props: IPeoplePickerItemSelectedProps) => JSX.Element;
        onRenderSuggestionsItem: (personaProps: IPersonaProps, suggestionsProps?: IBasePickerSuggestionsProps<any> | undefined) => JSX.Element;
        createGenericItem: typeof createGenericItem;
    };
}

// @public @deprecated (undocumented)
export type OnChangeCallback = IChoiceGroupOptionProps['onChange'];

// @public @deprecated (undocumented)
export type OnFocusCallback = IChoiceGroupOptionProps['onFocus'];

// @public (undocumented)
export const ONKEYDOWN_TIMEOUT_DURATION = 1000;

// @public (undocumented)
export enum OpenCardMode {
    hotKey = 1,
    hover = 0
}

// @public (undocumented)
export enum OverflowButtonType {
    descriptive = 1,
    downArrow = 3,
    more = 2,
    none = 0
}

// @public (undocumented)
export const OverflowSet: React.StatelessComponent<IOverflowSetProps>;

// @public (undocumented)
export class OverflowSetBase extends BaseComponent<IOverflowSetProps, {}> implements IOverflowSet {
    constructor(props: IOverflowSetProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: Pick<IOverflowSetProps, 'vertical' | 'role'>;
    focus(forceIntoFirstElement?: boolean): boolean;
    focusElement(childElement?: HTMLElement): boolean;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillUpdate(): void;
}

// @public (undocumented)
export const Overlay: React.StatelessComponent<IOverlayProps>;

// @public (undocumented)
export class OverlayBase extends BaseComponent<IOverlayProps, {}> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
}

// @public
export const Panel: React.StatelessComponent<IPanelProps>;

// @public (undocumented)
export enum PanelType {
    custom = 7,
    customNear = 8,
    extraLarge = 6,
    large = 4,
    largeFixed = 5,
    medium = 3,
    smallFixedFar = 1,
    smallFixedNear = 2,
    smallFluid = 0
}

// @public (undocumented)
export const people: (IExtendedPersonaProps & {
    key: string | number;
})[];

// @public (undocumented)
export const PeoplePickerItem: React.FunctionComponent<IPeoplePickerItemSelectedProps>;

// @public (undocumented)
export const PeoplePickerItemBase: (props: IPeoplePickerItemSelectedProps) => JSX.Element;

// @public (undocumented)
export const PeoplePickerItemSuggestion: React.FunctionComponent<IPeoplePickerItemSuggestionProps>;

// @public (undocumented)
export const PeoplePickerItemSuggestionBase: (props: IPeoplePickerItemSuggestionProps) => JSX.Element;

// @public
export const Persona: React.StatelessComponent<IPersonaProps>;

// @public
export class PersonaBase extends BaseComponent<IPersonaProps, {}> {
    constructor(props: IPersonaProps);
    // (undocumented)
    static defaultProps: IPersonaProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @public
export const PersonaCoin: React.StatelessComponent<IPersonaCoinProps>;

// @public
export class PersonaCoinBase extends BaseComponent<IPersonaCoinProps, IPersonaState> {
    constructor(props: IPersonaCoinProps);
    // (undocumented)
    static defaultProps: IPersonaCoinProps;
    // (undocumented)
    render(): JSX.Element | null;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: IPersonaCoinProps): void;
}

// @public (undocumented)
export enum PersonaInitialsColor {
    // @deprecated
    black = 11,
    // (undocumented)
    blue = 1,
    // (undocumented)
    burgundy = 19,
    // (undocumented)
    coolGray = 21,
    // (undocumented)
    cyan = 23,
    // (undocumented)
    darkBlue = 2,
    // (undocumented)
    darkGreen = 6,
    // (undocumented)
    darkRed = 14,
    // (undocumented)
    gold = 18,
    gray = 22,
    // (undocumented)
    green = 5,
    // (undocumented)
    lightBlue = 0,
    // (undocumented)
    lightGreen = 4,
    // (undocumented)
    lightPink = 7,
    // (undocumented)
    lightRed = 17,
    // (undocumented)
    magenta = 9,
    // (undocumented)
    orange = 12,
    // (undocumented)
    pink = 8,
    // (undocumented)
    purple = 10,
    // @deprecated
    red = 13,
    // (undocumented)
    rust = 24,
    // (undocumented)
    teal = 3,
    transparent = 15,
    // (undocumented)
    violet = 16,
    // (undocumented)
    warmGray = 20
}

// @public (undocumented)
export enum PersonaPresence {
    // (undocumented)
    away = 3,
    // (undocumented)
    blocked = 5,
    // (undocumented)
    busy = 6,
    // (undocumented)
    dnd = 4,
    // (undocumented)
    none = 0,
    // (undocumented)
    offline = 1,
    // (undocumented)
    online = 2
}

// @public (undocumented)
export namespace personaPresenceSize {
    const // (undocumented)
    size6 = "6px";
    const // (undocumented)
    size8 = "8px";
    const // (undocumented)
    size12 = "12px";
    const // (undocumented)
    size16 = "16px";
    const // (undocumented)
    size20 = "20px";
    const // (undocumented)
    size28 = "28px";
    const // @deprecated (undocumented)
    border = "2px";
}

// @public (undocumented)
export enum PersonaSize {
    // @deprecated
    extraExtraSmall = 1,
    // @deprecated
    extraLarge = 6,
    // @deprecated
    extraSmall = 2,
    // @deprecated
    large = 5,
    // @deprecated
    regular = 4,
    // @deprecated
    size10 = 9,
    size100 = 15,
    // @deprecated
    size16 = 8,
    size24 = 10,
    // @deprecated
    size28 = 7,
    size32 = 11,
    size40 = 12,
    size48 = 13,
    size56 = 16,
    size72 = 14,
    size8 = 17,
    // @deprecated
    small = 3,
    // @deprecated
    tiny = 0
}

// @public (undocumented)
export namespace personaSize {
    const // (undocumented)
    size8 = "20px";
    const // (undocumented)
    size10 = "20px";
    const // (undocumented)
    size16 = "16px";
    const // (undocumented)
    size24 = "24px";
    const // (undocumented)
    size28 = "28px";
    const // (undocumented)
    size32 = "32px";
    const // (undocumented)
    size40 = "40px";
    const // (undocumented)
    size48 = "48px";
    const // (undocumented)
    size56 = "56px";
    const // (undocumented)
    size72 = "72px";
    const // (undocumented)
    size100 = "100px";
}

// @public
export const Pivot: React.StatelessComponent<IPivotProps>;

// @public
export class PivotBase extends BaseComponent<IPivotProps, IPivotState> {
    constructor(props: IPivotProps);
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export class PivotItem extends BaseComponent<IPivotItemProps, {}> {
    constructor(props: IPivotItemProps);
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export enum PivotLinkFormat {
    links = 0,
    tabs = 1
}

// @public (undocumented)
export enum PivotLinkSize {
    large = 1,
    normal = 0
}

// @public (undocumented)
export const PlainCard: React.StatelessComponent<IPlainCardProps>;

// @public (undocumented)
export class PlainCardBase extends BaseComponent<IPlainCardProps, {}> {
    // (undocumented)
    render(): JSX.Element;
}

// @public
export class Popup extends React.Component<IPopupProps, IPopupState> {
    constructor(props: IPopupProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: IPopupProps;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    _root: React.RefObject<HTMLDivElement>;
    // (undocumented)
    UNSAFE_componentWillMount(): void;
    }

// @public (undocumented)
export class PositioningContainer extends BaseComponent<IPositioningContainerProps, IPositioningContainerState> implements PositioningContainer {
    constructor(props: IPositioningContainerProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    static defaultProps: IPositioningContainerProps;
    // @deprecated
    dismiss: (ev?: Event | React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement, MouseEvent> | undefined) => void;
    // (undocumented)
    protected _dismissOnLostFocus(ev: Event): void;
    // (undocumented)
    protected _dismissOnScroll(ev: Event): void;
    // (undocumented)
    protected _onComponentDidMount: () => void;
    // (undocumented)
    onResize: (ev?: Event | React.KeyboardEvent<HTMLElement> | React.MouseEvent<HTMLElement, MouseEvent> | undefined) => void;
    // (undocumented)
    render(): JSX.Element | null;
    // (undocumented)
    protected _setInitialFocus: () => void;
    // (undocumented)
    UNSAFE_componentWillMount(): void;
    // (undocumented)
    UNSAFE_componentWillUpdate(newProps: IPositioningContainerProps): void;
    }

// @public (undocumented)
export const presenceBoolean: (presence: PersonaPresence) => {
    isAvailable: boolean;
    isAway: boolean;
    isBlocked: boolean;
    isBusy: boolean;
    isDoNotDisturb: boolean;
    isOffline: boolean;
};

// @public (undocumented)
export class PrimaryButton extends BaseComponent<IButtonProps, {}> {
    // (undocumented)
    render(): JSX.Element;
    protected _skipComponentRefResolution: boolean;
}

// @public
export const ProgressIndicator: React.StatelessComponent<IProgressIndicatorProps>;

// @public
export class ProgressIndicatorBase extends React.Component<IProgressIndicatorProps, {}> {
    // (undocumented)
    static defaultProps: {
        label: string;
        description: string;
        width: number;
    };
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const Rating: React.StatelessComponent<IRatingProps>;

// @public (undocumented)
export class RatingBase extends React.Component<IRatingProps, IRatingState> {
    constructor(props: IRatingProps);
    // (undocumented)
    static defaultProps: IRatingProps;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export enum RatingSize {
    // (undocumented)
    Large = 1,
    // (undocumented)
    Small = 0
}

// @public (undocumented)
export const ResizeGroup: typeof ResizeGroupBase;

// @public (undocumented)
export class ResizeGroupBase extends BaseComponent<IResizeGroupProps, IResizeGroupState> {
    constructor(props: IResizeGroupProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IResizeGroupProps): void;
    // (undocumented)
    remeasure(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(nextProps: IResizeGroupProps): void;
    }

// @public (undocumented)
export enum ResizeGroupDirection {
    // (undocumented)
    horizontal = 0,
    // (undocumented)
    vertical = 1
}

// @public (undocumented)
export enum ResponsiveMode {
    // (undocumented)
    large = 2,
    // (undocumented)
    medium = 1,
    // (undocumented)
    small = 0,
    // (undocumented)
    xLarge = 3,
    // (undocumented)
    xxLarge = 4,
    // (undocumented)
    xxxLarge = 5
}

// @public
export function rgb2hex(r: number, g: number, b: number): string;

// @public
export function rgb2hsv(r: number, g: number, b: number): IHSV;

// @public
export const RGBA_REGEX: RegExp;

// @public (undocumented)
export const ScrollablePane: React.StatelessComponent<IScrollablePaneProps>;

// @public (undocumented)
export class ScrollablePaneBase extends BaseComponent<IScrollablePaneProps, IScrollablePaneState> implements IScrollablePane {
    constructor(props: IScrollablePaneProps);
    // (undocumented)
    addSticky: (sticky: Sticky) => void;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IScrollablePaneProps, prevState: IScrollablePaneState): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    readonly contentContainer: HTMLDivElement | null;
    // (undocumented)
    forceLayoutUpdate(): void;
    // (undocumented)
    getScrollPosition: () => number;
    // (undocumented)
    notifySubscribers: () => void;
    // (undocumented)
    removeSticky: (sticky: Sticky) => void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    readonly root: HTMLDivElement | null;
    // (undocumented)
    setStickiesDistanceFromTop(): void;
    // (undocumented)
    shouldComponentUpdate(nextProps: IScrollablePaneProps, nextState: IScrollablePaneState): boolean;
    // (undocumented)
    sortSticky: (sticky: Sticky, sortAgain?: boolean | undefined) => void;
    // (undocumented)
    readonly stickyAbove: HTMLDivElement | null;
    // (undocumented)
    readonly stickyBelow: HTMLDivElement | null;
    // (undocumented)
    subscribe: (handler: Function) => void;
    // (undocumented)
    syncScrollSticky: (sticky: Sticky) => void;
    // (undocumented)
    unsubscribe: (handler: Function) => void;
    // (undocumented)
    updateStickyRefHeights: () => void;
}

// @public (undocumented)
export const ScrollablePaneContext: React.Context<IScrollablePaneContext>;

// @public (undocumented)
export const ScrollbarVisibility: {
    auto: "auto";
    always: "always";
};

// @public (undocumented)
export type ScrollbarVisibility = typeof ScrollbarVisibility[keyof typeof ScrollbarVisibility];

// @public (undocumented)
export const ScrollToMode: {
    auto: 0;
    top: 1;
    bottom: 2;
    center: 3;
};

// @public (undocumented)
export type ScrollToMode = typeof ScrollToMode[keyof typeof ScrollToMode];

// @public (undocumented)
export const SearchBox: React.StatelessComponent<ISearchBoxProps>;

// @public (undocumented)
export class SearchBoxBase extends React.Component<ISearchBoxProps, ISearchBoxState> {
    constructor(props: ISearchBoxProps);
    // (undocumented)
    static defaultProps: Pick<ISearchBoxProps, 'disableAnimation' | 'clearButtonProps'>;
    focus(): void;
    hasFocus(): boolean;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillMount(): void;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: ISearchBoxProps): void;
}

// @public (undocumented)
enum SelectableOptionMenuItemType {
    // (undocumented)
    Divider = 1,
    // (undocumented)
    Header = 2,
    // (undocumented)
    Normal = 0
}

export { SelectableOptionMenuItemType as DropdownMenuItemType }

export { SelectableOptionMenuItemType }

// @public (undocumented)
export enum SelectAllVisibility {
    // (undocumented)
    hidden = 1,
    // (undocumented)
    none = 0,
    // (undocumented)
    visible = 2
}

// @public
export class SelectedPeopleList extends BasePeopleSelectedItemsList {
    // (undocumented)
    static defaultProps: any;
    // (undocumented)
    protected renderItems: () => JSX.Element[];
}

export { Selection }

export { SELECTION_CHANGE }

export { SelectionDirection }

export { SelectionMode }

// @public (undocumented)
export class SelectionZone extends BaseComponent<ISelectionZoneProps, {}> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    static defaultProps: {
        isSelectedOnFocus: boolean;
        selectionMode: SelectionMode;
    };
    ignoreNextFocus: () => void;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export enum SemanticColorSlots {
    // (undocumented)
    bodyBackground = 0,
    // (undocumented)
    bodyText = 1,
    // (undocumented)
    disabledBackground = 2,
    // (undocumented)
    disabledText = 3
}

// @public (undocumented)
export const Separator: React.StatelessComponent<ISeparatorProps>;

// @public (undocumented)
export const SeparatorBase: React.StatelessComponent<ISeparatorProps>;

// @public
export enum Shade {
    // (undocumented)
    Shade1 = 1,
    // (undocumented)
    Shade2 = 2,
    // (undocumented)
    Shade3 = 3,
    // (undocumented)
    Shade4 = 4,
    // (undocumented)
    Shade5 = 5,
    // (undocumented)
    Shade6 = 6,
    // (undocumented)
    Shade7 = 7,
    // (undocumented)
    Shade8 = 8,
    // (undocumented)
    Unshaded = 0
}

// @public (undocumented)
export const Shimmer: React.StatelessComponent<IShimmerProps>;

// @public (undocumented)
export class ShimmerBase extends React.Component<IShimmerProps, IShimmerState> {
    constructor(props: IShimmerProps);
    // (undocumented)
    componentDidUpdate(prevProps: IShimmerProps): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: IShimmerProps;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export const ShimmerCircle: React.StatelessComponent<IShimmerCircleProps>;

// @public (undocumented)
export const ShimmerCircleBase: React.FunctionComponent<IShimmerCircleProps>;

// @public (undocumented)
export const ShimmeredDetailsList: React.StatelessComponent<IShimmeredDetailsListProps>;

// @public (undocumented)
export class ShimmeredDetailsListBase extends React.Component<IShimmeredDetailsListProps, {}> {
    constructor(props: IShimmeredDetailsListProps);
    // (undocumented)
    render(): JSX.Element;
    }

// @public
export enum ShimmerElementsDefaultHeights {
    circle = 24,
    gap = 16,
    line = 16
}

// @public (undocumented)
export const ShimmerElementsGroup: React.StatelessComponent<IShimmerElementsGroupProps>;

// @public (undocumented)
export const ShimmerElementsGroupBase: React.FunctionComponent<IShimmerElementsGroupProps>;

// @public
export enum ShimmerElementType {
    circle = 2,
    gap = 3,
    line = 1
}

// @public (undocumented)
export const ShimmerGap: React.StatelessComponent<IShimmerGapProps>;

// @public (undocumented)
export const ShimmerGapBase: React.FunctionComponent<IShimmerGapProps>;

// @public (undocumented)
export const ShimmerLine: React.StatelessComponent<IShimmerLineProps>;

// @public (undocumented)
export const ShimmerLineBase: React.FunctionComponent<IShimmerLineProps>;

// @public (undocumented)
export const sizeBoolean: (size: PersonaSize) => {
    isSize8: boolean;
    isSize10: boolean;
    isSize16: boolean;
    isSize24: boolean;
    isSize28: boolean;
    isSize32: boolean;
    isSize40: boolean;
    isSize48: boolean;
    isSize56: boolean;
    isSize72: boolean;
    isSize100: boolean;
};

// @public (undocumented)
export const sizeToPixels: {
    [key: number]: number;
};

// @public (undocumented)
export const Slider: React.StatelessComponent<ISliderProps>;

// @public (undocumented)
export class SliderBase extends BaseComponent<ISliderProps, ISliderState> implements ISlider {
    constructor(props: ISliderProps);
    // (undocumented)
    static defaultProps: ISliderProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): React.ReactElement<{}>;
    // (undocumented)
    readonly value: number | undefined;
}

// @public (undocumented)
export class SpinButton extends React.Component<ISpinButtonProps, ISpinButtonState> implements ISpinButton {
    constructor(props: ISpinButtonProps);
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: DefaultProps;
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    UNSAFE_componentWillReceiveProps(newProps: ISpinButtonProps): void;
    readonly value: string | undefined;
    }

// @public (undocumented)
export const Spinner: React.StatelessComponent<ISpinnerProps>;

// @public (undocumented)
export class SpinnerBase extends BaseComponent<ISpinnerProps, any> {
    // (undocumented)
    static defaultProps: ISpinnerProps;
    // (undocumented)
    render(): JSX.Element;
}

// @public
export type SpinnerLabelPosition = 'top' | 'right' | 'bottom' | 'left';

// @public
export enum SpinnerSize {
    large = 3,
    medium = 2,
    small = 1,
    xSmall = 0
}

// @public @deprecated
export enum SpinnerType {
    // @deprecated
    large = 1,
    // @deprecated
    normal = 0
}

// @public (undocumented)
export const Stack: React.StatelessComponent<IStackProps> & {
    Item: React.StatelessComponent<IStackItemProps>;
};

// @public (undocumented)
export const StackItem: React.StatelessComponent<IStackItemProps>;

// @public (undocumented)
export class Sticky extends BaseComponent<IStickyProps, IStickyState> {
    constructor(props: IStickyProps);
    // (undocumented)
    addSticky(stickyContent: HTMLDivElement): void;
    // (undocumented)
    readonly canStickyBottom: boolean;
    // (undocumented)
    readonly canStickyTop: boolean;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: IStickyProps, prevState: IStickyState): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static contextType: React.Context<IScrollablePaneContext>;
    // (undocumented)
    static defaultProps: IStickyProps;
    // (undocumented)
    readonly nonStickyContent: HTMLDivElement | null;
    // (undocumented)
    readonly placeholder: HTMLDivElement | null;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    resetSticky(): void;
    // (undocumented)
    readonly root: HTMLDivElement | null;
    // (undocumented)
    setDistanceFromTop(container: HTMLDivElement): void;
    // (undocumented)
    shouldComponentUpdate(nextProps: IStickyProps, nextState: IStickyState): boolean;
    // (undocumented)
    readonly stickyContentBottom: HTMLDivElement | null;
    // (undocumented)
    readonly stickyContentTop: HTMLDivElement | null;
    // (undocumented)
    syncScroll: (container: HTMLElement) => void;
}

// @public (undocumented)
export enum StickyPositionType {
    // (undocumented)
    Both = 0,
    // (undocumented)
    Footer = 2,
    // (undocumented)
    Header = 1
}

// @public
export enum SuggestionActionType {
    forceResolve = 1,
    none = 0,
    searchMore = 2
}

// @public (undocumented)
export enum SuggestionItemType {
    // (undocumented)
    footer = 2,
    // (undocumented)
    header = 0,
    // (undocumented)
    suggestion = 1
}

// @public (undocumented)
export class Suggestions<T> extends BaseComponent<ISuggestionsProps<T>, ISuggestionsState> {
    constructor(suggestionsProps: ISuggestionsProps<T>);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    executeSelectedAction(): void;
    // (undocumented)
    focusAboveSuggestions(): void;
    // (undocumented)
    focusBelowSuggestions(): void;
    // (undocumented)
    focusSearchForMoreButton(): void;
    // (undocumented)
    protected _forceResolveButton: React.RefObject<IButton>;
    // (undocumented)
    hasSuggestedAction(): boolean;
    // (undocumented)
    hasSuggestedActionSelected(): boolean;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    scrollSelected(): void;
    // (undocumented)
    protected _searchForMoreButton: React.RefObject<IButton>;
    // (undocumented)
    protected _selectedElement: React.RefObject<HTMLDivElement>;
    tryHandleKeyDown: (keyCode: number, currentSuggestionIndex: number) => boolean;
}

// @public
export class SuggestionsControl<T> extends BaseComponent<ISuggestionsControlProps<T>, ISuggestionsControlState<T>> {
    constructor(suggestionsProps: ISuggestionsControlProps<T>);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    readonly currentSuggestion: ISuggestionModel<T>;
    // (undocumented)
    readonly currentSuggestionIndex: number;
    // (undocumented)
    executeSelectedAction(): void;
    // (undocumented)
    protected _forceResolveButton: IButton;
    handleKeyDown(keyCode: number): boolean;
    // (undocumented)
    hasSelection(): boolean;
    // (undocumented)
    hasSuggestionSelected(): boolean;
    // (undocumented)
    removeSuggestion(index?: number): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    protected renderFooterItems(): JSX.Element | null;
    // (undocumented)
    protected renderHeaderItems(): JSX.Element | null;
    // (undocumented)
    protected _renderSuggestions(): JSX.Element;
    protected resetSelectedItem(): void;
    // (undocumented)
    scrollSelected(): void;
    // (undocumented)
    protected _searchForMoreButton: IButton;
    // (undocumented)
    readonly selectedElement: HTMLDivElement | undefined;
    // (undocumented)
    protected _selectedElement: HTMLDivElement;
    protected selectFirstItem(): void;
    protected selectLastItem(): void;
    protected selectNextItem(itemType: SuggestionItemType, originalItemType?: SuggestionItemType): void;
    protected selectPreviousItem(itemType: SuggestionItemType, originalItemType?: SuggestionItemType): void;
    // (undocumented)
    protected _suggestions: SuggestionsCore<T>;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: ISuggestionsControlProps<T>): void;
}

// @public (undocumented)
export class SuggestionsController<T> {
    constructor();
    // (undocumented)
    convertSuggestionsToSuggestionItems(suggestions: Array<ISuggestionModel<T> | T>): ISuggestionModel<T>[];
    // (undocumented)
    createGenericSuggestion(itemToConvert: ISuggestionModel<T> | T): void;
    // (undocumented)
    currentIndex: number;
    // (undocumented)
    currentSuggestion: ISuggestionModel<T> | undefined;
    // (undocumented)
    deselectAllSuggestions(): void;
    // (undocumented)
    getCurrentItem(): ISuggestionModel<T>;
    // (undocumented)
    getSuggestionAtIndex(index: number): ISuggestionModel<T>;
    // (undocumented)
    getSuggestions(): ISuggestionModel<T>[];
    // (undocumented)
    hasSelectedSuggestion(): boolean;
    nextSuggestion(): boolean;
    previousSuggestion(): boolean;
    // (undocumented)
    removeSuggestion(index: number): void;
    // (undocumented)
    setSelectedSuggestion(index: number): void;
    // (undocumented)
    suggestions: ISuggestionModel<T>[];
    // (undocumented)
    updateSuggestions(newSuggestions: T[], selectedIndex?: number): void;
}

// @public
export class SuggestionsCore<T> extends BaseComponent<ISuggestionsCoreProps<T>, {}> {
    constructor(suggestionsProps: ISuggestionsCoreProps<T>);
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    currentIndex: number;
    // (undocumented)
    currentSuggestion: ISuggestionModel<T> | undefined;
    // (undocumented)
    deselectAllSuggestions(): void;
    // (undocumented)
    getCurrentItem(): ISuggestionModel<T>;
    // (undocumented)
    getSuggestionAtIndex(index: number): ISuggestionModel<T>;
    // (undocumented)
    hasSuggestionSelected(): boolean;
    nextSuggestion(): boolean;
    previousSuggestion(): boolean;
    // (undocumented)
    removeSuggestion(index: number): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    scrollSelected(): void;
    // (undocumented)
    readonly selectedElement: HTMLDivElement | undefined;
    // (undocumented)
    protected _selectedElement: HTMLDivElement;
    // (undocumented)
    setSelectedSuggestion(index: number): void;
    }

// @public (undocumented)
export class SuggestionsHeaderFooterItem extends BaseComponent<ISuggestionsHeaderFooterItemProps, {}> {
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export class SuggestionsItem<T> extends BaseComponent<ISuggestionItemProps<T>, {}> {
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export class SuggestionsStore<T> {
    constructor(options?: SuggestionsStoreOptions<T>);
    // (undocumented)
    convertSuggestionsToSuggestionItems(suggestions: Array<ISuggestionModel<T> | T>): ISuggestionModel<T>[];
    // (undocumented)
    getSuggestionAtIndex(index: number): ISuggestionModel<T>;
    // (undocumented)
    getSuggestions(): ISuggestionModel<T>[];
    // (undocumented)
    removeSuggestion(index: number): void;
    // (undocumented)
    suggestions: ISuggestionModel<T>[];
    // (undocumented)
    updateSuggestions(newSuggestions: T[]): void;
}

// @public (undocumented)
export type SuggestionsStoreOptions<T> = {
    getAriaLabel?: (item: T) => string;
};

// @public (undocumented)
export const SwatchColorPicker: React.StatelessComponent<ISwatchColorPickerProps>;

// @public (undocumented)
export class SwatchColorPickerBase extends React.Component<ISwatchColorPickerProps, ISwatchColorPickerState> {
    constructor(props: ISwatchColorPickerProps);
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: ISwatchColorPickerProps;
    // (undocumented)
    render(): JSX.Element | null;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: ISwatchColorPickerProps): void;
}

// @public (undocumented)
export const TagItem: React.FunctionComponent<ITagItemProps>;

// @public (undocumented)
export const TagItemBase: (props: ITagItemProps) => JSX.Element;

// @public (undocumented)
export const TagItemSuggestion: React.FunctionComponent<ITagItemSuggestionProps>;

// @public (undocumented)
export const TagItemSuggestionBase: (props: ITagItemSuggestionProps) => JSX.Element;

// @public (undocumented)
export const TagPicker: React.FunctionComponent<ITagPickerProps>;

// @public (undocumented)
export class TagPickerBase extends BasePicker<ITag, ITagPickerProps> {
    // (undocumented)
    static defaultProps: {
        onRenderItem: (props: ITagItemProps) => JSX.Element;
        onRenderSuggestionsItem: (props: ITag) => JSX.Element;
    };
}

// @public (undocumented)
export type Target = Element | string | MouseEvent | IPoint | null | React.RefObject<Element>;

// @public (undocumented)
export const TeachingBubble: React.StatelessComponent<ITeachingBubbleProps>;

// @public (undocumented)
export class TeachingBubbleBase extends BaseComponent<ITeachingBubbleProps, ITeachingBubbleState> {
    constructor(props: ITeachingBubbleProps);
    // (undocumented)
    static defaultProps: {
        calloutProps: {
            beakWidth: number;
            gapSpace: number;
            setInitialFocus: boolean;
            doNotLayer: boolean;
            directionalHint: 12;
        };
    };
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    rootElement: React.RefObject<HTMLDivElement>;
}

// @public (undocumented)
export const TeachingBubbleContent: React.StatelessComponent<ITeachingBubbleProps>;

// @public (undocumented)
export class TeachingBubbleContentBase extends BaseComponent<ITeachingBubbleProps, ITeachingBubbleState> {
    constructor(props: ITeachingBubbleProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        hasCondensedHeadline: boolean;
        imageProps: {
            imageFit: ImageFit;
            width: number;
            height: number;
        };
    };
    // (undocumented)
    focus(): void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    rootElement: React.RefObject<HTMLDivElement>;
}

// @public (undocumented)
export const Text: React.StatelessComponent<ITextProps>;

// @public (undocumented)
export const TextField: React.StatelessComponent<ITextFieldProps>;

// Warning: (ae-incompatible-release-tags) The symbol "TextFieldBase" is marked as @public, but its signature references "ITextFieldState" which is marked as @internal
// Warning: (ae-incompatible-release-tags) The symbol "TextFieldBase" is marked as @public, but its signature references "ITextFieldSnapshot" which is marked as @internal
// 
// @public (undocumented)
export class TextFieldBase extends React.Component<ITextFieldProps, ITextFieldState, ITextFieldSnapshot> implements ITextField {
    constructor(props: ITextFieldProps);
    blur(): void;
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: ITextFieldProps, prevState: ITextFieldState, snapshot: ITextFieldSnapshot): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: ITextFieldProps;
    focus(): void;
    // (undocumented)
    getSnapshotBeforeUpdate(prevProps: ITextFieldProps, prevState: ITextFieldState): ITextFieldSnapshot | null;
    // (undocumented)
    render(): JSX.Element;
    select(): void;
    readonly selectionEnd: number | null;
    readonly selectionStart: number | null;
    setSelectionEnd(value: number): void;
    setSelectionRange(start: number, end: number): void;
    setSelectionStart(value: number): void;
    readonly value: string | undefined;
    }

// @public (undocumented)
export const TextStyles: ITextComponent['styles'];

// @public (undocumented)
export const TextView: ITextComponent['view'];

// @public (undocumented)
export class ThemeGenerator {
    // (undocumented)
    static getThemeAsCode(slotRules: IThemeRules): any;
    // (undocumented)
    static getThemeAsJson(slotRules: IThemeRules): any;
    // (undocumented)
    static getThemeAsSass(slotRules: IThemeRules): any;
    // (undocumented)
    static getThemeForPowerShell(slotRules: IThemeRules): any;
    // (undocumented)
    static insureSlots(slotRules: IThemeRules, isInverted: boolean): void;
    // (undocumented)
    static setSlot(rule: IThemeSlotRule, color: string | IColor, isInverted?: boolean, isCustomization?: boolean, overwriteCustomColor?: boolean): void;
    }

// @public (undocumented)
export function themeRulesStandardCreator(): IThemeRules;

// @public (undocumented)
export const Toggle: React.StatelessComponent<IToggleProps>;

// @public (undocumented)
export class ToggleBase extends BaseComponent<IToggleProps, IToggleState> implements IToggle {
    constructor(props: IToggleProps);
    readonly checked: boolean;
    // (undocumented)
    focus(): void;
    // (undocumented)
    static getDerivedStateFromProps(props: IToggleProps, state: IToggleState): IToggleState;
    // (undocumented)
    render(): JSX.Element;
    }

// @public (undocumented)
export const Tooltip: React.StatelessComponent<ITooltipProps>;

// @public (undocumented)
export class TooltipBase extends React.Component<ITooltipProps, any> {
    // (undocumented)
    static defaultProps: Partial<ITooltipProps>;
    // (undocumented)
    render(): JSX.Element;
}

// @public (undocumented)
export enum TooltipDelay {
    // (undocumented)
    long = 2,
    // (undocumented)
    medium = 1,
    // (undocumented)
    zero = 0
}

// @public (undocumented)
export const TooltipHost: React.StatelessComponent<ITooltipHostProps>;

// @public (undocumented)
export class TooltipHostBase extends React.Component<ITooltipHostProps, ITooltipHostState> implements ITooltipHost {
    constructor(props: ITooltipHostProps);
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        delay: TooltipDelay;
    };
    // (undocumented)
    dismiss: () => void;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    show: () => void;
    }

// @public (undocumented)
export enum TooltipOverflowMode {
    Parent = 0,
    Self = 1
}

// @public
export function updateA(color: IColor, a: number): IColor;

// @public
export function updateH(color: IColor, h: number): IColor;

// @public
export function updateRGB(color: IColor, component: keyof IRGB, value: number): IColor;

// @public
export function updateSV(color: IColor, s: number, v: number): IColor;

// @public
export enum ValidationState {
    invalid = 2,
    valid = 0,
    warning = 1
}

// @public (undocumented)
export const VerticalDivider: React.StatelessComponent<IVerticalDividerProps>;

// @public (undocumented)
export class VirtualizedComboBox extends BaseComponent<IComboBoxProps, {}> implements IComboBox {
    // (undocumented)
    dismissMenu(): void;
    // (undocumented)
    focus(): boolean;
    // (undocumented)
    protected _onRenderList: (props: IComboBoxProps) => JSX.Element;
    // (undocumented)
    protected _onScrollToItem: (itemIndex: number) => void;
    // (undocumented)
    render(): JSX.Element;
    readonly selectedOptions: IComboBoxOption[];
}


export * from "@uifabric/icons";
export * from "@uifabric/styling";
export * from "@uifabric/utilities";

// Warnings were encountered during analysis:
// 
// lib/components/ColorPicker/ColorPicker.base.d.ts:8:9 - (ae-forgotten-export) The symbol "IRGBHex" needs to be exported by the entry point index.d.ts

// (No @packageDocumentation comment for this package)

```
