import '../../../../assert/js/assert.js';
import '../../../../globals.js';
import ResponsePacket, { ResolvedResponse, SpeakableResolvedOptions, VoicingResponse } from '../../../../utterance-queue/js/ResponsePacket.js';
import ResponsePatternCollection from '../../../../utterance-queue/js/ResponsePatternCollection.js';
import Utterance, { TAlertable } from '../../../../utterance-queue/js/Utterance.js';
import { InteractiveHighlightingOptions, Node, SceneryListenerFunction } from '../../imports.js';
import Constructor from '../../../../phet-core/js/types/Constructor.js';
import IntentionalAny from '../../../../phet-core/js/types/IntentionalAny.js';
import TinyProperty from '../../../../axon/js/TinyProperty.js';
import { TInteractiveHighlighting } from './InteractiveHighlighting.js';
type SelfOptions = {
    voicingNameResponse?: VoicingResponse;
    voicingObjectResponse?: VoicingResponse;
    voicingContextResponse?: VoicingResponse;
    voicingHintResponse?: VoicingResponse;
    voicingResponsePatternCollection?: ResponsePatternCollection;
    voicingIgnoreVoicingManagerProperties?: boolean;
    voicingFocusListener?: SceneryListenerFunction<FocusEvent> | null;
    voicingUtterance?: Utterance | null;
};
export type VoicingOptions = SelfOptions & InteractiveHighlightingOptions;
export type SpeakingOptions = {
    utterance?: SelfOptions['voicingUtterance'];
} & SpeakableResolvedOptions;
export interface TVoicing<SuperType extends Node = Node> extends TInteractiveHighlighting<SuperType> {
    _voicingResponsePacket: ResponsePacket;
    _voicingUtterance: Utterance | null;
    _voicingCanSpeakProperty: TinyProperty<boolean>;
    initialize(...args: IntentionalAny[]): this;
    voicingSpeakFullResponse(providedOptions?: SpeakingOptions): void;
    voicingSpeakResponse(providedOptions?: SpeakingOptions): void;
    voicingSpeakNameResponse(providedOptions?: SpeakingOptions): void;
    voicingSpeakObjectResponse(providedOptions?: SpeakingOptions): void;
    voicingSpeakContextResponse(providedOptions?: SpeakingOptions): void;
    voicingSpeakHintResponse(providedOptions?: SpeakingOptions): void;
    collectResponse(providedOptions?: SpeakingOptions): TAlertable;
    speakContent(content: TAlertable): void;
    setVoicingNameResponse(response: VoicingResponse): void;
    voicingNameResponse: ResolvedResponse;
    getVoicingNameResponse(): ResolvedResponse;
    setVoicingObjectResponse(response: VoicingResponse): void;
    voicingObjectResponse: ResolvedResponse;
    getVoicingObjectResponse(): ResolvedResponse;
    setVoicingContextResponse(response: VoicingResponse): void;
    voicingContextResponse: ResolvedResponse;
    getVoicingContextResponse(): ResolvedResponse;
    setVoicingHintResponse(response: VoicingResponse): void;
    voicingHintResponse: ResolvedResponse;
    getVoicingHintResponse(): ResolvedResponse;
    setVoicingIgnoreVoicingManagerProperties(ignoreProperties: boolean): void;
    voicingIgnoreVoicingManagerProperties: boolean;
    getVoicingIgnoreVoicingManagerProperties(): boolean;
    setVoicingResponsePatternCollection(patterns: ResponsePatternCollection): void;
    voicingResponsePatternCollection: ResponsePatternCollection;
    getVoicingResponsePatternCollection(): ResponsePatternCollection;
    setVoicingUtterance(utterance: Utterance): void;
    voicingUtterance: Utterance;
    getVoicingUtterance(): Utterance;
    setVoicingFocusListener(focusListener: SceneryListenerFunction<FocusEvent> | null): void;
    voicingFocusListener: SceneryListenerFunction<FocusEvent> | null;
    getVoicingFocusListener(): SceneryListenerFunction<FocusEvent> | null;
    defaultFocusListener(): void;
    get _isVoicing(): true;
    clean(): void;
    cleanVoicingUtterance(): void;
    mutate(options?: SelfOptions & Parameters<SuperType['mutate']>[0]): this;
}
declare const Voicing: {
    <SuperType extends Constructor<Node>>(Type: SuperType): SuperType & Constructor<TVoicing<InstanceType<SuperType>>>;
    VOICING_OPTION_KEYS: string[];
    /**
     * Alert an Utterance to the voicingUtteranceQueue. The Utterance must have voicingCanAnnounceProperties and hopefully
     * at least one of the Properties is a VoicingNode's canAnnounceProperty so that this Utterance is only announced
     * when the VoicingNode is globally visible and voicingVisible.
     * @static
     */
    alertUtterance(utterance: Utterance): void;
    /**
     * Assign the voicingNode's voicingCanSpeakProperty to the Utterance so that the Utterance can only be announced
     * if the voicingNode is globally visible and voicingVisible in the display.
     * @static
     */
    registerUtteranceToVoicingNode(utterance: Utterance, voicingNode: TVoicing): void;
    /**
     * Remove a voicingNode's voicingCanSpeakProperty from the Utterance.
     * @static
     */
    unregisterUtteranceToVoicingNode(utterance: Utterance, voicingNode: VoicingNode): void;
    /**
     * Assign the Node's voicingVisibleProperty and visibleProperty to the Utterance so that the Utterance can only be
     * announced if the Node is visible and voicingVisible. This is LOCAL visibility and does not care about ancestors.
     * This should rarely be used, in general you should be registering an Utterance to a VoicingNode and its
     * voicingCanSpeakProperty.
     * @static
     */
    registerUtteranceToNode(utterance: Utterance, node: Node): void;
    /**
     * Remove a Node's voicingVisibleProperty and visibleProperty from the voicingCanAnnounceProperties of the Utterance.
     * @static
     */
    unregisterUtteranceToNode(utterance: Utterance, node: Node): void;
};
export type VoicingNode = Node & TVoicing;
export declare function isVoicing(something: IntentionalAny): something is VoicingNode;
export default Voicing;
//# sourceMappingURL=Voicing.d.ts.map