import { BoolUpdateFlag } from "../BoolUpdateFlag";
import { Component } from "../Component";
import { AnimatorController } from "./AnimatorController";
import { AnimatorControllerLayer } from "./AnimatorControllerLayer";
import { AnimatorControllerParameter, AnimatorControllerParameterValue } from "./AnimatorControllerParameter";
import { AnimatorState } from "./AnimatorState";
import { AnimatorCullingMode } from "./enums/AnimatorCullingMode";
import { AnimatorStatePlayData } from "./internal/AnimatorStatePlayData";
/**
 * The controller of the animation system.
 */
export declare class Animator extends Component {
    private static _passedTriggerParameterNames;
    /** Culling mode of this Animator. */
    cullingMode: AnimatorCullingMode;
    /** The playback speed of the Animator, 1.0 is normal playback speed. */
    speed: number;
    /** Whether the Animator sends AnimationEvent callbacks. */
    fireEvents: boolean;
    protected _animatorController: AnimatorController;
    protected _controllerUpdateFlag: BoolUpdateFlag;
    protected _updateMark: number;
    private _animatorLayersData;
    private _curveOwnerPool;
    private _animationEventHandlerPool;
    private _parametersValueMap;
    private _tempAnimatorStateInfo;
    private _controlledRenderers;
    /**
     * All layers from the AnimatorController which belongs this Animator.
     */
    get animatorController(): AnimatorController;
    set animatorController(animatorController: AnimatorController);
    /**
     * The layers in the animator's controller.
     */
    get layers(): Readonly<AnimatorControllerLayer[]>;
    /**
     * The parameters in the animator's controller.
     */
    get parameters(): Readonly<AnimatorControllerParameter[]>;
    /**
     * Play a state by name.
     * @param stateName - The state name
     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
     * @param normalizedTimeOffset - The normalized time offset (between 0 and 1, default 0) to start the state's animation from
     */
    play(stateName: string, layerIndex?: number, normalizedTimeOffset?: number): void;
    /**
     * Create a cross fade from the current state to another state with a normalized duration.
     * @param stateName - The state name
     * @param normalizedDuration - The normalized duration of the transition, relative to the destination state's duration (range: 0 to 1)
     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
     * @param normalizedTimeOffset - The normalized time offset (between 0 and 1, default 0) to start the destination state's animation from
     */
    crossFade(stateName: string, normalizedDuration: number, layerIndex?: number, normalizedTimeOffset?: number): void;
    /**
     * Create a cross fade from the current state to another state with a fixed duration.
     * @param stateName - The state name
     * @param fixedDuration - The duration of the transition in seconds
     * @param layerIndex - The layer index(default -1). If layer is -1, play the first state with the given state name
     * @param normalizedTimeOffset - The normalized time offset (between 0 and 1, default 0) to start the destination state's animation from
     */
    crossFadeInFixedDuration(stateName: string, fixedDuration: number, layerIndex?: number, normalizedTimeOffset?: number): void;
    /**
     * Evaluates the animator component based on deltaTime.
     * @param deltaTime - The deltaTime when the animation update
     */
    update(deltaTime: number): void;
    /**
     * Get the playing state from the target layerIndex.
     * @param layerIndex - The layer index
     */
    getCurrentAnimatorState(layerIndex: number): AnimatorState;
    /**
     * Get the state by name.
     * @param stateName - The state name
     * @param layerIndex - The layer index(default -1). If layer is -1, find the first state with the given state name
     */
    /**
     * Find the per-instance play data for a state by name.
     * The returned object's `speed` and `wrapMode` are per-instance and safe to modify without affecting other Animator instances.
     * @param stateName - The state name
     * @param layerIndex - The layer index (default -1, searches all layers)
     * @returns Per-instance AnimatorStatePlayData, or null if not found
     */
    findAnimatorState(stateName: string, layerIndex?: number): AnimatorStatePlayData;
    /**
     * Get the layer by name.
     * @param name - The layer's name.
     * @todo Return per-instance layer data (like AnimatorStatePlayData for states) instead of shared asset.
     *       Currently returns the shared AnimatorControllerLayer — modifying `weight` affects all instances.
     *       Should follow Unity's pattern: Animator.SetLayerWeight/GetLayerWeight (per-instance).
     */
    findLayerByName(name: string): AnimatorControllerLayer;
    /**
     * Get the parameter by name from animatorController.
     * @param name - The name of the parameter
     */
    getParameter(name: string): AnimatorControllerParameter;
    /**
     * Get the value of the given parameter.
     * @param name - The name of the parameter
     * @param value - The value of the parameter
     */
    getParameterValue(name: string): AnimatorControllerParameterValue;
    /**
     * Set the value of the given parameter.
     * @param name - The name of the parameter
     * @param value - The value of the parameter
     */
    setParameterValue(name: string, value: AnimatorControllerParameterValue): void;
    /**
     * Activate the trigger parameter by name.
     * @param name - The name of the trigger parameter
     */
    activateTriggerParameter(name: string): void;
    /**
     * Reset the trigger parameter to deactivate it by name.
     * @param name - The name of the trigger parameter
     */
    deactivateTriggerParameter(name: string): void;
    protected _onDestroy(): void;
    private _crossFade;
    private _getAnimatorStateInfo;
    private _getAnimatorStateData;
    private _saveAnimatorStateData;
    private _saveAnimatorEventHandlers;
    private _clearCrossData;
    private _addCrossOwner;
    private _prepareCrossFading;
    private _prepareStandbyCrossFading;
    private _prepareFixedPoseCrossFading;
    private _prepareSrcCrossData;
    private _prepareDestCrossData;
    private _getAnimatorLayerData;
    private _updateState;
    private _updatePlayingState;
    private _evaluatePlayingState;
    private _updateCrossFadeState;
    private _evaluateCrossFadeState;
    private _updateCrossFadeFromPoseState;
    private _evaluateCrossFadeFromPoseState;
    private _updateFinishedState;
    private _evaluateFinishedState;
    private _updateCrossFadeData;
    private _preparePlayOwner;
    private _applyStateTransitions;
    private _tryCrossFadeInterrupt;
    private _checkNoExitTimeTransitions;
    private _checkSubTransition;
    private _checkBackwardsSubTransition;
    private _applyTransitionsByCondition;
    private _preparePlay;
    private _applyTransition;
    private _checkConditions;
    private _prepareCrossFadeByTransition;
    private _fireAnimationEvents;
    private _fireSubAnimationEvents;
    private _fireBackwardSubAnimationEvents;
    private _checkAnyAndEntryState;
    private _checkRevertOwner;
    private _fireAnimationEventsAndCallScripts;
    private _deactivateTriggeredParameters;
}
