Utilities.Api

import { DATA_PORTAL_ATTRIBUTE } from '@fluentui/dom-utilities';
import { elementContains } from '@fluentui/dom-utilities';
import { elementContainsAttribute } from '@fluentui/dom-utilities';
import type { ExtendedCSSStyleSheet } from '@fluentui/merge-styles';
import { findElementRecursive } from '@fluentui/dom-utilities';
import { getActiveElement } from '@fluentui/dom-utilities';
import { getChildren } from '@fluentui/dom-utilities';
import { getEventTarget } from '@fluentui/dom-utilities';
import { getParent } from '@fluentui/dom-utilities';
import { getVirtualParent } from '@fluentui/dom-utilities';
import type { IProcessedStyleSet } from '@fluentui/merge-styles';
import { IStyleFunction } from '@fluentui/merge-styles';
import { IStyleFunctionOrObject } from '@fluentui/merge-styles';
import type { IStyleSetBase } from '@fluentui/merge-styles';
import { isVirtualElement } from '@fluentui/dom-utilities';
import { IVirtualElement } from '@fluentui/dom-utilities';
import { Omit as Omit_2 } from '@fluentui/merge-styles';
import { portalContainsElement } from '@fluentui/dom-utilities';
import * as React_2 from 'react';
import { setPortalAttribute } from '@fluentui/dom-utilities';
import { setVirtualParent } from '@fluentui/dom-utilities';
import { ShadowConfig } from '@fluentui/merge-styles';

// @public
export function addDirectionalKeyCode(which: number): void;

// @public
export function addElementAtIndex<T>(array: T[], index: number, itemToAdd: T): T[];

// @public (undocumented)
export type AdoptedStylesheetExHook = (stylesheetKey: string, shadowCtx: MergeStylesShadowRootContextValue | undefined, rootMergeStyles: Map<string, ExtendedCSSStyleSheet>, win: Window | undefined) => boolean;

// @public (undocumented)
export type AdoptedStylesheetHook = (stylesheetKey: string) => boolean;

// @public
export const allowOverscrollOnElement: (element: HTMLElement | null, events: EventGroup) => void;

// @public
export const allowScrollOnElement: (element: HTMLElement | null, events: EventGroup) => void;

// @public
export const anchorProperties: Record<string, number>;

// @public
export function appendFunction(parent: any, ...functions: any[]): () => void;

// @public
export function arraysEqual<T>(array1: T[], array2: T[]): boolean;

// @public
export function asAsync<TProps extends {}>(options: IAsAsyncOptions<TProps>): React_2.ForwardRefExoticComponent<React_2.PropsWithoutRef<TProps & {
    asyncPlaceholder?: React_2.ElementType | undefined;
}> & React_2.RefAttributes<React_2.ElementType<TProps>>>;

// @public
export function assertNever(x: never): never;

// @public
export function assign(this: any, target: any, ...args: any[]): any;

// @public
export class Async {
    constructor(parent?: object, onError?: (e: any) => void);
    // (undocumented)
    cancelAnimationFrame(id: number, targetElement?: Element | null): void;
    clearImmediate(id: number, targetElement?: Element | null): void;
    clearInterval(id: number): void;
    clearTimeout(id: number): void;
    debounce<T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
        leading?: boolean;
        maxWait?: number;
        trailing?: boolean;
    }): ICancelable<T> & T;
    dispose(): void;
    // (undocumented)
    protected _logError(e: any): void;
    // (undocumented)
    requestAnimationFrame(callback: () => void, targetElement?: Element | null): number;
    setImmediate(callback: () => void, targetElement?: Element | null): number;
    setInterval(callback: () => void, duration: number): number;
    setTimeout(callback: () => void, duration: number): number;
    throttle<T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
        leading?: boolean;
        trailing?: boolean;
    }): T;
}

// @public
export const audioProperties: Record<string, number>;

// @public
export class AutoScroll {
    constructor(element: HTMLElement, win?: Window);
    // (undocumented)
    dispose(): void;
}

// @public @deprecated
export class BaseComponent<TProps extends IBaseProps = {}, TState extends {} = {}> extends React_2.Component<TProps, TState> {
    constructor(props: TProps, context?: any);
    protected get _async(): Async;
    get className(): string;
    componentDidMount(): void;
    componentDidUpdate(prevProps: TProps, prevState: TState): void;
    componentWillUnmount(): void;
    protected get _disposables(): IDisposable[];
    protected get _events(): EventGroup;
    // @deprecated (undocumented)
    static onError: (errorMessage?: string, ex?: any) => void;
    // @deprecated
    protected _resolveRef(refName: string): (ref: React_2.ReactNode) => React_2.ReactNode;
    protected _skipComponentRefResolution: boolean;
    protected _updateComponentRef(currentProps: IBaseProps, newProps?: IBaseProps): void;
    protected _warnConditionallyRequiredProps(requiredProps: string[], conditionalPropName: string, condition: boolean): void;
    protected _warnDeprecations(deprecationMap: ISettingsMap<TProps>): void;
    protected _warnMutuallyExclusive(mutuallyExclusiveMap: ISettingsMap<TProps>): void;
}

// @public
export const baseElementEvents: Record<string, number>;

// @public
export const baseElementProperties: Record<string, number>;

// @public
export const buttonProperties: Record<string, number>;

// @public
export function calculatePrecision(value: number | string): number;

// @public
export function canUseDOM(): boolean;

// @public
export function classNamesFunction<TStyleProps extends {}, TStyleSet extends IStyleSetBase>(options?: IClassNamesFunctionOptions): (getStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet> | undefined, styleProps?: TStyleProps) => IProcessedStyleSet<TStyleSet>;

