/// <reference types="react" />

import type { ComponentProps } from '@fluentui/react-components';
import type { ComponentState } from '@fluentui/react-components';
import type { Context } from '@fluentui/react-context-selector';
import type { ContextSelector } from '@fluentui/react-context-selector';
import type { DesignVersion } from '@fluentui-copilot/react-provider';
import { FC } from 'react';
import type { ForwardRefComponent } from '@fluentui/react-components';
import type { JSXElement } from '@fluentui/react-utilities';
import type { PopoverContextValue } from '@fluentui/react-components';
import type { PopoverProps } from '@fluentui/react-components';
import type { PopoverState } from '@fluentui/react-components';
import type { PopoverSurfaceProps } from '@fluentui/react-components';
import type { PopoverSurfaceSlots } from '@fluentui/react-components';
import type { PopoverSurfaceState } from '@fluentui/react-components';
import type { PopoverTriggerProps } from '@fluentui/react-components';
import type { PopoverTriggerState } from '@fluentui/react-components';
import { Provider } from 'react';
import { ProviderProps } from 'react';
import * as React_2 from 'react';
import type { Slot } from '@fluentui/react-components';
import type { SlotClassNames } from '@fluentui/react-components';

export declare const Preview: React_2.FC<PreviewProps>;

export declare const PreviewContent: ForwardRefComponent<PreviewContentProps>;

export declare const previewContentClassNames: SlotClassNames<PreviewContentSlots>;

/**
 * PreviewContent Props
 */
export declare type PreviewContentProps = ComponentProps<PreviewContentSlots>;

export declare type PreviewContentSlots = {
    root: NonNullable<Slot<'div'>>;
};

/**
 * State used in rendering PreviewContent
 */
export declare type PreviewContentState = ComponentState<PreviewContentSlots>;

export declare const PreviewContext: Context<PreviewContextValue>;

export declare const PreviewContextProvider: Provider<PreviewContextValue> & FC<ProviderProps<PreviewContextValue>>;

export declare type PreviewContextValue = PopoverContextValue & Pick<PreviewState, 'isPreviewLocked'>;

export declare const PreviewHeader: ForwardRefComponent<PreviewHeaderProps>;

export declare const previewHeaderClassNames: SlotClassNames<PreviewHeaderSlots>;

/**
 * PreviewHeader Props
 */
export declare type PreviewHeaderProps = ComponentProps<Partial<PreviewHeaderSlots>>;

export declare type PreviewHeaderSlots = {
    root: NonNullable<Slot<'div'>>;
    /**
     * Actions slot.
     */
    actions: Slot<'div'>;
    /**
     * Citation slot. Displays a `Citation`. Set to `null` to hide the citation.
     */
    citation: Slot<'span'>;
    /**
     * Label slot. Primary description of the preview.
     */
    label: NonNullable<Slot<'span'>>;
    /**
     * Media slot. Used to display Avatars, Icons, etc.
     */
    media: Slot<'div'>;
};

/**
 * State used in rendering PreviewHeader
 */
export declare type PreviewHeaderState = ComponentState<PreviewHeaderSlots>;

export declare const PreviewMetadata: ForwardRefComponent<PreviewMetadataProps>;

export declare const previewMetadataClassNames: SlotClassNames<PreviewMetadataSlots>;

/**
 * PreviewMetadata Props
 */
export declare type PreviewMetadataProps = ComponentProps<Partial<PreviewMetadataSlots>>;

export declare type PreviewMetadataSlots = {
    root: Slot<'div'>;
    /**
     * Icon slot in the metadata displayed after all text.
     */
    icon: Slot<'span'>;
    /**
     * First text displayed in the metadata.
     */
    primaryText: Slot<'span'>;
    /**
     * Second text displayed in the metadata.
     */
    secondaryText: Slot<'span'>;
    /**
     * Third text displayed in the metadata.
     */
    tertiaryText: Slot<'span'>;
};

/**
 * State used in rendering PreviewMetadata
 */
export declare type PreviewMetadataState = ComponentState<PreviewMetadataSlots>;

/**
 * Preview Props
 */
export declare type PreviewProps = Omit<PopoverProps, 'mouseLeaveDelay' | 'openOnHover'> & {
    /**
     * Sets the delay in milliseconds for closing the Preview on mouse leaving its trigger or popover surface when it was opened by hover.
     * @default 250
     */
    hideDelay?: number;
    /**
     * Sets the delay in milliseconds for opening the Preview on hovering its trigger.
     * @default 250
     */
    showDelay?: number;
};

/**
 * State used in rendering Preview
 */
export declare type PreviewState = PopoverState & {
    /**
     * Whether the Preview was opened by click or keyboard and is therefore locked until intentional interaction to close it.
     */
    isPreviewLocked: boolean;
};

export declare const PreviewSurface: ForwardRefComponent<PreviewSurfaceProps>;

export declare const previewSurfaceClassNames: SlotClassNames<PreviewSurfaceSlots>;

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

export declare type PreviewSurfaceSlots = PopoverSurfaceSlots & {};

/**
 * State used in rendering PreviewSurface
 */
