import type { ComponentProps } from '@fluentui/react-components';
import type { ComponentState } from '@fluentui/react-components';
import type { ForwardRefComponent } from '@fluentui/react-components';
import type { PopoverSurfaceProps } from '@fluentui/react-components';
import type { PopoverSurfaceSlots } from '@fluentui/react-components';
import type { PositioningProps } from '@fluentui/react-components';
import type { PositioningShorthand } from '@fluentui/react-components';
import * as React_2 from 'react';
import type { Slot } from '@fluentui/react-components';
import type { SlotClassNames } from '@fluentui/react-components';

declare const PreviewSurface: ForwardRefComponent<PreviewSurfaceProps>;

/**
 * PreviewSurface Props
 */
declare type PreviewSurfaceProps = ComponentProps<PreviewSurfaceSlots> & PopoverSurfaceProps & {};

declare type PreviewSurfaceSlots = PopoverSurfaceSlots & {};

/**
 * Render the final JSX of SensitivityIcon
 */
export declare const renderSensitivityIcon_unstable: (state: SensitivityIconState) => JSX.Element;

/**
 * Render the final JSX of SensitivityLabel
 */
export declare const renderSensitivityLabel_unstable: (state: SensitivityLabelState) => JSX.Element;

/**
 * Render the final JSX of SensitivityTooltip
 */
export declare const renderSensitivityTooltip_unstable: (state: SensitivityTooltipState) => JSX.Element;

export declare const SensitivityIcon: ForwardRefComponent<SensitivityIconProps>;

export declare const sensitivityIconClassNames: SlotClassNames<SensitivityIconSlots>;

/**
 * SensitivityIcon Props
 */
export declare type SensitivityIconProps = ComponentProps<SensitivityIconSlots> & {
    fillColor?: string;
    withLock?: boolean;
};

export declare type SensitivityIconSlots = {
    root: NonNullable<Slot<'span'>>;
    foregroundIcon?: Slot<'span'>;
    backgroundIcon?: Slot<'span'>;
};

/**
 * State used in rendering SensitivityIcon
 */
export declare type SensitivityIconState = ComponentState<SensitivityIconSlots>;

export declare const SensitivityLabel: ForwardRefComponent<SensitivityLabelProps>;

export declare const sensitivityLabelClassNames: SlotClassNames<SensitivityLabelSlots>;

/**
 * SensitivityLabel Props
 */
export declare type SensitivityLabelProps = ComponentProps<SensitivityLabelSlots> & {
    description: string;
};

export declare type SensitivityLabelSlots = {
    root: Slot<'span'>;
    label?: Slot<'span'>;
    tooltip?: Slot<typeof SensitivityTooltip>;
};

/**
 * State used in rendering SensitivityLabel
 */
export declare type SensitivityLabelState = ComponentState<SensitivityLabelSlots> & {};

export declare const SensitivityTooltip: ForwardRefComponent<SensitivityTooltipProps>;

export declare const sensitivityTooltipClassNames: SlotClassNames<SensitivityTooltipSlots>;

/**
 * SensitivityTooltip Props
 */
export declare type SensitivityTooltipProps = ComponentProps<SensitivityTooltipSlots> & {
    positioning?: PositioningShorthand;
};

export declare type SensitivityTooltipSlots = {
    root: Slot<'span'>;
    heading?: Slot<'span'>;
    message?: Slot<'span'>;
    previewSurface?: Slot<typeof PreviewSurface>;
    trigger?: Slot<'span'>;
};

/**
 * State used in rendering SensitivityTooltip
 */
export declare type SensitivityTooltipState = ComponentState<SensitivityTooltipSlots> & {
    positioning: PositioningProps;
};

/**
 * Create the state required to render SensitivityIcon.
 *
 * The returned state can be modified with hooks such as useSensitivityIconStyles_unstable,
 * before being passed to renderSensitivityIcon_unstable.
 *
 * @param props - props from this instance of SensitivityIcon
 * @param ref - reference to root HTMLElement of SensitivityIcon
 */
export declare const useSensitivityIcon_unstable: (props: SensitivityIconProps, ref: React_2.Ref<HTMLElement>) => SensitivityIconState;

/**
 * Apply styling to the SensitivityIcon slots based on the state
 */
export declare const useSensitivityIconStyles_unstable: (state: SensitivityIconState) => SensitivityIconState;

/**
 * Create the state required to render SensitivityLabel.
 *
 * The returned state can be modified with hooks such as useSensitivityLabelStyles_unstable,
 * before being passed to renderSensitivityLabel_unstable.
 *
 * @param props - props from this instance of SensitivityLabel
 * @param ref - reference to root HTMLElement of SensitivityLabel
 */
export declare const useSensitivityLabel_unstable: (props: SensitivityLabelProps, ref: React.Ref<HTMLElement>) => SensitivityLabelState;

/**
 * Apply styling to the SensitivityLabel slots based on the state
 */
export declare const useSensitivityLabelStyles_unstable: (state: SensitivityLabelState) => SensitivityLabelState;

/**
 * Create the state required to render SensitivityTooltip.
 *
 * The returned state can be modified with hooks such as useSensitivityTooltipStyles_unstable,
 * before being passed to renderSensitivityTooltip_unstable.
 *
 * @param props - props from this instance of SensitivityTooltip
 * @param ref - reference to root HTMLElement of SensitivityTooltip
 */
export declare const useSensitivityTooltip_unstable: (props: SensitivityTooltipProps, ref: React_2.Ref<HTMLElement>) => SensitivityTooltipState;

/**
 * Apply styling to the SensitivityTooltip slots based on the state
 */
export declare const useSensitivityTooltipStyles_unstable: (state: SensitivityTooltipState) => SensitivityTooltipState;

export { }