// @public (undocumented)
export const colGroupProperties: Record<string, number>;

// @public (undocumented)
export const colProperties: Record<string, number>;

// @public
export function composeComponentAs<TProps extends {}>(outer: IComponentAs<TProps>, inner: IComponentAs<TProps>): IComponentAs<TProps>;

// @public
export function composeRenderFunction<TProps>(outer: IRenderFunction<TProps>, inner: IRenderFunction<TProps>): IRenderFunction<TProps>;

// @public
export function createArray<T>(size: number, getItem: (index: number) => T): T[];

// @public
export function createMemoizer<F extends (input: any) => any>(getValue: F): F;

// @public
export const createMergedRef: <TType, TValue = null>(value?: TValue) => (...newRefs: (React_2.Ref<TType | null | TValue> | undefined)[]) => ((newValue: TType | TValue | null) => void);

// Warning: (ae-incompatible-release-tags) The symbol "css" is marked as @public, but its signature references "ICssInput" which is marked as @internal
//
// @public
export function css(...args: ICssInput[]): string;

// @public (undocumented)
export function customizable(scope: string, fields: string[], concatStyles?: boolean): <P>(ComposedComponent: React_2.ComponentType<P>) => any;

// @public (undocumented)
export class Customizations {
    static applyBatchedUpdates(code: () => void, suppressUpdate?: boolean): void;
    static applyScopedSettings(scopeName: string, settings: ISettings): void;
    static applySettings(settings: ISettings): void;
    // (undocumented)
    static getSettings(properties: string[], scopeName?: string, localSettings?: ICustomizations): any;
    // (undocumented)
    static observe(onChange: () => void): void;
    // (undocumented)
    static reset(): void;
    // (undocumented)
    static unobserve(onChange: () => void): void;
}

// @public @deprecated
export class Customizer extends React_2.Component<ICustomizerProps> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): React_2.ReactElement<{}>;
}

// @public (undocumented)
export const CustomizerContext: React_2.Context<ICustomizerContext>;

// @public
export const DATA_IS_SCROLLABLE_ATTRIBUTE = "data-is-scrollable";

export { DATA_PORTAL_ATTRIBUTE }

