import * as i0 from '@angular/core';
import { InjectionToken, Provider, EnvironmentProviders, OnInit, OnChanges, SimpleChanges, OnDestroy, ModuleWithProviders } from '@angular/core';
import * as ngx_matomo_client_core from 'ngx-matomo-client/core';
import { SafeResourceUrl } from '@angular/platform-browser';
import * as rxjs from 'rxjs';

/** Wrap a function to ensure it is called only once, ignoring all subsequent calls */
declare function runOnce<T, ARGS extends unknown[]>(fn: (...args: ARGS) => T): (...args: ARGS) => T | void;
/** Wrap a function to ensure it is called only once, calling an error handler otherwise */
declare function runOnce<T, ARGS extends unknown[], U = T>(fn: (...args: ARGS) => T, errorOrHandler: string | ((...args: ARGS) => U | never)): (...args: ARGS) => T | U;

declare function appendTrailingSlash(str: string): string;

/** Extract from a type T all getter-like method keys, optionally filtered by those returning type U */
type Getters<T, U = any> = keyof T & {
    [P in keyof T]: T[P] extends () => U ? P : never;
}[keyof T];
/** Extract all methods from a type T */
type Methods<T> = keyof T & {
    [P in keyof T]: T[P] extends (...args: any[]) => any ? P : never;
}[keyof T];
type RequireAtLeastOne<T> = {
    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<keyof T, K>>>;
}[keyof T];
type NonEmptyArray<T> = [T, ...T[]];
type NonEmptyReadonlyArray<T> = Readonly<NonEmptyArray<T>>;
type Prefixed<S, PREFIX extends string> = S extends string ? `${PREFIX}${S}` : never;
type PrefixedType<MATOMO, PREFIX extends string> = {
    [K in keyof MATOMO as Prefixed<K, PREFIX>]: MATOMO[K];
};

