export class AggregateBase extends FeatureBase {
    /**
     * Create an AggregateBase instance.
     * @param {Object} agentRef The reference to the agent instance.
     * @param {string} featureName The name of the feature creating the instance.
     */
    constructor(agentRef: Object, featureName: string);
    /** @type {Boolean} indicates if custom attributes are combined in each event payload for size estimation purposes. this is set to true in derived classes that need to evaluate custom attributes separately from the event payload */
    customAttributesAreSeparate: boolean;
    /** @type {Boolean} indicates if the feature can harvest early. This is set to false in derived classes that need to block early harvests, like ajax under certain conditions */
    canHarvestEarly: boolean;
    /** @type {Boolean} indicates if the feature is actively in a retry deferral period */
    isRetrying: boolean;
    harvestOpts: {};
    events: any;
    /** @type {Boolean} indicates if the feature supports registered entities and the harvest requirements therein. Also read by getter "harvestEndpointVersion". Controlled by feature flag in pre-release phase. */
    get supportsRegisteredEntities(): boolean;
    /**
     * the endpoint version the feature uses during harvests
     * @type {number}
     * @returns {boolean}
     */
    get harvestEndpointVersion(): number;
    waitForDrain(): void;
    drained: boolean | undefined;
    /**
     * Evaluates whether a harvest should be made early by estimating the size of the current payload.  Currently, this only happens if the event storage is EventBuffer, since that triggers this method directly.
     * If conditions are met, a new harvest will be triggered immediately.
     * @returns void
     */
    decideEarlyHarvest(): void;
    /**
     * New handler for waiting for multiple flags. Useful when expecting multiple flags simultaneously (ex. stn vs sr)
     * @param {string[]} flagNames
     * @returns {Promise}
     */
    waitForFlags(flagNames?: string[]): Promise<any>;
    /**
     * Stages the feature to be drained
     */
    drain(): void;
    preHarvestChecks(opts: any): boolean;
    /**
     * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
     * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic
     * @param {object|undefined} opts - opts passed from the harvester to help form the payload
     * @param {string} opts.target - the target app metadata
     * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
     */
    makeHarvestPayload(shouldRetryOnFail?: boolean, opts?: object | undefined): any[];
    /**
     * Cleanup task after a harvest.
     * @param {object} result - the cbResult object from the harvester's send method
     * @param {boolean=} result.sent - whether the harvest was sent successfully
     * @param {boolean=} result.retry - whether the harvest should be retried
     */
    postHarvestCleanup(result?: {
        sent?: boolean | undefined;
        retry?: boolean | undefined;
    }): void;
    /**
     * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
     * loader configurations may appear after the loader code is executed.
     */
    checkConfiguration(existingAgent: any): void;
    /**
     * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
     * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
     */
    doOnceForAllAggregate(agentRef: any): void;
    obfuscator: any;
    /**
     * Report a supportability metric
     * @param {*} metricName The tag of the name matching the Angler aggregation tag
     * @param {*} [value] An optional value to supply. If not supplied, the metric count will be incremented by 1 for every call.
     */
    reportSupportabilityMetric(metricName: any, value?: any): void;
    #private;
}
import { FeatureBase } from './feature-base';
//# sourceMappingURL=aggregate-base.d.ts.map