// Warning: (ae-incompatible-release-tags) The symbol "DelayedRender" is marked as @public, but its signature references "IDelayedRenderState" which is marked as @internal
//
// @public
export class DelayedRender extends React_2.Component<IDelayedRenderProps, IDelayedRenderState> {
    constructor(props: IDelayedRenderProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static defaultProps: {
        delay: number;
    };
    // (undocumented)
    render(): React_2.ReactElement<{}> | null;
}

// @public
export function disableBodyScroll(): void;

// @public
export const divProperties: Record<string, number>;

// @public
export function doesElementContainFocus(element: HTMLElement): boolean;

export { elementContains }

export { elementContainsAttribute }

// @public
export function enableBodyScroll(): void;

// @public
export class EventGroup {
    constructor(parent: any);
    declare(event: string | string[]): void;
    // (undocumented)
    dispose(): void;
    static isDeclared(target: any, eventName: string): boolean;
    // (undocumented)
    static isObserved(target: any, eventName: string): boolean;
    // (undocumented)
    off(target?: any, eventName?: string, callback?: (args?: any) => void, options?: boolean | AddEventListenerOptions): void;
    on(target: any, eventName: string, callback: (args?: any) => void, options?: boolean | AddEventListenerOptions): void;
    onAll(target: any, events: {
        [key: string]: (args?: any) => void;
    }, useCapture?: boolean): void;
    static raise(target: any, eventName: string, eventArgs?: any, bubbleEvent?: boolean, doc?: Document): boolean | undefined;
    raise(eventName: string, eventArgs?: any, bubbleEvent?: boolean): boolean | undefined;
    // (undocumented)
    static stopPropagation(event: any): void;
}

// @public
export function extendComponent<T extends React_2.Component>(parent: T, methods: {
    [key in keyof T]?: T[key];
}): void;

// @public
export class FabricPerformance {
    static measure(name: string, func: () => void): void;
    // (undocumented)
    static reset(): void;
    // (undocumented)
    static setPeriodicReset(): void;
    // Warning: (ae-incompatible-release-tags) The symbol "summary" is marked as @public, but its signature references "IPerfSummary" which is marked as @internal
    //
    // (undocumented)
    static summary: IPerfSummary;
}

// @public
export function filteredAssign(isAllowed: (propName: string) => boolean, target: any, ...args: any[]): any;

// @public
export function find<T>(array: T[], cb: (item: T, index: number) => boolean): T | undefined;

export { findElementRecursive }

// @public
export function findIndex<T>(array: T[], cb: (item: T, index: number) => boolean, fromIndex?: number): number;

// @public
export function findScrollableParent(startingElement: HTMLElement | null): HTMLElement | Window | undefined | null;

// @public
export function fitContentToBounds(options: IFitContentToBoundsOptions): ISize;

// @public
export type FitMode = 'contain' | 'cover';

// @public
export function flatten<T>(array: (T | T[])[]): T[];

// @public
export function focusAsync(element: HTMLElement | {
    focus: () => void;
} | undefined | null): void;

// @public
export function focusFirstChild(rootElement: HTMLElement, bypassHiddenElements?: boolean, includeShadowRoots?: boolean): boolean;

// @public
export const FocusRects: React_2.FunctionComponent<{
    rootRef?: React_2.RefObject<HTMLElement | null>;
}>;

// @public (undocumented)
export const FocusRectsContext: React_2.Context<IFocusRectsContext | undefined>;

// @public (undocumented)
export const FocusRectsProvider: React_2.FC<FocusRectsProviderProps>;

// @public (undocumented)
export type FocusRectsProviderProps = {
    providerRef: React_2.RefObject<HTMLElement | null>;
    layerRoot?: boolean;
    children?: React_2.ReactNode;
};

// @public
export function format(s: string, ...values: any[]): string;

// @public
export const formProperties: Record<string, number>;

export { getActiveElement }

export { getChildren }

// @public
export function getDistanceBetweenPoints(point1: Point, point2: Point): number;

// @public
export function getDocument(rootElement?: HTMLElement | null): Document | undefined;

// @public
export function getElementIndexPath(fromElement: HTMLElement, toElement: HTMLElement): number[];

export { getEventTarget }

// @public
export function getFirstFocusable(rootElement: HTMLElement, currentElement: HTMLElement, includeElementsInFocusZones?: boolean, includeShadowRoots?: boolean): HTMLElement | null;

// @public
export function getFirstTabbable(rootElement: HTMLElement, currentElement: HTMLElement, includeElementsInFocusZones?: boolean, checkNode?: boolean, includeShadowRoots?: boolean): HTMLElement | null;

// @public
export function getFirstVisibleElementFromSelector(selector: string): Element | undefined;

// @public
export function getFocusableByIndexPath(parent: HTMLElement, path: number[]): HTMLElement | undefined;

// @public
export function getId(prefix?: string): string;

// @public
export function getInitials(displayName: string | undefined | null, isRtl: boolean, allowPhoneInitials?: boolean): string;

// @public
export function getLanguage(persistenceType?: 'localStorage' | 'sessionStorage' | 'none'): string | null;

// @public
export function getLastFocusable(rootElement: HTMLElement, currentElement: HTMLElement, includeElementsInFocusZones?: boolean, includeShadowRoots?: boolean): HTMLElement | null;

// @public
export function getLastTabbable(rootElement: HTMLElement, currentElement: HTMLElement, includeElementsInFocusZones?: boolean, checkNode?: boolean, includeShadowRoots?: boolean): HTMLElement | null;

// @public
export function getNativeElementProps<TAttributes extends React_2.HTMLAttributes<any>>(tagName: string, props: {}, excludedPropNames?: string[]): TAttributes;

// @public
export function getNativeProps<T extends Record<string, any>>(props: Record<string, any>, allowedPropNames: string[] | Record<string, number>, excludedPropNames?: string[]): T;

// @public
export function getNextElement(rootElement: HTMLElement, currentElement: HTMLElement | null, checkNode?: boolean, suppressParentTraversal?: boolean, suppressChildTraversal?: boolean, includeElementsInFocusZones?: boolean, allowFocusRoot?: boolean, tabbable?: boolean, bypassHiddenElements?: boolean, includeShadowRoots?: boolean): HTMLElement | null;

export { getParent }

// @public
export function getPreviousElement(rootElement: HTMLElement, currentElement: HTMLElement | null, checkNode?: boolean, suppressParentTraversal?: boolean, traverseChildren?: boolean, includeElementsInFocusZones?: boolean, allowFocusRoot?: boolean, tabbable?: boolean, includeShadowRoots?: boolean): HTMLElement | null;

// @public
export function getPropsWithDefaults<TProps extends {}>(defaultProps: Partial<TProps>, propsWithoutDefaults: TProps): TProps;

// @public
export function getRect(element: HTMLElement | Window | null, win?: Window): IRectangle | undefined;

// @public @deprecated (undocumented)
export function getResourceUrl(url: string): string;

// @public
export function getRTL(theme?: {
    rtl?: boolean;
}): boolean;

// @public
export function getRTLSafeKeyCode(key: number, theme?: {
    rtl?: boolean;
}): number;

// @public
export function getScrollbarWidth(doc?: Document): number;

export { getVirtualParent }

// @public
export function getWindow(rootElement?: Element | null): Window | undefined;

// @public
export class GlobalSettings {
    // (undocumented)
    static addChangeListener(cb: IChangeEventCallback): void;
    // (undocumented)
    static getValue<T>(key: string, defaultValue?: T | (() => T)): T;
    // (undocumented)
    static removeChangeListener(cb: IChangeEventCallback): void;
    // (undocumented)
    static setValue<T>(key: string, value: T): T;
}

// @public
export function hasHorizontalOverflow(element: HTMLElement): boolean;

// @public (undocumented)
export type HasMergeStylesShadowRootContextHook = () => boolean;

// @public
export function hasOverflow(element: HTMLElement): boolean;

// @public
export function hasVerticalOverflow(element: HTMLElement): boolean;

// @public
export function hoistMethods(destination: any, source: any, exclusions?: string[]): string[];

// @public
export function hoistStatics<TSource extends Object, TDest>(source: TSource, dest: TDest): TDest;

// @public
export const htmlElementProperties: Record<string, number>;

// @public (undocumented)
export interface IAsAsyncOptions<TProps> {
    load: () => Promise<React_2.ElementType<TProps>>;
    onError?: (error: Error) => void;
    onLoad?: () => void;
}

// @public
export interface IBaseProps<T = any> {
    // (undocumented)
    componentRef?: IRefObject<T>;
}

// @public (undocumented)
export type ICancelable<T extends (...args: any[]) => any> = {
    flush: () => ReturnType<T>;
    cancel: () => void;
    pending: () => boolean;
};

// @public
export interface IChangeDescription {
    // (undocumented)
    key: string;
    // (undocumented)
    oldValue: any;
    // (undocumented)
    value: any;
}

// @public
export interface IChangeEventCallback {
    // (undocumented)
    (changeDescription?: IChangeDescription): void;
    // (undocumented)
    __id__?: string;
}

// @public @deprecated (undocumented)
export type IClassNames<T> = {
    [key in keyof T]: string;
};

// @public (undocumented)
export interface IClassNamesFunctionOptions {
    cacheSize?: number;
    disableCaching?: boolean;
    useStaticStyles?: boolean;
}

// @public
export type IComponentAs<T> = React_2.ComponentType<IComponentAsProps<T>>;

// @public
export type IComponentAsProps<T> = T & {
    defaultRender?: React_2.ComponentType<T>;
};

// Warning: (ae-internal-missing-underscore) The name "ICssInput" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export type ICssInput = string | ISerializableObject | IDictionary | null | undefined | boolean;

// @public (undocumented)
export interface ICustomizableProps {
    fields?: string[];
    scope: string;
}

// @public (undocumented)
export interface ICustomizations {
    // (undocumented)
    inCustomizerContext?: boolean;
    // (undocumented)
    scopedSettings: {
        [key: string]: ISettings;
    };
    // (undocumented)
    settings: ISettings;
}

// @public (undocumented)
export interface ICustomizerContext {
    // (undocumented)
    customizations: ICustomizations;
}

// @public (undocumented)
export type ICustomizerProps = IBaseProps & Partial<{
    settings: ISettings | ISettingsFunction;
    scopedSettings: ISettings | ISettingsFunction;
}> & {
    children?: React_2.ReactNode;
    contextTransform?: (context: Readonly<ICustomizerContext>) => ICustomizerContext;
};

// Warning: (ae-internal-missing-underscore) The name "IDeclaredEventsByName" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export interface IDeclaredEventsByName {
    // (undocumented)
    [eventName: string]: boolean;
}

