flagsmith-nodejs 3.3.3 → 4.0.0

package/build/cjs/sdk/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryFetch = exports.delay = exports.generateIdentitiesData = exports.isTraitConfig = void 0;
+function isTraitConfig(traitValue) {
+    return !!traitValue && typeof traitValue == 'object' && traitValue.value !== undefined;
+}
+exports.isTraitConfig = isTraitConfig;
+function generateIdentitiesData(identifier, traits, transient) {
+    const traitsGenerated = Object.entries(traits).map(([key, value]) => {
+        if (isTraitConfig(value)) {
+            return {
+                trait_key: key,
+                trait_value: value?.value,
+                transient: value?.transient,
+            };
+        }
+        else {
+            return {
+                trait_key: key,
+                trait_value: value,
+            };
+        }
+    });
+    if (transient) {
+        return {
+            identifier: identifier,
+            traits: traitsGenerated,
+            transient: true
+        };
+    }
+    return {
+        identifier: identifier,
+        traits: traitsGenerated
+    };
+}
+exports.generateIdentitiesData = generateIdentitiesData;
+const delay = (ms) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
+exports.delay = delay;
+const retryFetch = (url, 
+// built-in RequestInit type doesn't have dispatcher/agent
+fetchOptions, retries = 3, timeoutMs = 10, // set an overall timeout for this function
+customFetch) => {
+    return new Promise((resolve, reject) => {
+        const retryWrapper = (n) => {
+            customFetch(url, {
+                ...fetchOptions,
+                signal: AbortSignal.timeout(timeoutMs)
+            })
+                .then(res => resolve(res))
+                .catch(async (err) => {
+                if (n > 0) {
+                    await (0, exports.delay)(1000);
+                    retryWrapper(--n);
+                }
+                else {
+                    reject(err);
+                }
+            });
+        };
+        retryWrapper(retries);
+    });
+};
+exports.retryFetch = retryFetch;

package/build/esm/flagsmith-engine/environments/models.d.ts

@@ -0,0 +1,22 @@
+import { FeatureStateModel } from '../features/models.js';
+import { IdentityModel } from '../identities/models.js';
+import { ProjectModel } from '../projects/models.js';
+export declare class EnvironmentAPIKeyModel {
+    id: number;
+    key: string;
+    createdAt: number;
+    name: string;
+    clientApiKey: string;
+    expiresAt?: number;
+    active: boolean;
+    constructor(id: number, key: string, createdAt: number, name: string, clientApiKey: string, expiresAt?: number);
+    isValid(): boolean;
+}
+export declare class EnvironmentModel {
+    id: number;
+    apiKey: string;
+    project: ProjectModel;
+    featureStates: FeatureStateModel[];
+    identityOverrides: IdentityModel[];
+    constructor(id: number, apiKey: string, project: ProjectModel);
+}

package/build/esm/flagsmith-engine/environments/models.js

@@ -0,0 +1,32 @@
+export class EnvironmentAPIKeyModel {
+    id;
+    key;
+    createdAt;
+    name;
+    clientApiKey;
+    expiresAt;
+    active = true;
+    constructor(id, key, createdAt, name, clientApiKey, expiresAt) {
+        this.id = id;
+        this.key = key;
+        this.createdAt = createdAt;
+        this.name = name;
+        this.clientApiKey = clientApiKey;
+        this.expiresAt = expiresAt;
+    }
+    isValid() {
+        return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
+    }
+}
+export class EnvironmentModel {
+    id;
+    apiKey;
+    project;
+    featureStates = [];
+    identityOverrides = [];
+    constructor(id, apiKey, project) {
+        this.id = id;
+        this.apiKey = apiKey;
+        this.project = project;
+    }
+}

package/build/esm/flagsmith-engine/environments/util.d.ts

@@ -0,0 +1,3 @@
+import { EnvironmentAPIKeyModel, EnvironmentModel } from './models.js';
+export declare function buildEnvironmentModel(environmentJSON: any): EnvironmentModel;
+export declare function buildEnvironmentAPIKeyModel(apiKeyJSON: any): EnvironmentAPIKeyModel;

package/build/esm/flagsmith-engine/environments/util.js

