@kameleoon/javascript-sdk-core/dist/clientConfiguration/clientConfiguration.d.ts

Kameleoon JS SDK Core

import { Result } from 'ts-res';
import { KameleoonError } from '../kameleoonError/kameleoonError';
import { SegmentType } from '../targeting';
import { ClientConfigurationParametersType, ConfigurationType, ExperimentInfoType, ExperimentType, FeatureFlagType, MappedRuleType } from './types';
import { MEGroup } from '../clientConfiguration/meGroup';
interface IClientConfiguration {
    initialize: () => Promise<Result<void, KameleoonError>>;
    readonly featureFlags: Map<string, FeatureFlagType>;
    readonly configuration: ConfigurationType;
    readonly segments: Map<string, SegmentType>;
    readonly ruleMap: Map<number, MappedRuleType>;
    readonly experimentMap: Map<number, ExperimentInfoType>;
    readonly holdout: ExperimentType | null;
    readonly meGroups: Map<string, MEGroup>;
}
export declare class ClientConfiguration implements IClientConfiguration {
    private updateConfigurationIntervalId;
    private updateType;
    private configurationData;
    private featureFlagsData;
    private isTargetedDeliveryRule;
    private segmentsData;
    private holdoutData;
    private meGroupsData;
    private updateInterval;
    private lastUpdate;
    private storage;
    private requester;
    private eventSource;
    private mappedRules;
    private mappedExperiments;
    private dataManager;
    private visitorCodeManager;
    private eventManager;
    private urlProvider;
    private lastModified?;
    private requestTime?;
    private externalPackageInfo;
    private usedDefaultDataFile;
    private defaultDataFile?;
    private readonly CACHE_REVALIDATE_PERIOD;
    constructor({ updateInterval, urlProvider, storage, requester, dataManager, eventSource, externalVisitorCodeManager, eventManager, externalPackageInfo, defaultDataFile, }: ClientConfigurationParametersType);
    initialize(): Promise<Result<void, KameleoonError>>;
    private cleanupHandlers;
    private handleRealTimeUpdates;
    private handlePollingUpdates;
    get featureFlags(): Map<string, FeatureFlagType>;
    get configuration(): ConfigurationType;
    get segments(): Map<string, SegmentType>;
    get ruleMap(): Map<number, MappedRuleType>;
    get experimentMap(): Map<number, ExperimentInfoType>;
    get holdout(): ExperimentType | null;
    get meGroups(): Map<string, MEGroup>;
    get isConsentRequired(): boolean;
    get hasAnyTargetedDeliveryRule(): boolean;
    private checkShouldUpdate;
    private readStorageData;
    /**
     * Updates client configuration
     *
     * @param timeStamp - timestamp for real-time configuration update
     *
     * @returns `true` if current update type should be toggled (SSE/Polling)
     */
    private updateClientConfiguration;
    private updateClientConfigurationInBackground;
    private applyNewConfigurationDataFromResponse;
    private updateConfigurationData;
    private updateFeatureFlagSegments;
    private updateFeatureFlagBucketingCustomDataId;
    private makeMEGroups;
    private updateStorageData;
    private updateConsentRequired;
}
export {};