// @public
export interface IDelayedRenderProps extends IReactProps<{}> {
    delay?: number;
}

// Warning: (ae-internal-missing-underscore) The name "IDelayedRenderState" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export interface IDelayedRenderState {
    isRendered: boolean;
}

// Warning: (ae-internal-missing-underscore) The name "IDictionary" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export interface IDictionary {
    // (undocumented)
    [className: string]: boolean;
}

// @public
export interface IDisposable {
    // (undocumented)
    dispose: () => void;
}

// Warning: (ae-internal-missing-underscore) The name "IEventRecord" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export interface IEventRecord {
    // (undocumented)
    callback: (args?: any) => void;
    // (undocumented)
    elementCallback?: (...args: any[]) => void;
    // (undocumented)
    eventName: string;
    // (undocumented)
    objectCallback?: (args?: any) => void;
    // (undocumented)
    options?: boolean | AddEventListenerOptions;
    // (undocumented)
    parent: any;
    // (undocumented)
    target: any;
}

// Warning: (ae-internal-missing-underscore) The name "IEventRecordList" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export interface IEventRecordList {
    // (undocumented)
    [id: string]: IEventRecord[] | number;
    // (undocumented)
    count: number;
}

// Warning: (ae-internal-missing-underscore) The name "IEventRecordsByName" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export interface IEventRecordsByName {
    // (undocumented)
    [eventName: string]: IEventRecordList;
}

// @public
export interface IFitContentToBoundsOptions {
    boundsSize: ISize;
    contentSize: ISize;
    maxScale?: number;
    mode: FitMode;
}

// @public (undocumented)
export type IFocusRectsContext = {
    readonly providerRef: React_2.RefObject<HTMLElement | null>;
    readonly registeredProviders: React_2.RefObject<HTMLElement | null>[];
    readonly registerProvider: (ref: React_2.RefObject<HTMLElement | null>) => void;
    readonly unregisterProvider: (ref: React_2.RefObject<HTMLElement | null>) => void;
};

// @public
export const iframeProperties: Record<string, number>;

// @public @deprecated (undocumented)
export const imageProperties: Record<string, number>;

// @public
export const imgProperties: Record<string, number>;

// @public
export function initializeComponentRef<TProps extends IBaseProps, TState>(obj: React_2.Component<TProps, TState>): void;

// @public @deprecated
export function initializeFocusRects(window?: Window): void;

// @public
export const inputProperties: Record<string, number>;

// @public (undocumented)
export interface IObjectWithKey {
    // (undocumented)
    key?: string | number;
}

// Warning: (ae-internal-missing-underscore) The name "IPerfData" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export interface IPerfData {
    // (undocumented)
    duration: number;
    // (undocumented)
    timeStamp: number;
}

// Warning: (ae-internal-missing-underscore) The name "IPerfMeasurement" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export interface IPerfMeasurement {
    // (undocumented)
    all: IPerfData[];
    // (undocumented)
    count: number;
    // (undocumented)
    totalDuration: number;
}

// Warning: (ae-internal-missing-underscore) The name "IPerfSummary" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export interface IPerfSummary {
    // (undocumented)
    [key: string]: IPerfMeasurement;
}

// @public @deprecated
export interface IPoint extends Point {
}

// @public (undocumented)
export interface IPropsWithStyles<TStyleProps, TStyleSet extends IStyleSetBase> {
    // (undocumented)
    styles?: IStyleFunctionOrObject<TStyleProps, TStyleSet>;
}

// @public (undocumented)
export interface IReactProps<T> {
    // (undocumented)
    children?: React_2.ReactNode | undefined;
    // (undocumented)
    key?: React_2.Key | undefined;
    // (undocumented)
    ref?: React_2.Ref<T> | undefined;
}

