import { ApiManagerInterface } from '../../api';
import { BucketingManagerInterface } from '../../bucketing';
import { DataStoreManagerInterface } from './interfaces/data-store-manager';
import { DataManagerInterface } from './interfaces/data-manager';
import { EventManagerInterface } from '../../event';
import { LogManagerInterface } from '../../logger';
import { RuleManagerInterface } from '../../rules';
import { Entity, Config, ConfigResponseData, ConfigExperience, IdentityField, BucketedVariation, StoreData, GoalData, VisitorSegments, BucketingAttributes, LocationAttributes } from '../../types';
import { BucketingError, RuleError, ConversionSettingKey } from '../../enums';
/**
 * Provides logic for data. Stores bucket with help of dataStore if it's provided
 * @category Modules
 * @constructor
 * @implements {DataManagerInterface}
 */
export declare class DataManager implements DataManagerInterface {
    private _data;
    private _accountId;
    private _projectId;
    private _config;
    private _bucketingManager;
    private _loggerManager;
    private _eventManager;
    private _dataStoreManager;
    private _apiManager;
    private _ruleManager;
    private _dataEntities;
    private _localStoreLimit;
    private _bucketedVisitors;
    private _asyncStorage;
    private _environment;
    private _mapper;
    /**
     * @param {Config} config
     * @param {Object} dependencies
     * @param {ApiManagerInterface} dependencies.apiManager
     * @param {BucketingManagerInterface} dependencies.bucketingManager
     * @param {RuleManagerInterface} dependencies.ruleManager
     * @param {LogManagerInterface} dependencies.loggerManager
     */
    constructor(config: Config, { bucketingManager, ruleManager, eventManager, apiManager, loggerManager }: {
        bucketingManager: BucketingManagerInterface;
        ruleManager: RuleManagerInterface;
        eventManager: EventManagerInterface;
        apiManager: ApiManagerInterface;
        loggerManager?: LogManagerInterface;
    }, { asyncStorage }?: {
        asyncStorage?: boolean;
    });
    set data(data: ConfigResponseData);
    /**
     * data getter
     */
    get data(): ConfigResponseData;
    /**
     * dataStoreManager setter
     * @param {any=} dataStore
     */
    set dataStoreManager(dataStore: any);
    /**
     * dataStoreManager getter
     */
    get dataStoreManager(): DataStoreManagerInterface;
    /**
     * Set dataStoreManager at run-time
     */
    setDataStore(dataStore: any): void;
    /**
     * Validate locationProperties against locations rules and visitorProperties against audiences rules
     * @param {string} visitorId
     * @param {string} identity Value of the field which name is provided in identityField
     * @param {IdentityField=} identityField Defaults to 'key'
     * @param {BucketingAttributes} attributes
     * @param {Record<any, any>} attributes.locationProperties
     * @param {Record<any, any>} attributes.visitorProperties
     * @param {string=} attributes.environment
     * @return {ConfigExperience | RuleError}
     */
    matchRulesByField(visitorId: string, identity: string, identityField: IdentityField, attributes: BucketingAttributes): ConfigExperience | RuleError;
    /**
     * Retrieve variation for visitor
     * @param {string} visitorId
     * @param {string} identity Value of the field which name is provided in identityField
     * @param {IdentityField=} identityField Defaults to 'key'
     * @param {BucketingAttributes} attributes
     * @param {Record<any, any>} attributes.locationProperties
     * @param {Record<any, any>} attributes.visitorProperties
     * @param {boolean=} attributes.updateVisitorProperties
     * @param {string=} attributes.forceVariationId
     * @param {boolean=} attributes.enableTracking Defaults to `true`
     * @param {boolean=} attributes.asyncStorage Defaults to `true`
     * @param {string=} attributes.environment
     * @return {BucketedVariation | RuleError | BucketingError}
     * @private
     */
    private _getBucketingByField;
    /**
     * Retrieve bucketing for Visitor
     * @param {string} visitorId
     * @param {Record<string, any> | null} visitorProperties
     * @param {boolean} updateVisitorProperties
     * @param {ConfigExperience} experience
     * @param {string=} forceVariationId
     * @param {boolean=} enableTracking Defaults to `true`
     * @return {BucketedVariation | BucketingError}
     * @private
     */
    private _retrieveBucketing;
    /**
     * @param {string} experienceId
     * @param {string} variationId
     * @return {ExperienceVariationConfig}
     * @private
     */
    private retrieveVariation;
    reset(): void;
    /**
     * @param {string} visitorId
     * @param {StoreData} newData
     * @private
     */
    putData(visitorId: string, newData?: StoreData): void;
    /**
     * @param {string} visitorId
     * @return {StoreData} variation id
     * @private
     */
    getData(visitorId: string): StoreData;
    /**
     * @param {string} visitorId
     * @return {string} storeKey
     * @private
     */
    getStoreKey(visitorId: string): string;
    /**
     *
     * @param {string} visitorId
     * @param {Array<Record<string, any>>} items
     * @param {Record<string, any>} attributes.locationProperties
     * @param {IdentityField=} attributes.identityField
     * @param {boolean=} attributes.forceEvent
     * @returns {Array<Record<string, any> | RuleError>}
     */
    selectLocations(visitorId: string, items: Array<Record<string, any>>, attributes: LocationAttributes): Array<Record<string, any> | RuleError>;
    /**
     * Retrieve variation for visitor
     * @param {string} visitorId
     * @param {string} key
     * @param {BucketingAttributes} attributes
     * @param {Record<any, any>} attributes.locationProperties
     * @param {Record<any, any>} attributes.visitorProperties
     * @param {boolean=} attributes.updateVisitorProperties
     * @param {boolean=} attributes.enableTracking
     * @param {string=} attributes.environment
     * @return {BucketedVariation | RuleError}
     */
    getBucketing(visitorId: string, key: string, attributes: BucketingAttributes): BucketedVariation | RuleError | BucketingError;
    /**
     * Retrieve variation for Visitor
     * @param {string} visitorId
     * @param {string} id
     * @param {BucketingAttributes} attributes
     * @param {Record<any, any>} attributes.locationProperties
     * @param {Record<any, any>} attributes.visitorProperties
     * @param {boolean=} attributes.updateVisitorProperties
     * @param {boolean=} attributes.enableTracking
     * @param {string=} attributes.environment
     * @return {BucketedVariation | RuleError}
     */
    getBucketingById(visitorId: string, id: string, attributes: BucketingAttributes): BucketedVariation | RuleError | BucketingError;
    /**
     * Process conversion event
     * @param {string} visitorId
     * @param {string} goalId
     * @param {Record<string, any>=} goalRule An object of key-value pairs that are used for goal matching
     * @param {Array<GoalData>} goalData An array of object of key-value pairs
     * @param {VisitorSegments} segments
     * @param {Record<ConversionSettingKey, number | string | boolean>} conversionSetting An object of key-value pairs that are used for tracking settings
     */
    convert(visitorId: string, goalId: string, goalRule?: Record<string, any>, goalData?: Array<GoalData>, segments?: VisitorSegments, conversionSetting?: Record<ConversionSettingKey, number | string | boolean>): RuleError | boolean;
    /**
     * Get audiences that meet the visitorProperties
     * @param {Array<Record<any, any>>} items
     * @param {Record<string, any>} visitorProperties
     * @return {Array<Record<string, any> | RuleError>}
     */
    filterMatchedRecordsWithRule(items: Array<Record<string, any>>, visitorProperties: Record<string, any>, entityType: string, field?: IdentityField): Array<Record<string, any> | RuleError>;
    /**
     * Get audiences that meet the custom segments
     * @param {Array<Record<any, any>>} items
     * @param {string} visitorId
     * @return {Array<Record<string, any>>}
     */
    filterMatchedCustomSegments(items: Array<Record<string, any>>, visitorId: string): Array<Record<string, any>>;
    /**
     * Extract report segments from other attribues in Visitor properties
     * @param {Record<string, any>=} visitorProperties An object of key-value pairs that are used for audience targeting
     * @return {Record<string, any>}
     */
    filterReportSegments(visitorProperties: Record<string, any>): Record<string, any>;
    /**
     * Get list of data entities
     * @param {string} entityType
     * @return {Array<Entity | string>}
     */
    getEntitiesList(entityType: string): Array<Entity | string>;
    /**
     * Get list of data entities grouped by field
     * @param {string} entityType
     * @param {IdentityField=} field
     * @return {Record<string, Entity>}
     */
    getEntitiesListObject(entityType: string, field?: IdentityField): Record<string, Entity>;
    /**
     *
     * @param {string} identity Value of the field which name is provided in identityField
     * @param {string} entityType
     * @param {IdentityField=} identityField Defaults to 'key'
     * @return {Entity}
     * @private
     */
    private _getEntityByField;
    /**
     * Find the entity in list by id
     * @param {string} key
     * @param {string} entityType
     * @return {Entity}
     */
    getEntity(key: string, entityType: string): Entity;
    /**
     * Find the entity in list by keys
     * @param {Array<string>} keys
     * @param {string} entityType
     * @return {Array<Entity>}
     */
    getEntities(keys: Array<string>, entityType: string): Array<Entity>;
    /**
     * Find the entity in list by id
     * @param {string} id
     * @param {string} entityType
     * @return {Entity}
     */
    getEntityById(id: string, entityType: string): Entity;
    /**
     * Find the entity in list by ids
     * @param {Array<string>} ids
     * @param {string} entityType
     * @return {Array<Entity>}
     */
    getEntitiesByIds(ids: Array<string>, entityType: string): Array<Entity>;
    /**
     * Find the items in list by  keys
     * @param {Array<string>} keys
     * @param {string} path
     * @return {Array<Record<string, any>>}
     */
    getItemsByKeys(keys: Array<string>, path: string): Array<Record<string, any>>;
    /**
     * Find the items in list by ids
     * @param {Array<string>} ids
     * @param {String} path
     * @return {Array<Record<string, any>>}
     */
    getItemsByIds(ids: Array<string>, path: string): Array<Record<string, any>>;
    /**
     * Find nested item
     * @param {string} entityType
     * @param {string|number} entityIdentity
     * @param {string} subEntityType
     * @param {string|number} subEntityIdentity
     * @param {IdentityField} identityField
     * @param {IdentityField} subIdentityField
     * @return {Record<any, any>}
     */
    getSubItem(entityType: string, entityIdentity: string, subEntityType: string, subEntityIdentity: string, identityField: IdentityField, subIdentityField: IdentityField): Record<any, any>;
    /**
     * Validates data object
     * @param data
     * @return {boolean}
     */
    isValidConfigData(data: ConfigResponseData): boolean;
}