## API Report File for "@fluentui/react-next"

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

```ts

import { BaseSlots } from '@fluentui/react-compose';
import { ComposePreparedOptions } from '@fluentui/react-compose';
import { IBaseFloatingPickerProps } from 'office-ui-fabric-react/lib/FloatingPicker';
import { IBaseProps } from 'office-ui-fabric-react/lib/Utilities';
import { IButtonProps } from '@fluentui/react-next/lib/compat/Button';
import { IButtonProps as IButtonProps_2 } from 'office-ui-fabric-react/lib/components/Button/Button.types';
import { IButtonStyles } from '@fluentui/react-next/lib/compat/Button';
import { ICalloutPositionedInfo } from 'office-ui-fabric-react/lib/utilities/positioning';
import { IComponentAs } from 'office-ui-fabric-react/lib/Utilities';
import { IContextualMenuProps } from 'office-ui-fabric-react/lib/ContextualMenu';
import { IFocusZoneProps } from '@fluentui/react-focus';
import { IIconProps } from 'office-ui-fabric-react/lib/Icon';
import { IKeytipProps } from 'office-ui-fabric-react/lib/Keytip';
import { ILayerProps } from 'office-ui-fabric-react/lib/Layer';
import { IObjectWithKey } from 'office-ui-fabric-react/lib/Utilities';
import { IOverlayProps } from 'office-ui-fabric-react/lib/Overlay';
import { IPickerItemProps } from 'office-ui-fabric-react/lib/Pickers';
import { IPositionedData } from 'office-ui-fabric-react/lib/utilities/positioning';
import { IRectangle } from 'office-ui-fabric-react/lib/Utilities';
import { IRefObject } from 'office-ui-fabric-react/lib/Utilities';
import { IRenderFunction } from 'office-ui-fabric-react/lib/Utilities';
import { IStyle } from 'office-ui-fabric-react/lib/Styling';
import { IStyleFunctionOrObject } from 'office-ui-fabric-react/lib/Utilities';
import { IStyleSet } from 'office-ui-fabric-react/lib/Styling';
import { ISuggestionModel } from 'office-ui-fabric-react/lib/Pickers';
import { ISvgIconProps } from '@fluentui/react-icons';
import { ITeachingBubble } from 'office-ui-fabric-react/lib/TeachingBubble';
import { ITheme } from 'office-ui-fabric-react/lib/Styling';
import { IWithResponsiveModeState } from 'office-ui-fabric-react/lib/utilities/decorators/withResponsiveMode';
import { Point } from 'office-ui-fabric-react/lib/Utilities';
import { Position } from 'office-ui-fabric-react/lib/utilities/positioning';
import * as React from 'react';
import { ReactNode } from 'react';
import { Selection } from 'office-ui-fabric-react/lib/Selection';
import { SlotProp } from '@fluentui/react-compose';
import { SlotProps } from '@fluentui/react-compose';
import { ValidationState } from 'office-ui-fabric-react/lib/Pickers';

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

// @public (undocumented)
export class BaseSelectedItemsList<T, P extends IBaseSelectedItemsListProps<T>> extends React.Component<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<IObjectWithKey>): void;
    // (undocumented)
    unselectAll(): void;
    updateItems(items: T[], focusIndex?: number): void;
}

// @public (undocumented)
export const Callout: React.ForwardRefExoticComponent<ICalloutProps & React.RefAttributes<HTMLDivElement>>;

// @public (undocumented)
export const Checkbox: import("@fluentui/react-compose").ComponentWithAs<"div", ICheckboxProps>;

// @public (undocumented)
export const CheckboxBase: import("@fluentui/react-compose").ComponentWithAs<"div", ICheckboxProps>;

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

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

// @public (undocumented)
export const CoachmarkBase: React.ForwardRefExoticComponent<ICoachmarkProps & React.RefAttributes<HTMLDivElement>>;

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

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

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

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

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

// @public (undocumented)
export const FabricBase: React.ForwardRefExoticComponent<IFabricProps & React.RefAttributes<HTMLDivElement>>;

// @public
export const FocusTrapCallout: React.FunctionComponent<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
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 (undocumented)
export interface IAccessiblePopupProps {
    closeButtonAriaLabel?: string;
    elementToFocusOnDismiss?: HTMLElement;
    firstFocusableSelector?: string | (() => string);
    forceFocusInsideTrap?: boolean;
    ignoreExternalFocusing?: boolean;
    isClickableOutsideFocusTrap?: boolean;
}

// @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[]) => T | PromiseLike<T> | T[] | PromiseLike<T[]>;
    onRenderItem?: (props: ISelectedItemProps<T>) => JSX.Element;
    removeButtonAriaLabel?: string;
    selectedItems?: T[];
    selection?: Selection;
}

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

// @public (undocumented)
export interface ICalloutContentStyleProps {
    backgroundColor?: string;
    beakWidth?: number;
    calloutMaxWidth?: number;
    calloutWidth?: number;
    className?: string;
    overflowYHidden?: boolean;
    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 | ((target?: Target, targetWindow?: Window) => IRectangle | undefined);
    calloutMaxHeight?: number;
    calloutMaxWidth?: number;
    calloutWidth?: number;
    className?: string;
    coverTarget?: boolean;
    // Warning: (ae-forgotten-export) The symbol "DirectionalHint" needs to be exported by the entry point index.d.ts
    directionalHint?: DirectionalHint;
    directionalHintFixed?: boolean;
    directionalHintForRTL?: DirectionalHint;
    doNotLayer?: boolean;
    finalHeight?: number;
    gapSpace?: number;
    hidden?: boolean;
    hideOverflow?: boolean;
    isBeakVisible?: boolean;
    layerProps?: ILayerProps;
    minPagePadding?: number;
    onDismiss?: (ev?: Event | React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
    onLayerMounted?: () => void;
    onPositioned?: (positions?: ICalloutPositionedInfo) => void;
    onRestoreFocus?: (options: {
        originalElement?: HTMLElement | Window;
        containsFocus: boolean;
    }) => void;
    onScroll?: () => void;
    preventDismissOnLostFocus?: boolean;
    preventDismissOnResize?: boolean;
    preventDismissOnScroll?: boolean;
    role?: string;
    setInitialFocus?: boolean;
    // @deprecated
    shouldRestoreFocus?: boolean;
    shouldUpdateWhenHidden?: boolean;
    style?: React.CSSProperties;
    styles?: IStyleFunctionOrObject<ICalloutContentStyleProps, ICalloutContentStyles>;
    target?: Target;
    theme?: ITheme;
}

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

// @public (undocumented)
export type ICheckboxClasses = {
    [key in keyof ICheckboxSlots]: string;
};

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

// @public (undocumented)
export type ICheckboxSlotProps = SlotProps<ICheckboxSlots, ICheckboxProps, React.HTMLAttributes<HTMLDivElement>>;

// @public (undocumented)
export interface ICheckboxSlots extends BaseSlots {
    // (undocumented)
    checkbox: React.ElementType;
    // (undocumented)
    checkmark: React.ElementType;
    // (undocumented)
    container: React.ElementType;
    // (undocumented)
    input: React.ElementType;
    // (undocumented)
    label: React.ElementType;
}

// @public (undocumented)
export interface ICheckboxState extends Omit<ICheckboxProps, keyof ICheckboxSlotProps>, Partial<ICheckboxSlotProps> {
    // (undocumented)
    ref: React.Ref<HTMLElement>;
}

// @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 ICoachmark {
    dismiss?: (ev?: Event | React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
}

// @public
export interface ICoachmarkProps {
    ariaAlertText?: string;
    ariaDescribedBy?: string;
    ariaDescribedByText?: string;
    ariaLabelledBy?: string;
    ariaLabelledByText?: string;
    beaconColorOne?: string;
    beaconColorTwo?: string;
    // @deprecated
    beakHeight?: number;
    // @deprecated
    beakWidth?: number;
    children?: React.ReactNode;
    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?: Event | React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
    onMouseMove?: (e: MouseEvent) => void;
    persistentBeak?: boolean;
    positioningContainerProps?: IPositioningContainerProps;
    preventDismissOnLostFocus?: boolean;
    preventFocusOnMount?: boolean;
    styles?: IStyleFunctionOrObject<ICoachmarkStyleProps, ICoachmarkStyles>;
    target: HTMLElement | string | null;
    // @deprecated
    teachingBubbleRef?: ITeachingBubble;
    theme?: ITheme;
    // @deprecated
    width?: number;
}

// @public
export interface ICoachmarkStyleProps {
    beaconColorOne?: string;
    beaconColorTwo?: string;
    className?: string;
    // @deprecated
    collapsed?: boolean;
    color?: string;
    delayBeforeCoachmarkAnimation?: string;
    entityHostHeight?: string;
    entityHostWidth?: string;
    height?: string;
    isCollapsed: 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 IColorCellProps {
    color?: string;
    id: string;
    index?: number;
    label?: string;
}

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

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

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

// @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 IDragOptions {
    closeMenuItemText: string;
    dragHandleSelector?: string;
    keyboardMoveIconProps?: IIconProps;
    menu: React.FunctionComponent<IContextualMenuProps>;
    moveMenuItemText: string;
}

// @public (undocumented)
export interface IEditingSelectedPeopleItemProps extends ISelectedPeopleItemProps {
    // (undocumented)
    floatingPickerProps?: IBaseFloatingPickerProps<IPersonaProps>;
    // (undocumented)
    getEditingItemText?: (item: IExtendedPersonaProps) => string;
    // (undocumented)
    onEditingComplete: (oldItem: any, newItem: any) => void;
    // (undocumented)
    onRenderFloatingPicker?: React.ComponentType<IBaseFloatingPickerProps<IPersonaProps>>;
}

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

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

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

// @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> {
    applyTheme?: boolean;
    applyThemeToBody?: boolean;
    as?: React.ElementType;
    // (undocumented)
    componentRef?: IRefObject<{}>;
    dir?: 'rtl' | 'ltr' | 'auto';
    styles?: IStyleFunctionOrObject<IFabricStyleProps, IFabricStyles>;
    theme?: ITheme;
}

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

// @public (undocumented)
export interface IFabricStyles {
    // (undocumented)
    bodyThemed: IStyle;
    // (undocumented)
    root: 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 (undocumented)
export interface IImage {
}

// @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 (undocumented)
export interface ILink {
    focus(): void;
}

// @public (undocumented)
export interface ILinkHTMLAttributes<T> extends React.HTMLAttributes<T> {
    // (undocumented)
    [index: string]: any;
    // (undocumented)
    as?: React.ElementType;
    // (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 ILinkOptions {
}

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

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

// @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 const Image: React.FunctionComponent<IImageProps>;

// @public (undocumented)
export const ImageBase: React.ForwardRefExoticComponent<IImageProps & React.RefAttributes<HTMLImageElement>>;

// @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 (undocumented)
export enum ImageLoadState {
    error = 2,
    // @deprecated
    errorLoaded = 3,
    loaded = 1,
    notLoaded = 0
}

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

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

// @public (undocumented)
export interface IModalProps extends React.ClassAttributes<ModalBase>, IWithResponsiveModeState, IAccessiblePopupProps {
    allowTouchBodyScroll?: boolean;
    className?: string;
    componentRef?: IRefObject<IModal>;
    containerClassName?: string;
    dragOptions?: IDragOptions;
    enableAriaHiddenSiblings?: boolean;
    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 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>;
    // @deprecated
    doNotContainWithinFocusZone?: boolean;
    // @deprecated
    focusZoneProps?: IFocusZoneProps;
    items?: IOverflowSetItemProps[];
    itemSubMenuProvider?: (item: IOverflowSetItemProps) => any[] | undefined;
    keytipSequences?: string[];
    onRenderItem: (item: IOverflowSetItemProps) => any;
    onRenderOverflowButton: IRenderFunction<any[]>;
    overflowItems?: IOverflowSetItemProps[];
    overflowSide?: 'start' | 'end';
    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 IPeoplePickerItemState {
    // (undocumented)
    contextualMenuVisible: boolean;
}

// @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' | 'presenceColors'> & 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<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;
    presenceColors?: {
        available: string;
        away: string;
        busy: string;
        dnd: string;
        offline: string;
        oof: string;
        background: string;
    };
    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 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 (undocumented)
export interface IPopupProps extends React.HTMLAttributes<HTMLDivElement> {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    className?: string;
    onDismiss?: (ev?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement> | KeyboardEvent) => any;
    onRestoreFocus?: (options: {
        originalElement?: HTMLElement | Window;
        containsFocus: boolean;
    }) => void;
    role?: string;
    // @deprecated
    shouldRestoreFocus?: boolean;
}

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

// @public (undocumented)
export interface IPositioningContainerProps extends IBaseProps<IPositioningContainer> {
    ariaDescribedBy?: string;
    ariaLabel?: string;
    ariaLabelledBy?: string;
    backgroundColor?: string;
    bounds?: IRectangle;
    children?: ReactNode;
    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;
    onPositioned?: (positions?: IPositionedData) => void;
    positioningContainerMaxHeight?: number;
    positioningContainerWidth?: number;
    preventDismissOnScroll?: boolean;
    role?: string;
    setInitialFocus?: boolean;
    target?: HTMLElement | string | MouseEvent | Point | null;
    // @deprecated
    targetPoint?: Point;
    // @deprecated
    useTargetPoint?: boolean;
}

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

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

// @public (undocumented)
export interface IResizeGroupProps extends React.HTMLAttributes<HTMLDivElement> {
    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 (undocumented)
export interface ISearchBox {
    focus(): void;
    hasFocus(): boolean;
}

// @public (undocumented)
export interface ISearchBoxProps extends React.InputHTMLAttributes<HTMLInputElement> {
    ariaLabel?: string;
    className?: string;
    clearButtonProps?: IButtonProps;
    componentRef?: React.Ref<ISearchBox>;
    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 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 (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;
}

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

// @public (undocumented)
export interface ISliderProps extends React.ClassAttributes<HTMLElement> {
    'aria-label'?: string;
    // @deprecated
    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 type ISliderState = any;

// @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 extends React.HTMLAttributes<HTMLDivElement> {
    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>;
    iconButtonProps?: IButtonProps_2;
    iconProps?: IIconProps;
    incrementButtonAriaLabel?: string;
    incrementButtonIcon?: IIconProps;
    inputProps?: React.InputHTMLAttributes<HTMLElement | HTMLInputElement>;
    keytipProps?: IKeytipProps;
    label?: string;
    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?: IStyleFunctionOrObject<ISpinButtonStyleProps, ISpinButtonStyles>;
    theme?: ITheme;
    title?: string;
    upArrowButtonStyles?: Partial<IButtonStyles>;
    value?: string;
}

// @public (undocumented)
export interface ISpinButtonStyleProps {
    // (undocumented)
    className: string | undefined;
    // (undocumented)
    disabled: boolean;
    // (undocumented)
    isFocused: boolean;
    // (undocumented)
    keyboardSpinDirection: KeyboardSpinDirection;
    // (undocumented)
    labelPosition: Position;
    // (undocumented)
    theme: ITheme;
}

// @public (undocumented)
export interface ISpinButtonStyles {
    arrowButtonsContainer: IStyle;
    icon: IStyle;
    input: IStyle;
    label: IStyle;
    labelWrapper: IStyle;
    root: IStyle;
    spinButtonWrapper: IStyle;
}

// @public (undocumented)
export interface ISwatchColorPickerProps {
    ariaPosInSet?: number;
    ariaSetSize?: number;
    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;
    // @deprecated (undocumented)
    positionInSet?: number;
    selectedId?: string;
    // @deprecated (undocumented)
    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 (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 (undocumented)
export interface IToggle {
    // (undocumented)
    focus: () => void;
}

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

// @public
export interface IToggleProps extends React.HTMLAttributes<HTMLElement> {
    ariaLabel?: string;
    as?: IComponentAs<React.HTMLAttributes<HTMLElement>> | React.ElementType;
    checked?: boolean;
    componentRef?: IRefObject<IToggle>;
    defaultChecked?: boolean;
    disabled?: boolean;
    inlineLabel?: boolean;
    // @deprecated
    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;
    role?: 'checkbox' | 'switch' | 'menuitemcheckbox';
    styles?: IStyleFunctionOrObject<IToggleStyleProps, IToggleStyles>;
    theme?: ITheme;
}

// @public (undocumented)
export type IToggleSlotProps = {
    [key in keyof IToggleSlots]: IToggleProps[key];
};

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

// @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 enum KeyboardSpinDirection {
    // (undocumented)
    down = -1,
    // (undocumented)
    notSpinning = 0,
    // (undocumented)
    up = 1
}

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

// @public (undocumented)
export const LinkBase: import("@fluentui/react-compose").ComponentWithAs<"a", ILinkProps>;

// @public (undocumented)
export type LinkSlotProps = {
    [key in keyof ILinkSlots]: ILinkProps[key];
};

// @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;
    // (undocumented)
    UNSAFE_componentWillReceiveProps(newProps: ITextFieldProps): void;
    // (undocumented)
    readonly value: string | undefined;
}

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

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

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

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

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

// @public (undocumented)
export class OverflowSetBase extends React.Component<IOverflowSetProps, {}> implements IOverflowSet {
    constructor(props: IOverflowSetProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    componentWillUnmount(): void;
    focus(forceIntoFirstElement?: boolean): boolean;
    focusElement(childElement?: HTMLElement): boolean;
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    UNSAFE_componentWillUpdate(): void;
}

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

// @public
export const PersonaBase: React.ForwardRefExoticComponent<IPersonaProps & React.RefAttributes<HTMLDivElement>>;

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

// @public
export const PersonaCoinBase: React.ForwardRefExoticComponent<IPersonaCoinProps & React.RefAttributes<HTMLDivElement>>;

// @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 // (undocumented)
    size32 = "32px";
    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,
    size120 = 18,
    // @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";
    const // (undocumented)
    size120 = "120px";
}

// @public
export const Popup: React.ForwardRefExoticComponent<IPopupProps & React.RefAttributes<HTMLDivElement>>;

// @public (undocumented)
export const PositioningContainer: React.ForwardRefExoticComponent<IPositioningContainerProps & React.RefAttributes<HTMLDivElement>>;

// @public (undocumented)
export const presenceBoolean: (presence: PersonaPresence) => {
    isAvailable: boolean;
    isAway: boolean;
    isBlocked: boolean;
    isBusy: boolean;
    isDoNotDisturb: boolean;
    isOffline: boolean;
};

// @public (undocumented)
export const ResizeGroup: import("react").ForwardRefExoticComponent<import("./ResizeGroup.types").IResizeGroupProps & import("react").RefAttributes<HTMLDivElement>>;

// @public (undocumented)
export const ResizeGroupBase: React.ForwardRefExoticComponent<IResizeGroupProps & React.RefAttributes<HTMLDivElement>>;

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

// @public (undocumented)
export const SearchBox: React.FunctionComponent<ISearchBoxProps>;

// @public (undocumented)
export const SearchBoxBase: React.ForwardRefExoticComponent<ISearchBoxProps & React.RefAttributes<HTMLDivElement>>;

// @public
export class SelectedPeopleList extends BasePeopleSelectedItemsList {
    // (undocumented)
    static defaultProps: any;
    // (undocumented)
    protected renderItems: () => JSX.Element[];
}

// @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;
    isSize120: boolean;
};

// @public (undocumented)
export const sizeToPixels: {
    [key: number]: number;
};

// @public (undocumented)
export const Slider: React.FunctionComponent<ISliderProps>;

// @public (undocumented)
export const SliderBase: React.ForwardRefExoticComponent<Pick<ISliderProps, "max" | "disabled" | "label" | "vertical" | "key" | "step" | "theme" | "styles" | "className" | "defaultValue" | "aria-label" | "onChange" | "componentRef" | "min" | "value" | "ariaLabel" | "onChanged" | "showValue" | "ariaValueText" | "snapToStep" | "buttonProps" | "valueFormat" | "originFromZero"> & React.RefAttributes<HTMLDivElement>>;

// @public
export const SpinButton: React.FunctionComponent<ISpinButtonProps>;

// @public (undocumented)
export const SwatchColorPicker: React.FunctionComponent<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 type Target = Element | string | MouseEvent | Point | null | React.RefObject<Element>;

// @public (undocumented)
export const TextField: React.FunctionComponent<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 Toggle: React.FunctionComponent<IToggleProps & React.RefAttributes<HTMLDivElement>>;

// @public (undocumented)
export const ToggleBase: import("@fluentui/react-compose").ComponentWithAs<"div", IToggleProps>;

// @public (undocumented)
export function useHeightOffset({ finalHeight }: IPositioningContainerProps, contentHost: React.RefObject<HTMLDivElement | null>): number;

// @public
export const useLink: (props: ILinkProps, forwardedRef: React.Ref<HTMLElement>) => any;

// @public (undocumented)
export const useToggle: (props: IToggleProps, ref: React.Ref<HTMLDivElement>, options: ComposePreparedOptions<{}, any, {}>) => any;


export * from "@fluentui/react-button/lib/Button";
export * from "@fluentui/react-button/lib/MenuButton";
export * from "@fluentui/react-button/lib/SplitButton";
export * from "@fluentui/react-button/lib/ToggleButton";
export * from "@fluentui/react-tabs/lib/Pivot";
export * from "@fluentui/react-theme-provider";
export * from "@uifabric/date-time/lib/Calendar";
export * from "@uifabric/date-time/lib/DatePicker";
export * from "office-ui-fabric-react/lib/ActivityItem";
export * from "office-ui-fabric-react/lib/Announced";
export * from "office-ui-fabric-react/lib/Autofill";
export * from "office-ui-fabric-react/lib/Breadcrumb";
export * from "office-ui-fabric-react/lib/Check";
export * from "office-ui-fabric-react/lib/ChoiceGroup";
export * from "office-ui-fabric-react/lib/Color";
export * from "office-ui-fabric-react/lib/ColorPicker";
export * from "office-ui-fabric-react/lib/ComboBox";
export * from "office-ui-fabric-react/lib/CommandBar";
export * from "office-ui-fabric-react/lib/ContextualMenu";
export * from "office-ui-fabric-react/lib/DetailsList";
export * from "office-ui-fabric-react/lib/Dialog";
export * from "office-ui-fabric-react/lib/Divider";
export * from "office-ui-fabric-react/lib/DocumentCard";
export * from "office-ui-fabric-react/lib/Dropdown";
export * from "office-ui-fabric-react/lib/ExtendedPicker";
export * from "office-ui-fabric-react/lib/Facepile";
export * from "office-ui-fabric-react/lib/FloatingPicker";
export * from "office-ui-fabric-react/lib/FocusZone";
export * from "office-ui-fabric-react/lib/Grid";
export * from "office-ui-fabric-react/lib/GroupedList";
export * from "office-ui-fabric-react/lib/HoverCard";
export * from "office-ui-fabric-react/lib/Icon";
export * from "office-ui-fabric-react/lib/Icons";
export * from "office-ui-fabric-react/lib/Keytip";
export * from "office-ui-fabric-react/lib/KeytipData";
export * from "office-ui-fabric-react/lib/KeytipLayer";
export * from "office-ui-fabric-react/lib/Label";
export * from "office-ui-fabric-react/lib/Layer";
export * from "office-ui-fabric-react/lib/List";
export * from "office-ui-fabric-react/lib/MarqueeSelection";
export * from "office-ui-fabric-react/lib/MessageBar";
export * from "office-ui-fabric-react/lib/Nav";
export * from "office-ui-fabric-react/lib/Overlay";
export * from "office-ui-fabric-react/lib/Panel";
export * from "office-ui-fabric-react/lib/Pickers";
export * from "office-ui-fabric-react/lib/ProgressIndicator";
export * from "office-ui-fabric-react/lib/Rating";
export * from "office-ui-fabric-react/lib/ScrollablePane";
export * from "office-ui-fabric-react/lib/SelectableOption";
export * from "office-ui-fabric-react/lib/Selection";
export * from "office-ui-fabric-react/lib/Separator";
export * from "office-ui-fabric-react/lib/Shimmer";
export * from "office-ui-fabric-react/lib/ShimmeredDetailsList";
export * from "office-ui-fabric-react/lib/Spinner";
export * from "office-ui-fabric-react/lib/Stack";
export * from "office-ui-fabric-react/lib/Sticky";
export * from "office-ui-fabric-react/lib/Styling";
export * from "office-ui-fabric-react/lib/TeachingBubble";
export * from "office-ui-fabric-react/lib/Text";
export * from "office-ui-fabric-react/lib/ThemeGenerator";
export * from "office-ui-fabric-react/lib/Tooltip";
export * from "office-ui-fabric-react/lib/Utilities";

// (No @packageDocumentation comment for this package)

```