// @public
export interface IRectangle {
    // (undocumented)
    bottom?: number;
    // (undocumented)
    height: number;
    // (undocumented)
    left: number;
    // (undocumented)
    right?: number;
    // (undocumented)
    top: number;
    // (undocumented)
    width: number;
}

// @public (undocumented)
export type IRefObject<T> = React_2.MutableRefObject<T | null> | RefObject<T | null> | ((ref: T | null) => void);

// @public
export interface IRenderComponent<TProps> {
    children: (props: TProps) => JSXElement;
}

// @public
export type IRenderFunction<P> = (props?: P, defaultRender?: (props?: P) => JSXElement | null) => JSXElement | null;

// @public
export function isControlled<P>(props: P, valueProp: keyof P): boolean;

// @public
export function isDirectionalKeyCode(which: number): boolean;

// @public (undocumented)
export interface ISelection<TItem = IObjectWithKey> {
    // (undocumented)
    canSelectItem: (item: TItem, index?: number) => boolean;
    // (undocumented)
    count: number;
    // (undocumented)
    getItemIndex?(key: string): number;
    // (undocumented)
    getItems(): TItem[];
    // (undocumented)
    getSelectedCount(): number;
    // (undocumented)
    getSelectedIndices(): number[];
    // (undocumented)
    getSelection(): TItem[];
    // (undocumented)
    isAllSelected(): boolean;
    // (undocumented)
    isIndexSelected(index: number): boolean;
    // (undocumented)
    isKeySelected(key: string): boolean;
    // (undocumented)
    isModal?(): boolean;
    // (undocumented)
    isRangeSelected(fromIndex: number, count: number): boolean;
    // (undocumented)
    mode: SelectionMode_2;
    // (undocumented)
    selectToIndex(index: number, clearSelection?: boolean): void;
    // (undocumented)
    selectToKey(key: string, clearSelection?: boolean): void;
    // (undocumented)
    selectToRange?(index: number, count: number, clearSelection?: boolean): void;
    // (undocumented)
    setAllSelected(isAllSelected: boolean): void;
    // (undocumented)
    setChangeEvents(isEnabled: boolean, suppressChange?: boolean): void;
    // (undocumented)
    setIndexSelected(index: number, isSelected: boolean, shouldAnchor: boolean): void;
    // (undocumented)
    setItems(items: TItem[], shouldClear: boolean): void;
    // (undocumented)
    setKeySelected(key: string, isSelected: boolean, shouldAnchor: boolean): void;
    // (undocumented)
    setModal?(isModal: boolean): void;
    // (undocumented)
    setRangeSelected?(fromIndex: number, count: number, isSelected: boolean, shouldAnchor: boolean): void;
    // (undocumented)
    toggleAllSelected(): void;
    // (undocumented)
    toggleIndexSelected(index: number): void;
    // (undocumented)
    toggleKeySelected(key: string): void;
    // (undocumented)
    toggleRangeSelected(fromIndex: number, count: number): void;
}

// @public (undocumented)
export interface ISelectionOptions<TItem = IObjectWithKey> {
    // (undocumented)
    canSelectItem?: (item: TItem, index?: number) => boolean;
    getKey?: (item: TItem, index?: number) => string | number;
    // (undocumented)
    items?: TItem[];
    // (undocumented)
    onItemsChanged?: () => void;
    // (undocumented)
    onSelectionChanged?: () => void;
    // (undocumented)
    selectionMode?: SelectionMode_2;
}

// @public
export type ISelectionOptionsWithRequiredGetKey<TItem> = ISelectionOptions<TItem> & Required<Pick<ISelectionOptions<TItem>, 'getKey'>>;

// @public
export function isElementFocusSubZone(element?: HTMLElement): boolean;

// @public
export function isElementFocusZone(element?: HTMLElement): boolean;

// @public
export function isElementTabbable(element: HTMLElement, checkTabIndex?: boolean, checkShadowRoot?: boolean): boolean;

// @public
export function isElementVisible(element: HTMLElement | undefined | null): boolean;

// @public
export function isElementVisibleAndNotHidden(element: HTMLElement | undefined | null, win?: Window): boolean;

// Warning: (ae-internal-missing-underscore) The name "ISerializableObject" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export interface ISerializableObject {
    // (undocumented)
    toString?: () => string;
}

// @public (undocumented)
export type ISettings = {
    [key: string]: any;
};

// @public (undocumented)
export type ISettingsFunction = (settings: ISettings) => ISettings;

// @public (undocumented)
export type ISettingsMap<T> = {
    [P in keyof T]?: string;
};

// @public (undocumented)
export const IsFocusVisibleClassName = "ms-Fabric--isFocusVisible";

// @public (undocumented)
export const isIE11: () => boolean;

// @public
export const isIOS: () => boolean;

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

// @public
export function isMac(reset?: boolean): boolean;

export { IStyleFunction }

export { IStyleFunctionOrObject }

export { isVirtualElement }

export { IVirtualElement }

// @public (undocumented)
export interface IWarnControlledUsageParams<P> {
    componentId: string;
    componentName: string;
    defaultValueProp: keyof P;
    oldProps?: P;
    onChangeProp: keyof P;
    props: P;
    readOnlyProp?: keyof P;
    valueProp: keyof P;
}

// @public
export type JSXElement = React_2.ReactElement<any, any>;

// @public
export type JSXIntrinsicElement<Element extends JSXIntrinsicElementKeys> = React_2.ComponentProps<Element>;

// @public
export type JSXIntrinsicElementKeys = Exclude<React_2.ElementType, React_2.ComponentType>;

