import type { ActionObject, ExtendedActionObject } from '../globals';
interface ActionError {
    type?: string;
    message?: string;
    details?: unknown;
}
/**
 * The <strong>Action Manager</strong> object provides access to methods
 * that are used by Actions (ex: as found in Actions-Api or ContainerManager)
 * to track promises that are returned by the action.
 */
declare class ActionManager<T = unknown> {
    private actionMgrActions;
    private counterActionMgrId;
    /**
     * Constructor - <strong>Not for use outside of Core! Included for reference only.</strong>
     */
    constructor();
    /**
     * Returns a unique (for this session) actionMgrId that should
     * be provided in the payload to StateManager.dispatch so the
     * ActionManager can use it
     * @returns the next actionMgrID
     * @private
     */
    getNextActionMgrId(): string;
    /**
     * Registers the given Promise with the given actionMgrID
     * @param theActionMgrID the actionMgrID that is associated with the given Promise
     * @param thePromise the Promise associated with the given actionMgrID
     * @param theResolve the function called when the promise resolves
     * @param theReject the function called when the promise rejects
     * @param theActionType the type of action associated with this Promise
     * @param actionConfig the action config which has the context information
     * @param enableLoadingIndicator a boolean flag which tells if the actions need a loading indicator or not
     * @returns returns the registered ID if register succeeded or null if it failed (ex: ID already been used)
     * @private
     */
    register(theActionMgrID: string, thePromise: Promise<T>, theResolve: (value: T) => void, theReject: (reason?: ActionError) => void, theActionType?: string, actionConfig?: ActionObject, enableLoadingIndicator?: boolean): string | null;
    /**
     * Create a promise for an action and return an object containing the promise
     * and the ActionManager actionMgrID associated with that promise
     * @param theActionType the action type for which we're creating a promise
     * @param theActionMgrID the Action Manager ID associated with the promise. If provided,
     * the given ID is used when then promise is registered with the ActionManager. If not provided, we get the
     * ID and use the ID we get.
     * @returns object with actionMgrID and promise keys: { actionMgrID: <theID>, promise: <thePromise> }
     * @function
     */
    actionManagerPromise: (theActionType: string, theActionMgrID?: string) => {
        actionMgrID: string;
        promise: Promise<T>;
    };
    /**
     * resolve the promise associated with the given ID
     * @param theActionMgrID the ID of the Action Manager entry that should be resolved
     * @param data metadata info about the view
     * @param allowDispatch flag that dictates if Reset_Loading redux action should be dispatched or not
     * @returns returns the resolved ID if resolve was called or null if problem was encountered
     * @private
     */
    resolveActionByID(theActionMgrID: string | number, data?: T, allowDispatch?: boolean): string | number | null;
    /**
     * reject the promise associated with the given ID
     * @param theActionMgrID the ID of the Action Manager entry that should be resolved
     * @returns returns the rejected ID if reject was called or null if problem was encountered
     * @param allowDispatch flag that dictates if Reset_Loading redux action should be dispatched or not
     * @param error that gives the type of information about the error
     * @private
     */
    rejectActionByID(theActionMgrID: string | number, allowDispatch?: boolean, error?: ActionError): string | number | null;
    /**
     * This method is to add remote system id in request headers
     * @param remoteHeader - Remote system id to add in request headers.
     * @param actionConfig - Action config.
     * @function
     * @private
     */
    setRemoteCaseHeaderByContext(actionConfig: ActionObject, remoteHeader: string | undefined): void;
    /**
     * This method is to add necessary parameters for traditional remote case
     * @param actionConfig
     * @param className
     * @param remoteClassName
     * @returns string
     * @private
     */
    setTraditionalRemoteCaseParams(actionConfig: ExtendedActionObject, remoteCaseActionDetails: ExtendedActionObject): string;
}
declare const ActionManagerInstance: ActionManager<unknown>;
export { ActionManagerInstance };