export declare type PreviewSurfaceState = ComponentState<PreviewSurfaceSlots> & PopoverSurfaceState & Pick<Required<PreviewSurfaceProps>, 'designVersion'> & {};

export declare const PreviewTrigger: React_2.FC<PreviewTriggerProps>;

/**
 * PreviewTrigger Props
 */
export declare type PreviewTriggerProps = PopoverTriggerProps & {};

/**
 * State used in rendering PreviewTrigger
 */
export declare type PreviewTriggerState = PopoverTriggerState & {};

/**
 * Render the final JSX of Preview
 */
export declare const renderPreview_unstable: (state: PreviewState) => JSXElement;

/**
 * Render the final JSX of PreviewContent
 */
export declare const renderPreviewContent_unstable: (state: PreviewContentState) => JSXElement;

/**
 * Render the final JSX of PreviewHeader
 */
export declare const renderPreviewHeader_unstable: (state: PreviewHeaderState) => JSXElement;

/**
 * Render the final JSX of PreviewMetadata
 */
export declare const renderPreviewMetadata_unstable: (state: PreviewMetadataState) => JSXElement;

/**
 * Render the final JSX of PreviewSurface
 */
export declare const renderPreviewSurface_unstable: (state: PreviewSurfaceState) => JSXElement;

/**
 * Render the final JSX of PreviewTrigger
 */
export declare const renderPreviewTrigger_unstable: (state: PreviewTriggerState) => JSXElement | null;

/**
 * Create the state required to render Preview.
 *
 * The returned state can be modified with hooks such as usePreviewStyles_unstable,
 * before being passed to renderPreview_unstable.
 *
 * @param props - props from this instance of Preview
 * @param ref - reference to root HTMLElement of Preview
 */
export declare const usePreview_unstable: (props: PreviewProps) => PreviewState;

/**
 * Create the state required to render PreviewContent.
 *
 * The returned state can be modified with hooks such as usePreviewContentStyles_unstable,
 * before being passed to renderPreviewContent_unstable.
 *
 * @param props - props from this instance of PreviewContent
 * @param ref - reference to root HTMLElement of PreviewContent
 */
export declare const usePreviewContent_unstable: (props: PreviewContentProps, ref: React_2.Ref<HTMLDivElement>) => PreviewContentState;

/**
 * Apply styling to the PreviewContent slots based on the state
 */
export declare const usePreviewContentStyles_unstable: (state: PreviewContentState) => PreviewContentState;

export declare const usePreviewContext_unstable: <T>(selector: ContextSelector<PreviewContextValue, T>) => T;

/**
 * Create the state required to render PreviewHeader.
 *
 * The returned state can be modified with hooks such as usePreviewHeaderStyles_unstable,
 * before being passed to renderPreviewHeader_unstable.
 *
 * @param props - props from this instance of PreviewHeader
 * @param ref - reference to root HTMLElement of PreviewHeader
 */
export declare const usePreviewHeader_unstable: (props: PreviewHeaderProps, ref: React_2.Ref<HTMLDivElement>) => PreviewHeaderState;

/**
 * Apply styling to the PreviewHeader slots based on the state
 */
export declare const usePreviewHeaderStyles_unstable: (state: PreviewHeaderState) => PreviewHeaderState;

/**
 * Create the state required to render PreviewMetadata.
 *
 * The returned state can be modified with hooks such as usePreviewMetadataStyles_unstable,
 * before being passed to renderPreviewMetadata_unstable.
 *
 * @param props - props from this instance of PreviewMetadata
 * @param ref - reference to root HTMLElement of PreviewMetadata
 */
export declare const usePreviewMetadata_unstable: (props: PreviewMetadataProps, ref: React_2.Ref<HTMLDivElement>) => PreviewMetadataState;

/**
 * Apply styling to the PreviewMetadata slots based on the state
 */
export declare const usePreviewMetadataStyles_unstable: (state: PreviewMetadataState) => PreviewMetadataState;

/**
 * Create the state required to render PreviewSurface.
 *
 * The returned state can be modified with hooks such as usePreviewSurfaceStyles_unstable,
 * before being passed to renderPreviewSurface_unstable.
 *
 * @param props - props from this instance of PreviewSurface
 * @param ref - reference to root HTMLElement of PreviewSurface
 */
export declare const usePreviewSurface_unstable: (props: PreviewSurfaceProps, ref: React_2.Ref<HTMLDivElement>) => PreviewSurfaceState;

/**
 * Apply styling to the PreviewSurface slots based on the state
 */
export declare const usePreviewSurfaceStyles_unstable: (state: PreviewSurfaceState) => PreviewSurfaceState;

/**
 * Create the state required to render PreviewTrigger.
 *
 * The returned state can be modified with hooks such as usePreviewTriggerStyles_unstable,
 * before being passed to renderPreviewTrigger_unstable.
 *
 * @param props - props from this instance of PreviewTrigger
 * @param ref - reference to root HTMLElement of PreviewTrigger
 */
export declare const usePreviewTrigger_unstable: (props: PreviewTriggerProps) => PreviewTriggerState;

export { }