// @public
export const KeyCodes: {
    backspace: 8;
    tab: 9;
    enter: 13;
    shift: 16;
    ctrl: 17;
    alt: 18;
    pauseBreak: 19;
    capslock: 20;
    escape: 27;
    space: 32;
    pageUp: 33;
    pageDown: 34;
    end: 35;
    home: 36;
    left: 37;
    up: 38;
    right: 39;
    down: 40;
    insert: 45;
    del: 46;
    zero: 48;
    one: 49;
    two: 50;
    three: 51;
    four: 52;
    five: 53;
    six: 54;
    seven: 55;
    eight: 56;
    nine: 57;
    colon: 58;
    a: 65;
    b: 66;
    c: 67;
    d: 68;
    e: 69;
    f: 70;
    g: 71;
    h: 72;
    i: 73;
    j: 74;
    k: 75;
    l: 76;
    m: 77;
    n: 78;
    o: 79;
    p: 80;
    q: 81;
    r: 82;
    s: 83;
    t: 84;
    u: 85;
    v: 86;
    w: 87;
    x: 88;
    y: 89;
    z: 90;
    leftWindow: 91;
    rightWindow: 92;
    select: 93;
    zero_numpad: 96;
    one_numpad: 97;
    two_numpad: 98;
    three_numpad: 99;
    four_numpad: 100;
    five_numpad: 101;
    six_numpad: 102;
    seven_numpad: 103;
    eight_numpad: 104;
    nine_numpad: 105;
    multiply: 106;
    add: 107;
    subtract: 109;
    decimalPoint: 110;
    divide: 111;
    f1: 112;
    f2: 113;
    f3: 114;
    f4: 115;
    f5: 116;
    f6: 117;
    f7: 118;
    f8: 119;
    f9: 120;
    f10: 121;
    f11: 122;
    f12: 123;
    numlock: 144;
    scrollLock: 145;
    semicolon: 186;
    equalSign: 187;
    comma: 188;
    dash: 189;
    period: 190;
    forwardSlash: 191;
    graveAccent: 192;
    openBracket: 219;
    backSlash: 220;
    closeBracket: 221;
    singleQuote: 222;
};

// @public (undocumented)
export type KeyCodes = number;

// @public
export const labelProperties: Record<string, number>;

// @public
export const liProperties: Record<string, number>;

// @public
export function mapEnumByName<T>(theEnum: any, callback: (name?: string, value?: string | number) => T | undefined): (T | undefined)[] | undefined;

// @public
export function memoize<T extends Function>(_target: any, _key: string, descriptor: TypedPropertyDescriptor<T>): {
    configurable: boolean;
    get(): T;
};

// @public
export function memoizeFunction<T extends (...args: any[]) => RetType, RetType>(cb: T, maxCacheSize?: number, ignoreNullOrUndefinedResult?: boolean): T;

// @public
export function merge<T = {}>(target: Partial<T>, ...args: (Partial<T> | null | undefined | false)[]): T;

// @public
export function mergeAriaAttributeValues(...ariaAttributes: (string | undefined | false)[]): string | undefined;

// @public
export function mergeCustomizations(props: ICustomizerProps, parentContext: ICustomizerContext): ICustomizerContext;

// @public (undocumented)
export function mergeScopedSettings(oldSettings?: ISettings, newSettings?: ISettings | ISettingsFunction): ISettings;

// @public
export function mergeSettings(oldSettings?: ISettings, newSettings?: ISettings | ISettingsFunction): ISettings;

// @public (undocumented)
export type MergeStylesContextConsumerProps = {
    stylesheetKey: string;
    children: (inShadow: boolean) => React_2.ReactElement<any, any>;
};

// @public (undocumented)
export type MergeStylesRootContextValue = {
    stylesheets: Map<string, ExtendedCSSStyleSheet>;
    useAdoptedStylesheetEx: AdoptedStylesheetExHook;
    useAdoptedStylesheet: AdoptedStylesheetHook;
    useShadowConfig: ShadowConfigHook;
    useMergeStylesShadowRootContext: MergeStylesShadowRootContextHook;
    useHasMergeStylesShadowRootContext: HasMergeStylesShadowRootContextHook;
    useMergeStylesRootStylesheets: MergeStylesRootStylesheetsHook;
    useWindow: UseWindowHook;
    useStyled: UseStyledHook;
};

// @public
export const MergeStylesRootProvider: React_2.FC<MergeStylesRootProviderProps>;

// @public (undocumented)
export type MergeStylesRootProviderProps = {
    children?: React_2.ReactNode;
    stylesheets?: Map<string, ExtendedCSSStyleSheet>;
    window?: Window;
    useAdoptedStylesheetEx?: AdoptedStylesheetExHook;
    useAdoptedStylesheet?: AdoptedStylesheetHook;
    useShadowConfig?: ShadowConfigHook;
    useMergeStylesShadowRootContext?: MergeStylesShadowRootContextHook;
    useHasMergeStylesShadowRootContext?: HasMergeStylesShadowRootContextHook;
    useMergeStylesRootStylesheets?: MergeStylesRootStylesheetsHook;
    useWindow?: UseWindowHook;
    useStyled?: UseStyledHook;
};

// @public (undocumented)
export type MergeStylesRootStylesheetsHook = () => Map<string, ExtendedCSSStyleSheet>;

// @public (undocumented)
export const MergeStylesShadowRootContext: React_2.Context<MergeStylesShadowRootContextValue | undefined>;

// @public (undocumented)
export type MergeStylesShadowRootContextHook = () => MergeStylesShadowRootContextValue | undefined;

// @public (undocumented)
export type MergeStylesShadowRootContextValue = {
    stylesheets: Map<string, CSSStyleSheet>;
    shadowRoot?: ShadowRoot | null;
};