@@ -0,0 +1,18 @@
+import { buildFeatureStateModel } from '../features/util.js';
+import { buildIdentityModel } from '../identities/util.js';
+import { buildProjectModel } from '../projects/util.js';
+import { EnvironmentAPIKeyModel, EnvironmentModel } from './models.js';
+export function buildEnvironmentModel(environmentJSON) {
+    const project = buildProjectModel(environmentJSON.project);
+    const featureStates = environmentJSON.feature_states.map((fs) => buildFeatureStateModel(fs));
+    const environmentModel = new EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    environmentModel.featureStates = featureStates;
+    if (!!environmentJSON.identity_overrides) {
+        environmentModel.identityOverrides = environmentJSON.identity_overrides.map((identityData) => buildIdentityModel(identityData));
+    }
+    return environmentModel;
+}
+export function buildEnvironmentAPIKeyModel(apiKeyJSON) {
+    const model = new EnvironmentAPIKeyModel(apiKeyJSON.id, apiKeyJSON.key, Date.parse(apiKeyJSON.created_at), apiKeyJSON.name, apiKeyJSON.client_api_key);
+    return model;
+}

package/build/esm/flagsmith-engine/features/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CONSTANTS: {
+    STANDARD: string;
+    MULTIVARIATE: string;
+};

package/build/esm/flagsmith-engine/features/constants.js

@@ -0,0 +1,4 @@
+export const CONSTANTS = {
+    STANDARD: 'STANDARD',
+    MULTIVARIATE: 'MULTIVARIATE'
+};

package/build/esm/flagsmith-engine/features/models.d.ts

@@ -0,0 +1,37 @@
+export declare class FeatureModel {
+    id: number;
+    name: string;
+    type: string;
+    constructor(id: number, name: string, type: string);
+    eq(other: FeatureModel): boolean;
+}
+export declare class MultivariateFeatureOptionModel {
+    value: any;
+    id: number | undefined;
+    constructor(value: any, id?: number);
+}
+export declare class MultivariateFeatureStateValueModel {
+    multivariateFeatureOption: MultivariateFeatureOptionModel;
+    percentageAllocation: number;
+    id: number;
+    mvFsValueUuid: string;
+    constructor(multivariate_feature_option: MultivariateFeatureOptionModel, percentage_allocation: number, id: number, mvFsValueUuid?: string);
+}
+export declare class FeatureStateModel {
+    feature: FeatureModel;
+    enabled: boolean;
+    djangoID: number;
+    featurestateUUID: string;
+    featureSegment?: FeatureSegment;
+    private value;
+    multivariateFeatureStateValues: MultivariateFeatureStateValueModel[];
+    constructor(feature: FeatureModel, enabled: boolean, djangoID: number, value?: any, featurestateUuid?: string);
+    setValue(value: any): void;
+    getValue(identityId?: number | string): any;
+    isHigherSegmentPriority(other: FeatureStateModel): boolean;
+    getMultivariateValue(identityID: number | string): any;
+}
+export declare class FeatureSegment {
+    priority: number;
+    constructor(priority: number);
+}

package/build/esm/flagsmith-engine/features/models.js

