import type { IRouterLocation } from './IRouterLocation';
/**
 * Provides an abstraction over `window.location` that automatically adapts
 * to the currently active routing strategy (hash vs. path-based routing).
 *
 * This class is designed to be framework-agnostic but works best within the
 * `mosaik-router` ecosystem. It allows consistent access to routing-relevant
 * values such as pathname, search parameters, and origin – regardless of how
 * routing is implemented.
 *
 * @example
 * const location = new RouterLocation(() => router.useHash);
 * const path = location.pathname;
 * const query = location.search;
 *
 * @public
 */
export declare class RouterLocation implements IRouterLocation {
    /**
     * A resolver function that determines whether hash-based routing is active.
     * This allows the location behavior to dynamically respond to runtime configuration.
     */
    private readonly _useHashFn;
    /**
     * Constructs a new instance of the `RouterLocation` class.
     *
     * @param useHashFn - A function that returns the current value of `useHash` routing mode.
     */
    constructor(useHashFn: () => boolean);
    /**
     * Gets the current full document location URL.
     */
    get href(): string;
    /**
     * Gets the normalized pathname of the application route.
     * Automatically strips the hash prefix if `useHash` mode is active.
     */
    get pathname(): string;
    /**
     * Gets the normalized search string (query parameters) for the current route.
     */
    get search(): string;
    /**
     * Gets the app-level route, which combines `pathname` and `search`.
     */
    get route(): string;
    /**
     * Gets the raw hash string (including the `#`).
     * Note: when using hash-based routing, this should be ignored in favor of `pathname`.
     */
    get hash(): string;
    /**
     * Gets the hostname (e.g. "localhost").
     */
    get hostname(): string;
    /**
     * Gets the full origin (e.g. "http://localhost:8080").
     */
    get origin(): string;
    /**
     * Gets the host (hostname + port).
     */
    get host(): string;
    /**
     * Gets the port number (e.g. "8080").
     */
    get port(): string;
    /**
     * Gets the protocol used (e.g. "http:").
     */
    get protocol(): string;
    /**
     * Navigates programmatically to a new route.
     * Uses `hash` or `history.pushState` depending on the routing strategy.
     *
     * @param path - The route path to navigate to.
     */
    navigate(path: string): void;
}
/**
 * Service locator for accessing the current `RouterLocation` instance globally.
 * Intended for use in scenarios where dependency injection is not available.
 *
 * @example
 * const currentPath = RouterLocationServiceLocator.current.pathname;
 *
 * @public
 */
export declare class RouterLocationServiceLocator {
    /**
     * Internal storage for the registered location instance.
     */
    private static _current;
    /**
     * Gets the globally registered `RouterLocation` instance.
     * Throws an error if not set.
     */
    static get current(): RouterLocation;
    /**
     * Returns whether a `RouterLocation` instance is registered.
     */
    static isSet(): boolean;
    /**
     * Registers the current `RouterLocation` instance.
     *
     * @param current - The location instance to register globally.
     */
    static set(current: RouterLocation): void;
}
//# sourceMappingURL=RouterLocation.d.ts.map