// @public
export const MergeStylesShadowRootProvider: React_2.FC<MergeStylesShadowRootProviderProps>;

// @public (undocumented)
export type MergeStylesShadowRootProviderProps = {
    children?: React_2.ReactNode;
    shadowRoot?: ShadowRoot | null;
};

// @public
export function modalize(target: HTMLElement): () => void;

// @public
export function nullRender(): JSXElement | null;

// @public
export const olProperties: Record<string, number>;

// @public
export function omit<TObj extends Record<string, any>>(obj: TObj, exclusions: (keyof TObj)[]): TObj;

export { Omit_2 as Omit }

// @public (undocumented)
export function on(element: Element | Window | Document, eventName: string, callback: (ev: Event) => void, options?: boolean): () => void;

// @public (undocumented)
export const optionProperties: Record<string, number>;

// @public
export interface Point {
    // (undocumented)
    left?: number;
    // (undocumented)
    top?: number;
    // @deprecated (undocumented)
    x?: number;
    // @deprecated (undocumented)
    y?: number;
}

export { portalContainsElement }

// @public
export function precisionRound(value: number, precision: number, base?: number): number;

// @public @deprecated
export function raiseClick(target: Element, doc?: Document): void;

// @public
export class Rectangle {
    constructor(left?: number, right?: number, top?: number, bottom?: number);
    // (undocumented)
    bottom: number;
    equals(rect: Rectangle): boolean;
    get height(): number;
    // (undocumented)
    left: number;
    // (undocumented)
    right: number;
    // (undocumented)
    top: number;
    get width(): number;
}

// @public (undocumented)
export type RefObject<T> = {
    (component: T | null): void;
    current: T | null;
};

// @public
export function removeDirectionalKeyCode(which: number): void;

// @public
export function removeIndex<T>(array: T[], index: number): T[];

// @public
export function replaceElement<T>(array: T[], newElement: T, index: number): T[];

// @public
export function resetControlledWarnings(): void;

// @public
export function resetIds(counter?: number): void;

// @public
export function resetMemoizations(): void;

// @public
export const safeRequestAnimationFrame: (component: React_2.Component) => ((cb: Function) => void);

// @public
export const safeSetTimeout: (component: React_2.Component) => ((cb: Function, duration: number) => void);

// @public (undocumented)
class Selection_2<TItem = IObjectWithKey> implements ISelection<TItem> {
    constructor(...options: TItem extends IObjectWithKey ? [] | [ISelectionOptions<TItem>] : [ISelectionOptionsWithRequiredGetKey<TItem>]);
    // (undocumented)
    canSelectItem(item: TItem, index?: number): boolean;
    count: number;
    // (undocumented)
    getItemIndex(key: string): number;
    // (undocumented)
    getItems(): TItem[];
    // (undocumented)
    getKey(item: TItem, index?: number): string;
    // (undocumented)
    getSelectedCount(): number;
    // (undocumented)
    getSelectedIndices(): number[];
    // (undocumented)
    getSelection(): TItem[];
    // (undocumented)
    isAllSelected(): boolean;
    // (undocumented)
    isIndexSelected(index: number): boolean;
    // (undocumented)
    isKeySelected(key: string): boolean;
    // (undocumented)
    isModal(): boolean;
    // (undocumented)
    isRangeSelected(fromIndex: number, count: number): boolean;
    // (undocumented)
    readonly mode: SelectionMode_2;
    // (undocumented)
    selectToIndex(index: number, clearSelection?: boolean): void;
    // (undocumented)
    selectToKey(key: string, clearSelection?: boolean): void;
    // (undocumented)
    selectToRange(fromIndex: number, count: number, clearSelection?: boolean): void;
    // (undocumented)
    setAllSelected(isAllSelected: boolean): void;
    // (undocumented)
    setChangeEvents(isEnabled: boolean, suppressChange?: boolean): void;
    // (undocumented)
    setIndexSelected(index: number, isSelected: boolean, shouldAnchor: boolean): void;
    setItems(items: TItem[], shouldClear?: boolean): void;
    // (undocumented)
    setKeySelected(key: string, isSelected: boolean, shouldAnchor: boolean): void;
    // (undocumented)
    setModal(isModal: boolean): void;
    // (undocumented)
    setRangeSelected(fromIndex: number, count: number, isSelected: boolean, shouldAnchor: boolean): void;
    // (undocumented)
    toggleAllSelected(): void;
    // (undocumented)
    toggleIndexSelected(index: number): void;
    // (undocumented)
    toggleKeySelected(key: string): void;
    // (undocumented)
    toggleRangeSelected(fromIndex: number, count: number): void;
}
export { Selection_2 as Selection }

// @public (undocumented)
export const SELECTION_CHANGE = "change";

// @public (undocumented)
export const SELECTION_ITEMS_CHANGE = "items-change";

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

// @public (undocumented)
enum SelectionMode_2 {
    // (undocumented)
    multiple = 2,
    // (undocumented)
    none = 0,
    // (undocumented)
    single = 1
}
export { SelectionMode_2 as SelectionMode }

// @public
export const selectProperties: Record<string, number>;

// @public @deprecated (undocumented)
export function setBaseUrl(baseUrl: string): void;

// @public
export function setFocusVisibility(enabled: boolean, target?: Element, registeredProviders?: React_2.RefObject<HTMLElement | null>[]): void;

// @public
export function setLanguage(language: string, persistenceType?: 'localStorage' | 'sessionStorage' | 'none'): void;

// @public @deprecated
export function setLanguage(language: string, avoidPersisting?: boolean): void;