@@ -0,0 +1,110 @@
+import { randomUUID as uuidv4 } from "node:crypto";
+import { getHashedPercentateForObjIds } from '../utils/hashing/index.js';
+export class FeatureModel {
+    id;
+    name;
+    type;
+    constructor(id, name, type) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+    }
+    eq(other) {
+        return !!other && this.id === other.id;
+    }
+}
+export class MultivariateFeatureOptionModel {
+    value;
+    id;
+    constructor(value, id) {
+        this.value = value;
+        this.id = id;
+    }
+}
+export class MultivariateFeatureStateValueModel {
+    multivariateFeatureOption;
+    percentageAllocation;
+    id;
+    mvFsValueUuid = uuidv4();
+    constructor(multivariate_feature_option, percentage_allocation, id, mvFsValueUuid) {
+        this.id = id;
+        this.percentageAllocation = percentage_allocation;
+        this.multivariateFeatureOption = multivariate_feature_option;
+        this.mvFsValueUuid = mvFsValueUuid || this.mvFsValueUuid;
+    }
+}
+export class FeatureStateModel {
+    feature;
+    enabled;
+    djangoID;
+    featurestateUUID = uuidv4();
+    featureSegment;
+    value;
+    multivariateFeatureStateValues = [];
+    constructor(feature, enabled, djangoID, value, featurestateUuid = uuidv4()) {
+        this.feature = feature;
+        this.enabled = enabled;
+        this.djangoID = djangoID;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    getValue(identityId) {
+        if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
+            return this.getMultivariateValue(identityId);
+        }
+        return this.value;
+    }
+    /*
+        Returns `True` if `this` is higher segment priority than `other`
+        (i.e. has lower value for featureSegment.priority)
+        NOTE:
+            A segment will be considered higher priority only if:
+            1. `other` does not have a feature segment(i.e: it is an environment feature state or it's a
+            feature state with feature segment but from an old document that does not have `featureSegment.priority`)
+            but `this` does.
+            2. `other` have a feature segment with high priority
+    */
+    isHigherSegmentPriority(other) {
+        if (!other.featureSegment || !this.featureSegment) {
+            return !!this.featureSegment && !other.featureSegment;
+        }
+        return this.featureSegment.priority < other.featureSegment.priority;
+    }
+    getMultivariateValue(identityID) {
+        let percentageValue;
+        let startPercentage = 0;
+        const sortedF = this.multivariateFeatureStateValues.sort((a, b) => {
+            return a.id - b.id;
+        });
+        for (const myValue of sortedF) {
+            switch (myValue.percentageAllocation) {
+                case 0:
+                    continue;
+                case 100:
+                    return myValue.multivariateFeatureOption.value;
+                default:
+                    if (percentageValue === undefined) {
+                        percentageValue = getHashedPercentateForObjIds([
+                            this.djangoID || this.featurestateUUID,
+                            identityID
+                        ]);
+                    }
+            }
+            const limit = myValue.percentageAllocation + startPercentage;
+            if (startPercentage <= percentageValue && percentageValue < limit) {
+                return myValue.multivariateFeatureOption.value;
+            }
+            startPercentage = limit;
+        }
+        return this.value;
+    }
+}
+export class FeatureSegment {
+    priority;
+    constructor(priority) {
+        this.priority = priority;
+    }
+}

package/build/esm/flagsmith-engine/features/util.d.ts

@@ -0,0 +1,4 @@
+import { FeatureModel, FeatureSegment, FeatureStateModel } from './models.js';
+export declare function buildFeatureModel(featuresModelJSON: any): FeatureModel;
+export declare function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStateModel;
+export declare function buildFeatureSegment(featureSegmentJSON: any): FeatureSegment;

package/build/esm/flagsmith-engine/features/util.js

@@ -0,0 +1,21 @@
+import { FeatureModel, FeatureSegment, FeatureStateModel, MultivariateFeatureOptionModel, MultivariateFeatureStateValueModel } from './models.js';
+export function buildFeatureModel(featuresModelJSON) {
+    return new FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
+}
+export function buildFeatureStateModel(featuresStateModelJSON) {
+    const featureStateModel = new FeatureStateModel(buildFeatureModel(featuresStateModelJSON.feature), featuresStateModelJSON.enabled, featuresStateModelJSON.django_id, featuresStateModelJSON.feature_state_value, featuresStateModelJSON.featurestate_uuid);
+    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ?
+        buildFeatureSegment(featuresStateModelJSON.feature_segment) :
+        undefined;
+    const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv) => {
+            const featureOption = new MultivariateFeatureOptionModel(fsv.multivariate_feature_option.value, fsv.multivariate_feature_option.id);
+            return new MultivariateFeatureStateValueModel(featureOption, fsv.percentage_allocation, fsv.id, fsv.mv_fs_value_uuid);
+        })
+        : [];
+    featureStateModel.multivariateFeatureStateValues = multivariateFeatureStateValues;
+    return featureStateModel;
+}
+export function buildFeatureSegment(featureSegmentJSON) {
+    return new FeatureSegment(featureSegmentJSON.priority);
+}

package/build/esm/flagsmith-engine/identities/models.d.ts