declare class ScriptInjector {
    private readonly scriptFactory;
    private readonly injector;
    private readonly document;
    injectDOMScript(scriptUrl: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScriptInjector, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScriptInjector>;
}

/** Internal marker token to detect that router has been enabled */
declare const MATOMO_ROUTER_ENABLED: InjectionToken<boolean>;
/** Injection token for {@link MatomoConfiguration} */
declare const MATOMO_CONFIGURATION: InjectionToken<MatomoConfiguration>;
/**
 * For internal use only. Injection token for {@link InternalMatomoConfiguration}
 *
 */
declare const INTERNAL_MATOMO_CONFIGURATION$1: InjectionToken<InternalMatomoConfiguration>;
/**
 * For internal use only. Injection token for deferred {@link InternalMatomoConfiguration}.
 *
 */
declare const DEFERRED_INTERNAL_MATOMO_CONFIGURATION: InjectionToken<DeferredInternalMatomoConfiguration>;
/**
 * For internal use only. Injection token for fully loaded async {@link InternalMatomoConfiguration}.
 *
 */
declare const ASYNC_INTERNAL_MATOMO_CONFIGURATION: InjectionToken<Promise<InternalMatomoConfiguration>>;
/**
 * For internal use only. Module configuration merged with default values.
 *
 */
type InternalMatomoConfiguration = Omit<MatomoConfiguration, 'mode' | 'requireConsent'> & Omit<Required<BaseMatomoConfiguration>, 'requireConsent'> & {
    mode?: MatomoInitializationBehavior;
    requireConsent: MatomoConsentRequirement;
};
interface DeferredInternalMatomoConfiguration {
    readonly configuration: Promise<InternalMatomoConfiguration>;
    markReady(configuration: InternalMatomoConfiguration): void;
}
/**
 * - __auto__: automatically inject matomo script using provided configuration
 * - __manual__: do not inject Matomo script. In this case, initialization script must be provided
 * - __deferred__: automatically inject matomo script when deferred tracker configuration is provided using `MatomoInitializerService.initializeTracker()`.
 */
type MatomoInitializationBehavior = 'auto' | 'manual' | 'deferred';
/** @deprecated Use {@link MatomoInitializationBehavior} instead */
declare enum MatomoInitializationMode {
    /**
     * Automatically inject matomo script using provided configuration
     *
     * @deprecated Use `'auto'` instead
     */
    AUTO = 0,
    /**
     * Do not inject Matomo script. In this case, initialization script must be provided
     *
     * @deprecated Use `'manual'` instead
     */
    MANUAL = 1,
    /**
     * Automatically inject matomo script when deferred tracker configuration is provided using `MatomoInitializerService.initializeTracker()`.
     *
     * @deprecated Use `'deferred'` instead
     */
    AUTO_DEFERRED = 2
}
type MatomoConsentRequirement = 'none' | 'cookie' | 'tracking';
/** @deprecated Use {@link MatomoConsentRequirement} instead */
declare enum MatomoConsentMode {
    /** Do not require any consent, always track users */
    NONE = 0,
    /** Require cookie consent */
    COOKIE = 1,
    /** Require tracking consent */
    TRACKING = 2
}
interface MatomoTrackerConfiguration {
    /** Matomo site id */
    siteId: number | string;
    /** Matomo server url */
    trackerUrl: string;
    /** The trackerUrlSuffix is always appended to the trackerUrl. It defaults to matomo.php */
    trackerUrlSuffix?: string;
}
interface MultiTrackersConfiguration {
    /**
     * Configure multiple tracking servers. <b>Order matters: if no custom script url is
     * provided, Matomo script will be downloaded from first tracker.</b>
     */
    trackers: MatomoTrackerConfiguration[];
}
interface BaseMatomoConfiguration {
    /** Set to `true` to disable tracking */
    disabled?: boolean;
    /** If `true`, track a page view when app loads (default `false`) */
    trackAppInitialLoad?: boolean;
    /**
     * Configure link clicks tracking
     *
     * If `true` (the default value), enable link tracking, excluding middle-clicks and contextmenu events.
     * If `enable-pseudo`, enable link tracking, including middle-clicks and contextmenu events.
     * If `false`, to disable this Matomo feature (default `true`).
     *
     * Used when {@link trackAppInitialLoad} is `true` and when automatic page tracking is enabled.
     *
     * @see {@link MatomoTracker.enableLinkTracking} for more details
     */
    enableLinkTracking?: boolean | 'enable-pseudo';
    /** Set to `true` to not track users who opt out of tracking using <i>Do Not Track</i> setting */
    acceptDoNotTrack?: boolean;
    /**
     * Configure user consent requirement
     *
     * To identify whether you need to ask for any consent, you need to determine whether your lawful
     * basis for processing personal data is "Consent" or "Legitimate interest", or whether you can
     * avoid collecting personal data altogether.
     *
     * Matomo differentiates between cookie and tracking consent:
     * - In the context of <b>tracking consent</b> no cookies will be used and no tracking request
     *   will be sent unless consent was given. As soon as consent was given, tracking requests will
     *   be sent and cookies will be used.
     * - In the context of <b>cookie consent</b> tracking requests will always be sent. However,
     *   cookies will be only used if consent for storing and using cookies was given by the user.
     *
     * Note that cookies impact reports accuracy.
     *
     * See Matomo guide: {@link https://developer.matomo.org/guides/tracking-consent}
     */
    requireConsent?: MatomoConsentRequirement | MatomoConsentMode;
    /** Set to `true` to enable Javascript errors tracking as <i>events</i> (with category <i>JavaScript Errors</i>) */
    enableJSErrorTracking?: boolean;
    /** Set to `true` to run matomo calls outside of angular NgZone. This may fix angular freezes. This has no effect in zoneless applications. */
    runOutsideAngularZone?: boolean;
    /**
     * Set to `true` to avoid sending campaign parameters
     *
     * By default, Matomo will send campaign parameters (mtm, utm, etc.) to the tracker and record that information.
     * Some privacy regulations may not allow for this information to be collected.
     *
     * <b>This is available as of Matomo 5.1 only.</b>
     */
    disableCampaignParameters?: boolean;
}
/**
 * Mapping type to extend input types with legacy `MatomoInitializationMode` type
 *
 * TODO remove when `MatomoInitializationMode` is removed
 */
interface MatomoInitializationBehaviorInputMapping {
    manual: MatomoInitializationMode.MANUAL;
    auto: MatomoInitializationMode.AUTO;
    deferred: MatomoInitializationMode.AUTO_DEFERRED;
}
/**
 * Special type to map a `MatomoInitializationBehavior` to either itself or the legacy equivalent `MatomoInitializationMode`
 *
 * @example
 * MatomoInitializationBehaviorInput<'auto'>
 *   // Equivalent to:
 * 'auto' | MatomoInitializationMode.AUTO
 *
 * MatomoInitializationBehaviorInput<'manual'>
 *   // Equivalent to:
 * 'manual' | MatomoInitializationMode.MANUAL
 *
 * MatomoInitializationBehaviorInput<'deferred'>
 *   // Equivalent to:
 * 'deferred' | MatomoInitializationMode.AUTO_DEFERRED
 *
 * TODO remove when `MatomoInitializationMode` is removed and use `MatomoInitializationBehavior` instead
 */
type MatomoInitializationBehaviorInput<T extends MatomoInitializationBehavior = MatomoInitializationBehavior> = T | MatomoInitializationBehaviorInputMapping[T];
interface BaseAutoMatomoConfiguration<M extends 'auto' | 'deferred' = 'auto'> {
    /**
     * Set the script initialization mode (default is `'auto'`)
     *
     * @see MatomoInitializationBehavior
     */
    mode?: MatomoInitializationBehaviorInput<M>;
    /** Matomo script url (default is `matomo.js` appended to main tracker url) */
    scriptUrl: string;
}
type Without<T, U> = {
    [P in Exclude<keyof T, keyof U>]?: never;
};
type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
type XOR3<T, U, V> = XOR<T, XOR<U, V>>;
type ManualMatomoConfiguration = {
    /**
     * Set the script initialization mode (default is `'auto'`)
     *
     * @see MatomoInitializationBehavior
     */
    mode: MatomoInitializationBehaviorInput<'manual'>;
};
type DeferredMatomoConfiguration = {
    /**
     * Set the script initialization mode (default is `'auto'`)
     *
     * @see MatomoInitializationBehavior
     */
    mode: MatomoInitializationBehaviorInput<'deferred'>;
};
type ExplicitAutoConfiguration<M extends 'auto' | 'deferred' = 'auto'> = Partial<BaseAutoMatomoConfiguration<M>> & XOR<MatomoTrackerConfiguration, MultiTrackersConfiguration>;
type EmbeddedAutoConfiguration<M extends 'auto' | 'deferred' = 'auto'> = BaseAutoMatomoConfiguration<M> & Partial<MultiTrackersConfiguration>;
type AutoMatomoConfiguration<M extends 'auto' | 'deferred' = 'auto'> = XOR<ExplicitAutoConfiguration<M>, EmbeddedAutoConfiguration<M>>;
type MatomoConfiguration = BaseMatomoConfiguration & XOR3<AutoMatomoConfiguration, ManualMatomoConfiguration, DeferredMatomoConfiguration>;
declare function isAutoConfigurationMode(config: MatomoConfiguration | InternalMatomoConfiguration): config is AutoMatomoConfiguration;
declare function isExplicitTrackerConfiguration<M extends 'auto' | 'deferred'>(config: AutoMatomoConfiguration<M>): config is ExplicitAutoConfiguration<M>;
declare function getTrackersConfiguration(config: ExplicitAutoConfiguration<'auto' | 'deferred'>): MatomoTrackerConfiguration[];

type ReturnType<T> = T extends (...args: any) => infer R ? R : any;
type InternalMatomoTrackerType = Pick<InternalMatomoTracker<unknown, string>, 'get' | 'push' | 'pushFn'>;
declare class InternalMatomoTracker<MATOMO, PREFIX extends string = ''> {
    private readonly ngZone;
    private readonly config;
    constructor();
    /** Asynchronously call provided method name on matomo tracker instance */
    get<K extends Getters<PrefixedType<MATOMO, PREFIX>>>(getter: K extends keyof PrefixedType<MATOMO, PREFIX> ? K : never): Promise<ReturnType<PrefixedType<MATOMO, PREFIX>[K]>>;
    pushFn<T>(fn: (matomo: PrefixedType<MATOMO, PREFIX>) => T): Promise<T>;
    push(args: NonEmptyArray<unknown>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InternalMatomoTracker<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InternalMatomoTracker<any, any>>;
}

declare function provideTestingTracker(): Provider[];
declare class MatomoTestingTracker<MATOMO = unknown, PREFIX extends string = ''> implements InternalMatomoTrackerType {
    private readonly initStatus;
    /** Get list of all calls until initialization */
    callsOnInit: unknown[][];
    /** Get list of all calls after initialization */
    callsAfterInit: unknown[][];
    /** Get a copy of all calls since application startup */
    get calls(): unknown[];
    countCallsAfterInit(command: string): number;
    reset(): void;
    /** Asynchronously call provided method name on matomo tracker instance */
    get<K extends keyof PrefixedType<MATOMO, PREFIX>>(_: K): Promise<never>;
    push(arg: unknown[]): void;
    pushFn<T>(_: (matomo: PrefixedType<MATOMO, PREFIX>) => T): Promise<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoTestingTracker<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MatomoTestingTracker<any, any>>;
}

type MatomoScriptFactory = (scriptUrl: string, document: Document) => HTMLScriptElement;
declare const createDefaultMatomoScriptElement: MatomoScriptFactory;
declare const MATOMO_SCRIPT_FACTORY: InjectionToken<MatomoScriptFactory>;

declare const PRIVATE_MATOMO_PROVIDERS: unique symbol;
declare const PRIVATE_MATOMO_CHECKS: unique symbol;
type MatomoFeatureKind = unknown;
interface MatomoFeature {
    readonly kind: MatomoFeatureKind;
    [PRIVATE_MATOMO_PROVIDERS]: Provider[];
    [PRIVATE_MATOMO_CHECKS]?: (features: MatomoFeatureKind[]) => void;
}
declare function createMatomoFeature(kind: MatomoFeatureKind, providers: Provider[], checks?: (features: MatomoFeatureKind[]) => void): MatomoFeature;
/**
 * Return Matomo providers (typically added to an application's root module)
 *
 * Additional features may be provided as additional arguments, like this:
 * @example
 * // Simple configuration
 * providers: [ provideMatomo({ siteId: 1, trackerUrl: '...' }) ]
 *
 * // With additional features
 * providers: [
 *     provideMatomo(
 *         { siteId: 1, trackerUrl: '...' },
 *         withScriptFactory(...),
 *     )
 * ]
 *
 * // With advanced config factory function
 * providers: [
 *     provideMatomo(
 *         () => inject(MyService).getMatomoConfig(),
 *         withScriptFactory(...),
 *     )
 * ]
 *
 * @param config Matomo configuration (or configuration factory, which can use `inject`)
 * @param features Optional additional features to enable
 *
 * @see MatomoConfiguration
 * @see withScriptFactory
 * @see withRouter
 * @see withRouterInterceptors
 * @see withRouteData
 */
declare function provideMatomo(config: MatomoConfiguration | (() => MatomoConfiguration), ...features: MatomoFeature[]): EnvironmentProviders;
/** Add a custom script factory to use for Matomo's script element */
declare function withScriptFactory(scriptFactory: MatomoScriptFactory): MatomoFeature;

type CssSizeInput = string | number | null | undefined;

/**
 * Basic opt-out form, based on an iframe auto-generated by Matomo.
 *
 * <b>WARNING:</b> By default, this component assumes the tracker url set in MatomoConfiguration is
 * safe to be used as an iframe `src`. You have to make sure that this url is safe before using this
 * component!
 *
 * Note: This component relies on the matomo-generated opt-out form, which is deprecated
 * since Matomo version 4.12.0. It will be marked as deprecated soon.
 *
 * @see https://developer.matomo.org/changelog#new-privacy-opt-out-options
 */
declare class MatomoOptOutFormComponent implements OnInit, OnChanges {
    private readonly sanitizer;
    private readonly config;
    private _defaultServerUrl?;
    private _defaultServerUrlInitialized;
    private _border;
    private _width;
    private _height;
    private _iframeSrc;
    private _serverUrlOverride?;
    /**
     * Set a custom locale for the opt-out form
     * <br>
     * Default is the current app locale available in LOCALE_ID token
     */
    locale: string;
    /** Font color (note that Matomo currently only supports hexadecimal without leading hash notation) */
    color: string;
    /** Background color (note that Matomo currently only supports hexadecimal without leading hash notation) */
    backgroundColor: string;
    fontSize: string;
    fontFamily: string;
    constructor();
    get serverUrl(): SafeResourceUrl | undefined;
    /**
     * Set a custom Matomo server url to be used for iframe generation
     * <br>
     * By default, tracker url is retrieved from MatomoConfiguration.
     * <br>
     * <b>WARNING:</b> This component assumes the url you provide is safe to be used as an iframe
     * `src`. You have to make sure that this url is safe before using this component!
     */
    set serverUrl(value: SafeResourceUrl | undefined);
    get iframeSrc(): SafeResourceUrl | undefined;
    get height(): string;
    set height(value: string);
    get width(): string;
    set width(value: string);
    get border(): string;
    set border(value: string);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private updateUrl;
    static ngAcceptInputType_border: CssSizeInput;
    static ngAcceptInputType_width: CssSizeInput;
    static ngAcceptInputType_height: CssSizeInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoOptOutFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatomoOptOutFormComponent, "matomo-opt-out-form", never, { "locale": { "alias": "locale"; "required": false; }; "color": { "alias": "color"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "fontFamily": { "alias": "fontFamily"; "required": false; }; "serverUrl": { "alias": "serverUrl"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; "border": { "alias": "border"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MatomoTrackClickDirective {
    private readonly tracker;
    matomoClickCategory?: string;
    matomoClickAction?: string;
    matomoClickName?: string;
    matomoClickValue?: number;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoTrackClickDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatomoTrackClickDirective, "[matomoClickCategory][matomoClickAction]", never, { "matomoClickCategory": { "alias": "matomoClickCategory"; "required": false; }; "matomoClickAction": { "alias": "matomoClickAction"; "required": false; }; "matomoClickName": { "alias": "matomoClickName"; "required": false; }; "matomoClickValue": { "alias": "matomoClickValue"; "required": false; }; }, {}, never, never, true, never>;
}

interface TrackArgs {
    category?: string;
    action?: string;
    name?: string;
    value?: number;
}
type EventName = keyof GlobalEventHandlersEventMap | string;
type DOMEventInput = EventName | EventName[] | null | undefined;
declare class MatomoTrackerDirective implements OnDestroy {
    private readonly tracker;
    private readonly elementRef;
    private sub?;
    /** Set the event category */
    matomoCategory?: string;
    /** Set the event action */
    matomoAction?: string;
    /** Set the event name */
    matomoName?: string;
    /** Set the event value */
    matomoValue?: number;
    /** Track a Matomo event whenever specified DOM event is triggered */
    set matomoTracker(input: DOMEventInput);
    ngOnDestroy(): void;
    /** Track an event using category, action, name and value set as @Input() */
    trackEvent(): void;
    /** Track an event using category, action and name set as @Input() and provided value */
    trackEvent(value: number): void;
    /** Track an event using category and action set as @Input() and provided name and value */
    trackEvent(name: string, value?: number): void;
    /** Track an event using provided category, action, name and value (any @Input() is used as a default value) */
    trackEvent(args: TrackArgs): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoTrackerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatomoTrackerDirective, "[matomoTracker]", ["matomo"], { "matomoCategory": { "alias": "matomoCategory"; "required": false; }; "matomoAction": { "alias": "matomoAction"; "required": false; }; "matomoName": { "alias": "matomoName"; "required": false; }; "matomoValue": { "alias": "matomoValue"; "required": false; }; "matomoTracker": { "alias": "matomoTracker"; "required": false; }; }, {}, never, never, true, never>;
}

declare const MATOMO_DIRECTIVES: readonly [typeof MatomoTrackerDirective, typeof MatomoTrackClickDirective, typeof MatomoOptOutFormComponent];
declare class MatomoModule {
    static forRoot(config: MatomoConfiguration, scriptFactory?: MatomoScriptFactory): ModuleWithProviders<MatomoModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MatomoModule, never, [typeof MatomoTrackerDirective, typeof MatomoTrackClickDirective, typeof MatomoOptOutFormComponent], [typeof MatomoTrackerDirective, typeof MatomoTrackClickDirective, typeof MatomoOptOutFormComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MatomoModule>;
}
/**
 * @deprecated use MatomoModule instead
 * @breaking-change 8.0.0
 */
declare class NgxMatomoModule {
    static forRoot(config: MatomoConfiguration, scriptFactory?: MatomoScriptFactory): ModuleWithProviders<NgxMatomoModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatomoModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatomoModule, never, [typeof MatomoModule], [typeof MatomoModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatomoModule>;
}
/**
 * @deprecated use MatomoModule instead
 * @breaking-change 8.0.0
 */
declare class NgxMatomoTrackerModule {
    static forRoot(config: MatomoConfiguration, scriptFactory?: MatomoScriptFactory): ModuleWithProviders<NgxMatomoTrackerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxMatomoTrackerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxMatomoTrackerModule, never, [typeof NgxMatomoModule], [typeof NgxMatomoModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxMatomoTrackerModule>;
}

interface MatomoECommerceItem {
    productSKU: string;
    productName?: string;
    productCategory?: string;
    price?: number;
    quantity?: number;
}
type MatomoECommerceItemView = Omit<MatomoECommerceItem, 'quantity'>;
type MatomoECommerceCategoryView = Required<Pick<MatomoECommerceItem, 'productCategory'>>;
type MatomoECommerceView = MatomoECommerceItemView | MatomoECommerceCategoryView;
type PagePerformanceTimings = RequireAtLeastOne<{
    networkTimeInMs?: number;
    serverTimeInMs?: number;
    transferTimeInMs?: number;
    domProcessingTimeInMs?: number;
    domCompletionTimeInMs?: number;
    onloadTimeInMs?: number;
}>;
/** Matomo's internal tracker instance */
interface MatomoInstance {
    getMatomoUrl(): string;
    getPiwikUrl(): string;
    getCurrentUrl(): string;
    getLinkTrackingTimer(): number;
    getVisitorId(): string;
    getVisitorInfo(): unknown[];
    /**
     *
     * @return array of getAttributionCampaignName, getAttributionCampaignKeyword, getAttributionReferrerTimestamp, getAttributionReferrerUrl
     */
    getAttributionInfo(): string[];
    getAttributionCampaignName(): string;
    getAttributionCampaignKeyword(): string;
    getAttributionReferrerTimestamp(): string;
    getAttributionReferrerUrl(): string;
    getUserId(): string;
    getPageViewId(): string;
    getCustomData(): unknown;
    getCustomVariable(index: number, scope: string): string;
    getCustomDimension(customDimensionId: number): string;
    getEcommerceItems(): MatomoECommerceItem[];
    hasCookies(): boolean;
    getCrossDomainLinkingUrlParameter(): string;
    hasRememberedConsent(): boolean;
    getRememberedConsent(): number | string;
    getRememberedCookieConsent(): number | string;
    isConsentRequired(): boolean;
    areCookiesEnabled(): boolean;
    isUserOptedOut(): boolean;
    getCustomPagePerformanceTiming(): string;
    getExcludedReferrers(): string[];
    getIgnoreCampaignsForReferrers(): string[];
}
declare class MatomoTracker {
    private readonly delegate;
    private readonly _pageViewTracked;
    readonly pageViewTracked: rxjs.Observable<void>;
    constructor();
    /**
     * Logs a visit to this page.
     *
     * @param [customTitle] Optional title of the visited page.
     */
    trackPageView(customTitle?: string): void;
    /**
     * Logs an event with an event category (Videos, Music, Games…), an event action (Play, Pause, Duration,
     * Add Playlist, Downloaded, Clicked…), and an optional event name and optional numeric value.
     *
     * @param category Category of the event.
     * @param action Action of the event.
     * @param [name] Optional name of the event.
     * @param [value] Optional value for the event.
     * @param [customData] Optional custom data for the event.
     */
    trackEvent(category: string, action: string, name?: string, value?: number, customData?: unknown): void;
    /**
     * Logs an internal site search for a specific keyword, in an optional category,
     * specifying the optional count of search results in the page.
     *
     * @param keyword Keywords of the search query.
     * @param [category] Optional category of the search query.
     * @param [resultsCount] Optional number of results returned by the search query.
     * @param [customData] Optional custom data for the search query.
     */
    trackSiteSearch(keyword: string, category?: string, resultsCount?: number, customData?: unknown): void;
    /**
     * Manually logs a conversion for the numeric goal ID, with an optional numeric custom revenue customRevenue.
     *
     * @param idGoal numeric ID of the goal to log a conversion for.
     * @param [customRevenue] Optional custom revenue to log for the goal.
     * @param [customData] Optional custom data for the goal.
     */
    trackGoal(idGoal: number, customRevenue?: number, customData?: unknown): void;
    /**
     * Manually logs a click from your own code.
     *
     * @param url Full URL which is to be tracked as a click.
     * @param linkType Either 'link' for an outlink or 'download' for a download.
     * @param [customData] Optional custom data for the link.
     */
    trackLink(url: string, linkType: 'link' | 'download', customData?: unknown): void;
    /**
     * Scans the entire DOM for all content blocks and tracks all impressions once the DOM ready event has been triggered.
     *
     */
    trackAllContentImpressions(): void;
    /**
     * Scans the entire DOM for all content blocks as soon as the page is loaded.<br />
     * It tracks an impression only if a content block is actually visible.
     *
     * @param checkOnScroll If true, checks for new content blocks while scrolling the page.
     * @param timeInterval Duration, in milliseconds, between two checks upon scroll.
     */
    trackVisibleContentImpressions(checkOnScroll: boolean, timeInterval: number): void;
    /**
     * Scans the given DOM node and its children for content blocks and tracks an impression for them
     * if no impression was already tracked for it.
     *
     * @param node DOM node in which to look for content blocks which have not been previously tracked.
     */
    trackContentImpressionsWithinNode(node: Node): void;
    /**
     * Tracks an interaction with the given DOM node/content block.
     *
     * @param node DOM node for which to track a content interaction.
     * @param contentInteraction Name of the content interaction.
     */
    trackContentInteractionNode(node: Node, contentInteraction: string): void;
    /**
     * Tracks a content impression using the specified values.
     *
     * @param contentName Content name.
     * @param contentPiece Content piece.
     * @param contentTarget Content target.
     */
    trackContentImpression(contentName: string, contentPiece: string, contentTarget: string): void;
    /**
     * Tracks a content interaction using the specified values.
     *
     * @param contentInteraction Content interaction.
     * @param contentName Content name.
     * @param contentPiece Content piece.
     * @param contentTarget Content target.
     */
    trackContentInteraction(contentInteraction: string, contentName: string, contentPiece: string, contentTarget: string): void;
    /**
     * Logs all found content blocks within a page to the console. This is useful to debug / test content tracking.
     */
    logAllContentBlocksOnPage(): void;
    /**
     * Send a ping request
     * <p>
     * Ping requests do not track new actions.
     * If they are sent within the standard visit length, they will update the existing visit time.
     * If sent after the standard visit length, ping requests will be ignored.
     * See also {@link #enableHeartBeatTimer enableHeartBeatTimer()}.
     *
     * @see enableHeartBeatTimer
     */
    ping(): void;
    /**
     * Install a Heart beat timer that will regularly send requests to Matomo in order to better measure the time spent on the page.<br />
     * These requests will be sent only when the user is actively viewing the page (when the tab is active and in focus).<br />
     * These requests will not track additional actions or page views.<br />
     * By default, the delay is set to 15 seconds.
     *
     * @param delay Delay, in seconds, between two heart beats to the server.
     */
    enableHeartBeatTimer(delay: number): void;
    /**
     * Installs link tracking on all applicable link elements.
     *
     * @param usePseudoClickHandler Set to `true` to use pseudo click-handler (treat middle click and open contextmenu as
     * left click).<br />
     * A right click (or any click that opens the context menu) on a link will be tracked as clicked even if "Open in new tab"
     * is not selected.<br />
     * If "false" (default), nothing will be tracked on open context menu or middle click.
     */
    enableLinkTracking(usePseudoClickHandler?: boolean): void;
    /** Disables page performance tracking */
    disablePerformanceTracking(): void;
    /**
     * Enables cross domain linking. By default, the visitor ID that identifies a unique visitor is stored in the browser's
     * first party cookies.<br />
     * This means the cookie can only be accessed by pages on the same domain.<br />
     * If you own multiple domains and would like to track all the actions and pageviews of a specific visitor into the same visit,
     * you may enable cross domain linking.<br />
     * Whenever a user clicks on a link it will append a URL parameter pk_vid to the clicked URL which forwards the current
     * visitor ID value to the page of the different domain.
     *
     */
    enableCrossDomainLinking(): void;
    /**
     * By default, the two visits across domains will be linked together when the link is clicked and the page is loaded within
     * a 180 seconds timeout window.
     *
     * @param timeout Timeout, in seconds, between two actions across two domains before creating a new visit.
     */
    setCrossDomainLinkingTimeout(timeout: number): void;
    /**
     * Get the query parameter to append to links to handle cross domain linking.
     *
     * Use this to add cross domain support for links that are added to the DOM dynamically
     */
    getCrossDomainLinkingUrlParameter(): Promise<string>;
    /**
     * Set array of referrers where campaign parameters should be ignored
     */
    setIgnoreCampaignsForReferrers(referrers: string | string[]): void;
    /**
     * Get array of referrers where campaign parameters should be ignored
     */
    getIgnoreCampaignsForReferrers(): Promise<string[]>;
    /**
     * Overrides document.title
     *
     * @param title Title of the document.
     */
    setDocumentTitle(title: string): void;
    /**
     * Set array of hostnames or domains to be treated as local.<br />
     * For wildcard subdomains, you can use: `setDomains('.example.com')`; or `setDomains('*.example.com');`.<br />
     * You can also specify a path along a domain: `setDomains('*.example.com/subsite1');`.
     *
     * @param domains List of hostnames or domains, with or without path, to be treated as local.
     */
    setDomains(domains: string[]): void;
    /**
     * Override the page's reported URL.
     *
     * @param url URL to be reported for the page.
     */
    setCustomUrl(url: string): void;
    /**
     * Overrides the detected Http-Referer.
     *
     * @param url URL to be reported for the referer.
     */
    setReferrerUrl(url: string): void;
    /**
     * Specifies the website ID.<br />
     * Redundant: can be specified in getTracker() constructor.
     *
     * @param siteId Site ID for the tracker.
     */
    setSiteId(siteId: number | string): void;
    /**
     * Specify the Matomo HTTP API URL endpoint. Points to the root directory of matomo,
     * e.g. http://matomo.example.org/ or https://example.org/matomo/.<br />
     * This function is only useful when the 'Overlay' report is not working.<br />
     * By default, you do not need to use this function.
     *
     * @param url URL for Matomo HTTP API endpoint.
     */
    setApiUrl(url: string): void;
    /**
     * Specifies the Matomo server URL.<br />
     * Redundant: can be specified in getTracker() constructor.
     *
     * @param url URL for the Matomo server.
     */
    setTrackerUrl(url: string): void;
    /**
     * Register an additional Matomo server<br />
     * Redundant: can be specified in getTracker() constructor.
     *
     * @param url URL for the Matomo server.
     * @param siteId Site ID for the tracker
     */
    addTracker(url: string, siteId: number | string): void;
    /**
     * Returns the Matomo server URL.
     *
     * @returns Promise for the Matomo server URL.
     */
    getMatomoUrl(): Promise<string>;
    /** @deprecated use `getMatomoUrl` instead */
    getPiwikUrl(): Promise<string>;
    /**
     * Returns the current url of the page that is currently being visited.<br />
     * If a custom URL was set before calling this method, the custom URL will be returned.
     *
     * @returns Promise for the URL of the current page.
     */
    getCurrentUrl(): Promise<string>;
    /**
     * Set classes to be treated as downloads (in addition to piwik_download).
     *
     * @param classes Class, or list of classes to be treated as downloads.
     */
    setDownloadClasses(classes: string | string[]): void;
    /**
     * Set list of file extensions to be recognized as downloads.<br />
     * Example: `'docx'` or `['docx', 'xlsx']`.
     *
     * @param extensions Extension, or list of extensions to be recognized as downloads.
     */
    setDownloadExtensions(extensions: string | string[]): void;
    /**
     * Set additional file extensions to be recognized as downloads.<br />
     * Example: `'docx'` or `['docx', 'xlsx']`.
     *
     * @param extensions Extension, or list of extensions to be recognized as downloads.
     */
    addDownloadExtensions(extensions: string | string[]): void;
    /**
     * Set file extensions to be removed from the list of download file extensions.<br />
     * Example: `'docx'` or `['docx', 'xlsx']`.
     *
     * @param extensions Extension, or list of extensions not to be recognized as downloads.
     */
    removeDownloadExtensions(extensions: string | string[]): void;
    /**
     * Set classes to be ignored if present in link (in addition to piwik_ignore).
     *
     * @param classes Class, or list of classes to be ignored if present in link.
     */
    setIgnoreClasses(classes: string | string[]): void;
    /**
     * Set classes to be treated as outlinks (in addition to piwik_link).
     *
     * @param classes Class, or list of classes to be treated as outlinks.
     */
    setLinkClasses(classes: string | string[]): void;
    /**
     * Set delay for link tracking (in milliseconds).
     *
     * @param delay Delay, in milliseconds, for link tracking.
     */
    setLinkTrackingTimer(delay: number): void;
    /**
     * Returns delay for link tracking.
     *
     * @returns Promise for the delay in milliseconds.
     */
    getLinkTrackingTimer(): Promise<number>;
    /**
     * Set to true to not record the hash tag (anchor) portion of URLs.
     *
     * @param value If true, the hash tag portion of the URLs won't be recorded.
     */
    discardHashTag(value: boolean): void;
    /**
     * By default, Matomo uses the browser DOM Timing API to accurately determine the time it takes to generate and download
     * the page. You may overwrite this value with this function.
     *
     * <b>This feature has been deprecated since Matomo 4. Any call will be ignored with Matomo 4. Use {@link setPagePerformanceTiming setPagePerformanceTiming()} instead.</b>
     *
     * @param generationTime Time, in milliseconds, of the page generation.
     */
    setGenerationTimeMs(generationTime: number): void;
    /**
     * Manually set performance metrics in milliseconds in a Single Page App or when Matomo cannot detect some metrics.
     *
     * You can set parameters to undefined if you do not want to track this metric. At least one parameter needs to be set.
     * The set performance timings will be tracked only on the next page view. If you track another page view then you will need to set the performance timings again.
     *
     * <b>Requires Matomo 4.5 or newer.</b>
     *
     */
    setPagePerformanceTiming(timings: PagePerformanceTimings): void;
    /**
     * Manually set performance metrics in milliseconds in a Single Page App or when Matomo cannot detect some metrics.
     *
     * You can set parameters to undefined if you do not want to track this metric. At least one parameter needs to be set.
     * The set performance timings will be tracked only on the next page view. If you track another page view then you will need to set the performance timings again.
     *
     * <b>Requires Matomo 4.5 or newer.</b>
     *
     */
    setPagePerformanceTiming(networkTimeInMs: number | undefined, serverTimeInMs?: number, transferTimeInMs?: number, domProcessingTimeInMs?: number, domCompletionTimeInMs?: number, onloadTimeInMs?: number): void;
    getCustomPagePerformanceTiming(): Promise<string>;
    /**
     * Appends a custom string to the end of the HTTP request to matomo.php.
     *
     * @param appendToUrl String to append to the end of the HTTP request to matomo.php.
     */
    appendToTrackingUrl(appendToUrl: string): void;
    /** Set to `true` to not track users who opt out of tracking using <i>Do Not Track</i> setting */
    setDoNotTrack(doNotTrack: boolean): void;
    /**
     * Enables a frame-buster to prevent the tracked web page from being framed/iframed.
     */
    killFrame(): void;
    /**
     * Forces the browser to load the live URL if the tracked web page is loaded from a local file
     * (e.g., saved to someone's desktop).
     *
     * @param url URL to track instead of file:// URLs.
     */
    redirectFile(url: string): void;
    /**
     * Records how long the page has been viewed if the minimumVisitLength is attained;
     * the heartBeatDelay determines how frequently to update the server.
     *
     * @param minimumVisitLength Duration before notifying the server for the duration of the visit to a page.
     * @param heartBeatDelay Delay, in seconds, between two updates to the server.
     */
    setHeartBeatTimer(minimumVisitLength: number, heartBeatDelay: number): void;
    /**
     * Returns the 16 characters ID for the visitor.
     *
     * @returns Promise for the the 16 characters ID for the visitor.
     */
    getVisitorId(): Promise<string>;
    /**
     * Set the 16 characters ID for the visitor
     * <p/>
     * The visitorId needs to be a 16 digit hex string.
     * It won't be persisted in a cookie and needs to be set on every new page load.
     *
     * @param visitorId a 16 digit hex string
     */
    setVisitorId(visitorId: string): void;
    /**
     * Returns the visitor cookie contents in an array.
     *
     * @returns Promise for the cookie contents in an array.
     *
     * TODO better return type
     */
    getVisitorInfo(): Promise<unknown[]>;
    /**
     * Returns the visitor attribution array (Referer information and/or Campaign name & keyword).<br />
     * Attribution information is used by Matomo to credit the correct referrer (first or last referrer)
     * used when a user triggers a goal conversion.
     *
     * @returns Promise for the visitor attribution array (Referer information and/or Campaign name & keyword).
     */
    getAttributionInfo(): Promise<string[]>;
    /**
     * Returns the attribution campaign name.
     *
     * @returns Promise for the the attribution campaign name.
     */
    getAttributionCampaignName(): Promise<string>;
    /**
     * Returns the attribution campaign keyword.
     *
     * @returns Promise for the attribution campaign keyword.
     */
    getAttributionCampaignKeyword(): Promise<string>;
    /**
     * Returns the attribution referrer timestamp.
     *
     * @returns Promise for the attribution referrer timestamp (as string).
     */
    getAttributionReferrerTimestamp(): Promise<string>;
    /**
     * Returns the attribution referrer URL.
     *
     * @returns Promise for the attribution referrer URL
     */
    getAttributionReferrerUrl(): Promise<string>;
    /**
     * Returns the User ID string if it was set.
     *
     * @returns Promise for the User ID for the visitor.
     */
    getUserId(): Promise<string>;
    /**
     * Set a User ID to this user (such as an email address or a username).
     *
     * @param userId User ID to set for the current visitor.
     */
    setUserId(userId: string): void;
    /**
     * Reset the User ID which also generates a new Visitor ID.
     *
     */
    resetUserId(): void;
    /**
     * Override PageView id for every use of logPageView() <b>THIS SHOULD PROBABLY NOT BE CALLED IN A SINGLE-PAGE APP!</b>
     *
     * Do not use this if you call trackPageView() multiple times during tracking (e.g. when tracking a single page application)
     *
     * @param pageView
     */
    setPageViewId(pageView: string): void;
    /**
     * Returns the PageView id. If not set manually using setPageViewId, this method will return the dynamic PageView id, used in the last tracked page view, or undefined if no page view was tracked yet
     */
    getPageViewId(): Promise<string>;
    /**
     * Set custom data for the next request
     *
     * @param key
     * @param value
     */
    setCustomData(key: PropertyKey, value: unknown): void;
    /**
     * Overwrite custom data for the next request
     *
     * @param data
     */
    setCustomData(data: unknown): void;
    /**
     * Retrieves custom data.
     *
     * @returns Promise for the value of custom data.
     */
    getCustomData(): Promise<unknown>;
    /**
     * Set a custom variable.
     *
     * @param index Index, the number from 1 to 5 where this custom variable name is stored for the current page view.
     * @param name Name, the name of the variable, for example: Category, Sub-category, UserType.
     * @param value Value, for example: "Sports", "News", "World", "Business"…
     * @param scope Scope of the custom variable:<br />
     * - "page" means the custom variable applies to the current page view.
     * - "visit" means the custom variable applies to the current visitor.
     */
    setCustomVariable(index: number, name: string, value: string, scope: 'page' | 'visit' | 'event'): void;
    /**
     * Deletes a custom variable.
     *
     * @param index Index of the custom variable to delete.
     * @param scope Scope of the custom variable to delete.
     */
    deleteCustomVariable(index: number, scope: 'page' | 'visit' | 'event'): void;
    /**
     * Deletes all custom variables.
     *
     * @param scope Scope of the custom variables to delete.
     */
    deleteCustomVariables(scope: 'page' | 'visit' | 'event'): void;
    /**
     * Retrieves a custom variable.
     *
     * @param index Index of the custom variable to retrieve.
     * @param scope Scope of the custom variable to retrieve.
     * @returns Promise for the value of custom variable.
     */
    getCustomVariable(index: number, scope: 'page' | 'visit' | 'event'): Promise<string>;
    /**
     * When called then the Custom Variables of scope "visit" will be stored (persisted) in a first party cookie
     * for the duration of the visit.<br />
     * This is useful if you want to call getCustomVariable later in the visit.<br />
     * (by default custom variables are not stored on the visitor's computer.)
     *
     */
    storeCustomVariablesInCookie(): void;
    /**
     * Set a custom dimension.<br />
     * (requires Matomo 2.15.1 + Custom Dimensions plugin)
     *
     * @param customDimensionId ID of the custom dimension to set.
     * @param customDimensionValue Value to be set.
     */
    setCustomDimension(customDimensionId: number, customDimensionValue: string): void;
    /**
     * Deletes a custom dimension.<br />
     * (requires Matomo 2.15.1 + Custom Dimensions plugin)
     *
     * @param customDimensionId ID of the custom dimension to delete.
     */
    deleteCustomDimension(customDimensionId: number): void;
    /**
     * Retrieve a custom dimension.<br />
     * (requires Matomo 2.15.1 + Custom Dimensions plugin)
     *
     * @param customDimensionId ID of the custom dimension to retrieve.
     * @return Promise for the value for the requested custom dimension.
     */
    getCustomDimension(customDimensionId: number): Promise<string>;
    /**
     * Set campaign name parameter(s).
     *
     * @param name Name of the campaign
     */
    setCampaignNameKey(name: string): void;
    /**
     * Set campaign keyword parameter(s).
     *
     * @param keyword Keyword parameter(s) of the campaign.
     */
    setCampaignKeywordKey(keyword: string): void;
    /**
     * Set to true to attribute a conversion to the first referrer.<br />
     * By default, conversion is attributed to the most recent referrer.
     *
     * @param conversionToFirstReferrer If true, Matomo will attribute the Goal conversion to the first referrer used
     * instead of the last one.
     */
    setConversionAttributionFirstReferrer(conversionToFirstReferrer: boolean): void;
    /**
     * Set the current page view as a product page view.<br />
     * When you call setEcommerceView, it must be followed by a call to trackPageView to record the product or category page view.
     *
     * @param productSKU SKU of the viewed product.
     * @param productName Name of the viewed product.
     * @param productCategory Category of the viewed product.
     * @param price Price of the viewed product.
     */
    setEcommerceView(productSKU: string, productName?: string, productCategory?: string, price?: number): void;
    /**
     * Set the current page view as a product page view.<br />
     * When you call setEcommerceView, it must be followed by a call to trackPageView to record the product or category page view.
     *
     */
    setEcommerceView(product: MatomoECommerceItemView): void;
    /**
     * Set the current page view as a category page view.<br />
     * When you call setEcommerceView, it must be followed by a call to trackPageView to record the product or category page view.
     *
     */
    setEcommerceView(product: MatomoECommerceCategoryView): void;
    /**
     * Set the current page view as a product or category page view.<br />
     * When you call setEcommerceView, it must be followed by a call to trackPageView to record the product or category page view.
     *
     */
    setEcommerceView(product: MatomoECommerceView): void;
    /**
     * Adds a product into the eCommerce order.<br />
     * Must be called for each product in the order.
     *
     * @param productSKU SKU of the product to add.
     * @param [productName] Optional name of the product to add.
     * @param [productCategory] Optional category of the product to add.
     * @param [price] Optional price of the product to add.
     * @param [quantity] Optional quantity of the product to add.
     */
    addEcommerceItem(productSKU: string, productName?: string, productCategory?: string, price?: number, quantity?: number): void;
    /**
     * Adds a product into the eCommerce order.<br />
     * Must be called for each product in the order.
     *
     */
    addEcommerceItem(product: MatomoECommerceItem): void;
    /**
     * Remove the specified product from the untracked ecommerce order
     *
     * @param productSKU SKU of the product to remove.
     */
    removeEcommerceItem(productSKU: string): void;
    /**
     * Remove all products in the untracked ecommerce order
     *
     * Note: This is done automatically after {@link #trackEcommerceOrder trackEcommerceOrder()} is called
     */
    clearEcommerceCart(): void;
    /**
     * Return all ecommerce items currently in the untracked ecommerce order
     * <p/>
     * The returned array will be a copy, so changing it won't affect the ecommerce order.
     * To affect what gets tracked, use the {@link #addEcommerceItem addEcommerceItem()}, {@link #removeEcommerceItem removeEcommerceItem()},
     * {@link #clearEcommerceCart clearEcommerceCart()} methods.
     * Use this method to see what will be tracked before you track an order or cart update.
     */
    getEcommerceItems(): Promise<MatomoECommerceItem[]>;
    /**
     * Tracks a shopping cart.<br />
     * Call this function every time a user is adding, updating or deleting a product from the cart.
     *
     * @param grandTotal Grand total of the shopping cart.
     */
    trackEcommerceCartUpdate(grandTotal: number): void;
    /**
     * Tracks an Ecommerce order, including any eCommerce item previously added to the order.<br />
     * orderId and grandTotal (ie.revenue) are required parameters.
     *
     * @param orderId ID of the tracked order.
     * @param grandTotal Grand total of the tracked order.
     * @param [subTotal] Sub total of the tracked order.
     * @param [tax] Taxes for the tracked order.
     * @param [shipping] Shipping fees for the tracked order.
     * @param [discount] Discount granted for the tracked order.
     */
    trackEcommerceOrder(orderId: string, grandTotal: number, subTotal?: number, tax?: number, shipping?: number, discount?: number): void;
    /**
     * Require nothing is tracked until a user consents
     *
     * By default the Matomo tracker assumes consent to tracking.
     *
     * @see `requireConsent` module configuration property
     */
    requireConsent(): void;
    /**
     * Mark that the current user has consented
     *
     * The consent is one-time only, so in a subsequent browser session, the user will have to consent again.
     * To remember consent, see {@link rememberConsentGiven}.
     */
    setConsentGiven(): void;
    /**
     * Mark that the current user has consented, and remembers this consent through a browser cookie.
     *
     * The next time the user visits the site, Matomo will remember that they consented, and track them.
     * If you call this method, you do not need to call {@link setConsentGiven}.
     *
     * @param hoursToExpire After how many hours the consent should expire. By default the consent is valid
     *                          for 30 years unless cookies are deleted by the user or the browser prior to this
     */
    rememberConsentGiven(hoursToExpire?: number): void;
    /**
     * Remove a user's consent, both if the consent was one-time only and if the consent was remembered.
     *
     * After calling this method, the user will have to consent again in order to be tracked.
     */
    forgetConsentGiven(): void;
    /** Return whether the current visitor has given consent previously or not */
    hasRememberedConsent(): Promise<boolean>;
    /**
     * If consent was given, returns the timestamp when the visitor gave consent
     *
     * Only works if {@link rememberConsentGiven} was used and not when {@link setConsentGiven} was used.
     * The timestamp is the local timestamp which depends on the visitors time.
     */
    getRememberedConsent(): Promise<string | number>;
    /** Return whether {@link requireConsent} was called previously */
    isConsentRequired(): Promise<boolean>;
    /**
     * Require no cookies are used
     *
     * By default the Matomo tracker assumes consent to using cookies
     */
    requireCookieConsent(): void;
    /**
     * Mark that the current user has consented to using cookies
     *
     * The consent is one-time only, so in a subsequent browser session, the user will have to consent again.
     * To remember cookie consent, see {@link rememberCookieConsentGiven}.
     */
    setCookieConsentGiven(): void;
    /**
     * Mark that the current user has consented to using cookies, and remembers this consent through a browser cookie.
     *
     * The next time the user visits the site, Matomo will remember that they consented, and use cookies.
     * If you call this method, you do not need to call {@link setCookieConsentGiven}.
     *
     * @param hoursToExpire After how many hours the cookie consent should expire. By default the consent is valid
     *                          for 30 years unless cookies are deleted by the user or the browser prior to this
     */
    rememberCookieConsentGiven(hoursToExpire?: number): void;
    /**
     * Remove a user's cookie consent, both if the consent was one-time only and if the consent was remembered.
     *
     * After calling this method, the user will have to consent again in order for cookies to be used.
     */
    forgetCookieConsentGiven(): void;
    getRememberedCookieConsent(): Promise<number | string>;
    /** Return whether cookies are currently enabled or disabled */
    areCookiesEnabled(): Promise<boolean>;
    /** After calling this function, the user will be opted out and no longer be tracked */
    optUserOut(): void;
    /** After calling this method the user will be tracked again */
    forgetUserOptOut(): void;
    /**
     * Return whether the user is opted out or not
     *
     * Note: This method might not return the correct value if you are using the opt out iframe.
     */
    isUserOptedOut(): Promise<boolean>;
    /**
     * Disables all first party cookies.<br />
     * Existing Matomo cookies for this websites will be deleted on the next page view.
     */
    disableCookies(): void;
    /**
     * Deletes the tracking cookies currently set (useful when creating new visits).
     */
    deleteCookies(): void;
    /**
     * Returns whether cookies are enabled and supported by this browser.
     *
     * @returns Promise for the support and activation of cookies.
     */
    hasCookies(): Promise<boolean>;
    /**
     * Set the tracking cookie name prefix.<br />
     * Default prefix is 'pk'.
     *
     * @param prefix Prefix for the tracking cookie names.
     */
    setCookieNamePrefix(prefix: string): void;
    /**
     * Set the domain of the tracking cookies.<br />
     * Default is the document domain.<br />
     * If your website can be visited at both www.example.com and example.com, you would use: `'.example.com'` or `'*.example.com'`.
     *
     * @param domain Domain of the tracking cookies.
     */
    setCookieDomain(domain: string): void;
    /**
     * Set the path of the tracking cookies.<br />
     * Default is '/'.
     *
     * @param path Path of the tracking cookies.
     */
    setCookiePath(path: string): void;
    /**
     * Set to true to enable the Secure cookie flag on all first party cookies.<br />
     * This should be used when your website is only available under HTTPS so that all tracking cookies are always sent
     * over secure connection.
     *
     * @param secure If true, the secure cookie flag will be set on all first party cookies.
     */
    setSecureCookie(secure: boolean): void;
    /**
     * Set cookie <i>same site</i>
     * <p/>
     * Defaults to Lax.
     * Can be set to None or Strict.
     * None requires all traffic to be on HTTPS and will also automatically set the secure cookie.
     * It can be useful for example if the tracked website is an iframe.
     * Strict only works if your Matomo and the website runs on the very same domain.
     */
    setCookieSameSite(sameSite: 'Strict' | 'Lax' | 'None'): void;
    /**
     * Set the visitor cookie timeout.<br />
     * Default is 13 months.
     *
     * @param timeout Timeout, in seconds, for the visitor cookie timeout.
     */
    setVisitorCookieTimeout(timeout: number): void;
    /**
     * Set the referral cookie timeout.<br />
     * Default is 6 months.
     *
     * @param timeout Timeout, in seconds, for the referral cookie timeout.
     */
    setReferralCookieTimeout(timeout: number): void;
    /**
     * Set the session cookie timeout.<br />
     * Default is 30 minutes.
     *
     * @param timeout Timeout, in seconds, for the session cookie timeout.
     */
    setSessionCookieTimeout(timeout: number): void;
    /**
     * Allows adjusting the length limit used for storing the referrer url in tracking cookie. Defaults to 1024 chars.
     *
     * @param length
     */
    setReferrerUrlMaxLength(length: number): void;
    /**
     * Adds a click listener to a specific link element.<br />
     * When clicked, Matomo will log the click automatically.
     *
     * @param element Element on which to add a click listener.
     */
    addListener(element: Element): void;
    /**
     * Set the request method to either "GET" or "POST". (The default is "GET".)<br />
     * To use the POST request method, either:<br />
     * 1) the Matomo host is the same as the tracked website host (Matomo installed in the same domain as your tracked website), or<br />
     * 2) if Matomo is not installed on the same host as your website, you need to enable CORS (Cross domain requests).
     *
     * @param method HTTP method for sending information to the Matomo server.
     */
    setRequestMethod(method: string): void;
    /**
     * Set a function that will process the request content.<br />
     * The function will be called once the request (query parameters string) has been prepared, and before the request content is sent.
     *
     * @param callback Function that will process the request content.
     */
    setCustomRequestProcessing(callback: (queryParameters: string) => void): void;
    /**
     * Set request Content-Type header value.<br />
     * Applicable when "POST" request method is used via setRequestMethod.
     *
     * @param contentType Value for Content-Type HTTP header.
     */
    setRequestContentType(contentType: string): void;
    /**
     * Disable the feature which groups together multiple tracking requests and send them as a bulk POST request.
     * <p/>
     * Disabling this feature is useful when you want to be able to replay all logs:
     * one must use disableQueueRequest to disable this behaviour to later be able to replay logged
     * Matomo logs (otherwise a subset of the requests wouldn't be able to be replayed).
     */
    disableQueueRequest(): void;
    /**
     * Defines after how many ms a queued requests will be executed after the request was queued initially
     * <p/>
     * The higher the value the more tracking requests can be sent together at once
     *
     * @param interval Interval in milliseconds, must be at least 1000, defaults to 2500
     */
    setRequestQueueInterval(interval: number): void;
    /** Disable sending tracking requests using `navigator.sendBeacon` which is enabled by default */
    disableAlwaysUseSendBeacon(): void;
    /** Enable sending tracking requests using `navigator.sendBeacon` (enabled by default) */
    alwaysUseSendBeacon(): void;
    /**
     * Enable Javascript errors tracking. JS errors are then tracked as events with category
     * "JavaScript Errors". Refer to official doc for more details.
     *
     * @see https://matomo.org/faq/how-to/how-do-i-enable-basic-javascript-error-tracking-and-reporting-in-matomo-browser-console-error-messages/
     */
    enableJSErrorTracking(): void;
    /**
     * Enable tracking of file:// protocol actions. By default, the file:// protocol is not tracked.
     */
    enableFileTracking(): void;
    /**
     * Set array of hostnames or domains that should be ignored as referrers.
     *
     * For wildcard subdomains, you can use: `setExcludedReferrers('.example.com');` or `setExcludedReferrers('*.example.com');`.
     * You can also specify a path along a domain: `setExcludedReferrers('*.example.com/subsite1');`.
     *
     * This method is available as of Matomo 4.12.
     */
    setExcludedReferrers(...excludedReferrers: NonEmptyReadonlyArray<string | string[]>): void;
    /**
     * Returns the list of excluded referrers, which was previously set using setExcludedReferrers
     */
    getExcludedReferrers(): Promise<string[]>;
    /**
     * By default, Matomo accesses information from the visitor's browser to detect the current browser resolution
     * and what browser plugins (for example PDF and cookies) are supported.
     *
     * This information is used to show you reports on your visitor's browser resolution, supported browser plugins,
     * and it is also used to generate a short-lived identifier for every visitor which we call the config_id.
     * Some privacy regulations may only allow accessing information from a visitor's device after having consent.
     * If this applies to you, call this method to no longer access this information.
     *
     * @see https://matomo.org/faq/how-do-i-disable-browser-feature-detection-completely/
     */
    disableBrowserFeatureDetection(): void;
    /** Enable the browser feature detection if you previously disabled it */
    enableBrowserFeatureDetection(): void;
    /**
     * By default, Matomo will send campaign parameters (mtm, utm, etc.) to the tracker and record that information.
     * Some privacy regulations may not allow for this information to be collected.
     * If this applies to you, call this method to prevent campaign parameters from being sent to the tracker.
     *
     * <b>This method is available as of Matomo 5.1.</b>
     */
    disableCampaignParameters(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoTracker, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MatomoTracker>;
}

declare class MatomoInitializerService {
    private readonly config;
    private readonly deferredConfig;
    private readonly tracker;
    private readonly scriptInjector;
    constructor();
    /** @deprecated Will be removed in v7+. Use {@link initialize initialize()} instead. */
    init(): void;
    readonly initialize: () => void;
    initializeTracker(config: AutoMatomoConfiguration<'deferred'>): void;
    private readonly injectMatomoScript;
    private registerMainTracker;
    private registerAdditionalTrackers;
    private runPreInitTasks;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatomoInitializerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MatomoInitializerService>;
}

/**
 * @deprecated for internal use only
 * @breaking-change 6.0.0
 */
declare const INTERNAL_MATOMO_CONFIGURATION: i0.InjectionToken<ngx_matomo_client_core.InternalMatomoConfiguration>;

export { INTERNAL_MATOMO_CONFIGURATION, MATOMO_CONFIGURATION, MATOMO_DIRECTIVES, MATOMO_SCRIPT_FACTORY, MatomoConsentMode, MatomoInitializationMode, MatomoInitializerService, MatomoModule, MatomoOptOutFormComponent, MatomoTrackClickDirective, MatomoTracker, MatomoTrackerDirective, NgxMatomoModule, NgxMatomoTrackerModule, createDefaultMatomoScriptElement, provideMatomo, withScriptFactory, ASYNC_INTERNAL_MATOMO_CONFIGURATION as ɵASYNC_INTERNAL_MATOMO_CONFIGURATION, DEFERRED_INTERNAL_MATOMO_CONFIGURATION as ɵDEFERRED_INTERNAL_MATOMO_CONFIGURATION, INTERNAL_MATOMO_CONFIGURATION$1 as ɵINTERNAL_MATOMO_CONFIGURATION, InternalMatomoTracker as ɵInternalMatomoTracker, MATOMO_ROUTER_ENABLED as ɵMATOMO_ROUTER_ENABLED, MatomoTestingTracker as ɵMatomoTestingTracker, ScriptInjector as ɵScriptInjector, appendTrailingSlash as ɵappendTrailingSlash, createMatomoFeature as ɵcreateMatomoFeature, getTrackersConfiguration as ɵgetTrackersConfiguration, isAutoConfigurationMode as ɵisAutoConfigurationMode, isExplicitTrackerConfiguration as ɵisExplicitTrackerConfiguration, provideTestingTracker as ɵprovideTestingTracker, runOnce as ɵrunOnce };
export type { AutoMatomoConfiguration, InternalMatomoConfiguration, MatomoConfiguration, MatomoConsentRequirement, MatomoECommerceCategoryView, MatomoECommerceItem, MatomoECommerceItemView, MatomoECommerceView, MatomoFeature, MatomoFeatureKind, MatomoInitializationBehavior, MatomoInstance, MatomoScriptFactory, PagePerformanceTimings, Getters as ɵGetters, Methods as ɵMethods };