// Warning: (ae-internal-missing-underscore) The name "setMemoizeWeakMap" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function setMemoizeWeakMap(weakMap: any): void;

export { setPortalAttribute }

// @public
export function setRTL(isRTL: boolean, persistSetting?: boolean): void;

// @public @deprecated
export function setSSR(isEnabled: boolean): void;

// @public @deprecated (undocumented)
export type Settings = ISettings;

// @public @deprecated (undocumented)
export type SettingsFunction = ISettingsFunction;

export { setVirtualParent }

// @public
export function setWarningCallback(warningCallback?: (message: string) => void): void;

// @public (undocumented)
export type ShadowConfigHook = (stylesheetKey: string, inShadow: boolean, win?: Window) => ShadowConfig;

// @public
export function shallowCompare<TA extends any, TB extends any>(a: TA, b: TB): boolean;

// @public
export function shouldWrapFocus(element: HTMLElement, noWrapDataAttribute: 'data-no-vertical-wrap' | 'data-no-horizontal-wrap', doc?: Document): boolean;

// @public
export function styled<TComponentProps extends IPropsWithStyles<TStyleProps, TStyleSet>, TStyleProps, TStyleSet extends IStyleSetBase>(Component: React_2.ComponentClass<TComponentProps> | React_2.FunctionComponent<React_2.PropsWithChildren<TComponentProps>>, baseStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet>, getProps?: (props: React_2.PropsWithoutRef<TComponentProps>) => Partial<React_2.PropsWithoutRef<TComponentProps>>, customizable?: ICustomizableProps, pure?: boolean): React_2.FunctionComponent<React_2.PropsWithChildren<React_2.PropsWithChildren<TComponentProps>>>;

// @public (undocumented)
export function styled<TComponentProps extends IPropsWithStyles<TStyleProps, TStyleSet> & React_2.RefAttributes<TRef>, TStyleProps, TStyleSet extends IStyleSetBase, TRef = unknown>(Component: React_2.ComponentClass<TComponentProps> | React_2.FunctionComponent<React_2.PropsWithChildren<TComponentProps>>, baseStyles: IStyleFunctionOrObject<TStyleProps, TStyleSet>, getProps?: (props: React_2.PropsWithoutRef<TComponentProps>) => Partial<React_2.PropsWithoutRef<TComponentProps>>, customizable?: ICustomizableProps, pure?: boolean): React_2.ForwardRefExoticComponent<React_2.PropsWithoutRef<TComponentProps> & React_2.RefAttributes<TRef>>;

// @public (undocumented)
export type StyleFunction<TStyleProps, TStyleSet extends IStyleSetBase> = IStyleFunctionOrObject<TStyleProps, TStyleSet> & {
    __cachedInputs__: (IStyleFunctionOrObject<TStyleProps, TStyleSet> | undefined)[];
    __noStyleOverride__: boolean;
    __shadowConfig__?: ShadowConfig;
};

// @public
export const tableProperties: Record<string, number>;

// @public
export const tdProperties: Record<string, number>;

// @public
export const textAreaProperties: Record<string, number>;

// @public
export const thProperties: Record<string, number>;

// @public
export function toMatrix<T>(items: T[], columnCount: number): T[][];

// @public
export const trProperties: Record<string, number>;

// @public
export function unhoistMethods(source: any, methodNames: string[]): void;

// @public
export const useAdoptedStylesheet: AdoptedStylesheetHook;

// @public
export const useAdoptedStylesheetEx: AdoptedStylesheetExHook;

// @public
export function useCustomizationSettings(properties: string[], scopeName?: string): ISettings;

// @public
export function useFocusRects(rootRef?: React_2.RefObject<HTMLElement | null>): void;

// @public
export const useHasMergeStylesShadowRootContext: HasMergeStylesShadowRootContextHook;

// @public
export const useIsomorphicLayoutEffect: typeof React_2.useEffect;

// @public (undocumented)
export const useMergeStylesHooks: () => {
    useAdoptedStylesheetEx: AdoptedStylesheetExHook;
    useAdoptedStylesheet: AdoptedStylesheetHook;
    useShadowConfig: ShadowConfigHook;
    useMergeStylesShadowRootContext: MergeStylesShadowRootContextHook;
    useHasMergeStylesShadowRootContext: HasMergeStylesShadowRootContextHook;
    useMergeStylesRootStylesheets: MergeStylesRootStylesheetsHook;
    useWindow: UseWindowHook;
    useStyled: UseStyledHook;
};

// @public
export const useMergeStylesRootStylesheets: MergeStylesRootStylesheetsHook;

// @public
export const useMergeStylesShadowRootContext: MergeStylesShadowRootContextHook;

// @public
export const useShadowConfig: ShadowConfigHook;

// @public (undocumented)
export const useStyled: UseStyledHook;

// @public (undocumented)
export type UseStyledHook = (scope: string) => ShadowConfig | undefined;

// @public (undocumented)
export type UseWindowHook = () => Window | undefined;

// @public
export function values<T>(obj: any): T[];

// @public
export const videoProperties: Record<string, number>;

// @public
export function warn(message: string): void;

// @public
export function warnConditionallyRequiredProps<P extends {}>(componentName: string, props: P, requiredProps: string[], conditionalPropName: string, condition: boolean): void;

// @public
export function warnControlledUsage<P>(params: IWarnControlledUsageParams<P>): void;

// @public
export function warnDeprecations<P extends {}>(componentName: string, props: P, deprecationMap: ISettingsMap<P>): void;

// @public
export function warnMutuallyExclusive<P>(componentName: string, props: P, exclusiveMap: ISettingsMap<P>): void;

// (No @packageDocumentation comment for this package)