@@ -0,0 +1,15 @@
+import { IdentityFeaturesList } from '../utils/collections.js';
+import { TraitModel } from './traits/models.js';
+export declare class IdentityModel {
+    identifier: string;
+    environmentApiKey: string;
+    createdDate?: number;
+    identityFeatures: IdentityFeaturesList;
+    identityTraits: TraitModel[];
+    identityUuid: string;
+    djangoID: number | undefined;
+    constructor(created_date: string, identityTraits: TraitModel[], identityFeatures: IdentityFeaturesList, environmentApiKey: string, identifier: string, identityUuid?: string, djangoID?: number);
+    get compositeKey(): string;
+    static generateCompositeKey(env_key: string, identifier: string): string;
+    updateTraits(traits: TraitModel[]): void;
+}

package/build/esm/flagsmith-engine/identities/models.js

@@ -0,0 +1,44 @@
+import { IdentityFeaturesList } from '../utils/collections.js';
+import { randomUUID as uuidv4 } from 'node:crypto';
+export class IdentityModel {
+    identifier;
+    environmentApiKey;
+    createdDate;
+    identityFeatures;
+    identityTraits;
+    identityUuid;
+    djangoID;
+    constructor(created_date, identityTraits, identityFeatures, environmentApiKey, identifier, identityUuid, djangoID) {
+        this.identityUuid = identityUuid || uuidv4();
+        this.createdDate = Date.parse(created_date) || Date.now();
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new IdentityFeaturesList(...identityFeatures);
+        this.environmentApiKey = environmentApiKey;
+        this.identifier = identifier;
+        this.djangoID = djangoID;
+    }
+    get compositeKey() {
+        return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+    }
+    static generateCompositeKey(env_key, identifier) {
+        return `${env_key}_${identifier}`;
+    }
+    updateTraits(traits) {
+        const existingTraits = new Map();
+        for (const trait of this.identityTraits) {
+            existingTraits.set(trait.traitKey, trait);
+        }
+        for (const trait of traits) {
+            if (!!trait.traitValue) {
+                existingTraits.set(trait.traitKey, trait);
+            }
+            else {
+                existingTraits.delete(trait.traitKey);
+            }
+        }
+        this.identityTraits = [];
+        for (const [k, v] of existingTraits.entries()) {
+            this.identityTraits.push(v);
+        }
+    }
+}

package/build/esm/flagsmith-engine/identities/traits/models.d.ts

@@ -0,0 +1,5 @@
+export declare class TraitModel {
+    traitKey: string;
+    traitValue: any;
+    constructor(key: string, value: any);
+}

package/build/esm/flagsmith-engine/identities/traits/models.js

@@ -0,0 +1,8 @@
+export class TraitModel {
+    traitKey;
+    traitValue;
+    constructor(key, value) {
+        this.traitKey = key;
+        this.traitValue = value;
+    }
+}

package/build/esm/flagsmith-engine/identities/util.d.ts

@@ -0,0 +1,4 @@
+import { IdentityModel } from './models.js';
+import { TraitModel } from './traits/models.js';
+export declare function buildTraitModel(traitJSON: any): TraitModel;
+export declare function buildIdentityModel(identityJSON: any): IdentityModel;

package/build/esm/flagsmith-engine/identities/util.js

@@ -0,0 +1,17 @@
+import { buildFeatureStateModel } from '../features/util.js';
+import { IdentityFeaturesList } from '../utils/collections.js';
+import { IdentityModel } from './models.js';
+import { TraitModel } from './traits/models.js';
+export function buildTraitModel(traitJSON) {
+    return new TraitModel(traitJSON.trait_key, traitJSON.trait_value);
+}
+export function buildIdentityModel(identityJSON) {
+    const featureList = identityJSON.identity_features
+        ? new IdentityFeaturesList(...identityJSON.identity_features.map((f) => buildFeatureStateModel(f)))
+        : [];
+    const model = new IdentityModel(identityJSON.created_date, identityJSON.identity_traits
+        ? identityJSON.identity_traits.map((trait) => buildTraitModel(trait))
+        : [], featureList, identityJSON.environment_api_key, identityJSON.identifier, identityJSON.identity_uuid);
+    model.djangoID = identityJSON.django_id;
+    return model;
+}

package/build/esm/flagsmith-engine/index.d.ts

@@ -0,0 +1,14 @@
+import { EnvironmentModel } from './environments/models.js';
+import { FeatureStateModel } from './features/models.js';
+import { IdentityModel } from './identities/models.js';
+import { TraitModel } from './identities/traits/models.js';
+export { EnvironmentModel } from './environments/models.js';
+export { FeatureStateModel } from './features/models.js';
+export { IdentityModel } from './identities/models.js';
+export { TraitModel } from './identities/traits/models.js';
+export { SegmentModel } from './segments/models.js';
+export { OrganisationModel } from './organisations/models.js';
+export declare function getIdentityFeatureState(environment: EnvironmentModel, identity: IdentityModel, featureName: string, overrideTraits?: TraitModel[]): FeatureStateModel;
+export declare function getIdentityFeatureStates(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): FeatureStateModel[];
+export declare function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string): FeatureStateModel;
+export declare function getEnvironmentFeatureStates(environment: EnvironmentModel): FeatureStateModel[];

package/build/esm/flagsmith-engine/index.js

@@ -0,0 +1,62 @@
+import { getIdentitySegments } from './segments/evaluators.js';
+import { FeatureStateNotFound } from './utils/errors.js';
+export { EnvironmentModel } from './environments/models.js';
+export { FeatureStateModel } from './features/models.js';
+export { IdentityModel } from './identities/models.js';
+export { TraitModel } from './identities/traits/models.js';
+export { SegmentModel } from './segments/models.js';
+export { OrganisationModel } from './organisations/models.js';
+function getIdentityFeatureStatesDict(environment, identity, overrideTraits) {
+    // Get feature states from the environment
+    const featureStates = {};
+    for (const fs of environment.featureStates) {
+        featureStates[fs.feature.id] = fs;
+    }
+    // Override with any feature states defined by matching segments
+    const identitySegments = getIdentitySegments(environment, identity, overrideTraits);
+    for (const matchingSegment of identitySegments) {
+        for (const featureState of matchingSegment.featureStates) {
+            if (featureStates[featureState.feature.id]) {
+                if (featureStates[featureState.feature.id].isHigherSegmentPriority(featureState)) {
+                    continue;
+                }
+            }
+            featureStates[featureState.feature.id] = featureState;
+        }
+    }
+    // Override with any feature states defined directly the identity
+    for (const fs of identity.identityFeatures) {
+        if (featureStates[fs.feature.id]) {
+            featureStates[fs.feature.id] = fs;
+        }
+    }
+    return featureStates;
+}
+export function getIdentityFeatureState(environment, identity, featureName, overrideTraits) {
+    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
+    const matchingFeature = Object.values(featureStates).filter(f => f.feature.name === featureName);
+    if (matchingFeature.length === 0) {
+        throw new FeatureStateNotFound('Feature State Not Found');
+    }
+    return matchingFeature[0];
+}
+export function getIdentityFeatureStates(environment, identity, overrideTraits) {
+    const featureStates = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
+    if (environment.project.hideDisabledFlags) {
+        return featureStates.filter(fs => !!fs.enabled);
+    }
+    return featureStates;
+}
+export function getEnvironmentFeatureState(environment, featureName) {
+    const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
+    if (featuresStates.length === 0) {
+        throw new FeatureStateNotFound('Feature State Not Found');
+    }
+    return featuresStates[0];
+}
+export function getEnvironmentFeatureStates(environment) {
+    if (environment.project.hideDisabledFlags) {
+        return environment.featureStates.filter(fs => !!fs.enabled);
+    }
+    return environment.featureStates;
+}

package/build/esm/flagsmith-engine/organisations/models.d.ts

@@ -0,0 +1,9 @@
+export declare class OrganisationModel {
+    id: number;
+    name: string;
+    featureAnalytics: boolean;
+    stopServingFlags: boolean;
+    persistTraitData: boolean;
+    constructor(id: number, name: string, featureAnalytics: boolean, stopServingFlags: boolean, persistTraitData: boolean);
+    get uniqueSlug(): string;
+}

package/build/esm/flagsmith-engine/organisations/models.js

@@ -0,0 +1,17 @@
+export class OrganisationModel {
+    id;
+    name;
+    featureAnalytics;
+    stopServingFlags;
+    persistTraitData;
+    constructor(id, name, featureAnalytics, stopServingFlags, persistTraitData) {
+        this.id = id;
+        this.name = name;
+        this.featureAnalytics = featureAnalytics;
+        this.stopServingFlags = stopServingFlags;
+        this.persistTraitData = persistTraitData;
+    }
+    get uniqueSlug() {
+        return this.id.toString() + '-' + this.name;
+    }
+}

package/build/esm/flagsmith-engine/organisations/util.d.ts

@@ -0,0 +1,2 @@
+import { OrganisationModel } from './models.js';
+export declare function buildOrganizationModel(organizationJSON: any): OrganisationModel;

package/build/esm/flagsmith-engine/organisations/util.js

@@ -0,0 +1,4 @@
+import { OrganisationModel } from './models.js';
+export function buildOrganizationModel(organizationJSON) {
+    return new OrganisationModel(organizationJSON.id, organizationJSON.name, organizationJSON.feature_analytics, organizationJSON.stop_serving_flags, organizationJSON.persist_trait_data);
+}

package/build/esm/flagsmith-engine/projects/models.d.ts

@@ -0,0 +1,10 @@
+import { OrganisationModel } from '../organisations/models.js';
+import { SegmentModel } from '../segments/models.js';
+export declare class ProjectModel {
+    id: number;
+    name: string;
+    organisation: OrganisationModel;
+    hideDisabledFlags: boolean;
+    segments: SegmentModel[];
+    constructor(id: number, name: string, hideDisabledFlags: boolean, organization: OrganisationModel);
+}

package/build/esm/flagsmith-engine/projects/models.js

@@ -0,0 +1,13 @@
+export class ProjectModel {
+    id;
+    name;
+    organisation;
+    hideDisabledFlags;
+    segments = [];
+    constructor(id, name, hideDisabledFlags, organization) {
+        this.id = id;
+        this.name = name;
+        this.hideDisabledFlags = hideDisabledFlags;
+        this.organisation = organization;
+    }
+}

package/build/esm/flagsmith-engine/projects/util.d.ts

@@ -0,0 +1,2 @@
+import { ProjectModel } from './models.js';
+export declare function buildProjectModel(projectJSON: any): ProjectModel;

package/build/esm/flagsmith-engine/projects/util.js

@@ -0,0 +1,11 @@
+import { buildOrganizationModel } from '../organisations/util.js';
+import { buildSegmentModel } from '../segments/util.js';
+import { ProjectModel } from './models.js';
+export function buildProjectModel(projectJSON) {
+    const segments = projectJSON['segments']
+        ? projectJSON['segments'].map((s) => buildSegmentModel(s))
+        : [];
+    const model = new ProjectModel(projectJSON.id, projectJSON.name, projectJSON.hide_disabled_flags, buildOrganizationModel(projectJSON.organisation));
+    model.segments = segments;
+    return model;
+}

package/build/esm/flagsmith-engine/segments/constants.d.ts

@@ -0,0 +1,34 @@
+export declare const ALL_RULE = "ALL";
+export declare const ANY_RULE = "ANY";
+export declare const NONE_RULE = "NONE";
+export declare const RULE_TYPES: string[];
+export declare const EQUAL = "EQUAL";
+export declare const GREATER_THAN = "GREATER_THAN";
+export declare const LESS_THAN = "LESS_THAN";
+export declare const LESS_THAN_INCLUSIVE = "LESS_THAN_INCLUSIVE";
+export declare const CONTAINS = "CONTAINS";
+export declare const GREATER_THAN_INCLUSIVE = "GREATER_THAN_INCLUSIVE";
+export declare const NOT_CONTAINS = "NOT_CONTAINS";
+export declare const NOT_EQUAL = "NOT_EQUAL";
+export declare const REGEX = "REGEX";
+export declare const PERCENTAGE_SPLIT = "PERCENTAGE_SPLIT";
+export declare const IS_SET = "IS_SET";
+export declare const IS_NOT_SET = "IS_NOT_SET";
+export declare const MODULO = "MODULO";
+export declare const IN = "IN";
+export declare const CONDITION_OPERATORS: {
+    EQUAL: string;
+    GREATER_THAN: string;
+    LESS_THAN: string;
+    LESS_THAN_INCLUSIVE: string;
+    CONTAINS: string;
+    GREATER_THAN_INCLUSIVE: string;
+    NOT_CONTAINS: string;
+    NOT_EQUAL: string;
+    REGEX: string;
+    PERCENTAGE_SPLIT: string;
+    IS_SET: string;
+    IS_NOT_SET: string;
+    MODULO: string;
+    IN: string;
+};