flagsmith-nodejs 6.2.0 → 7.0.2

package/build/cjs/flagsmith-engine/segments/models.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentModel = exports.SegmentRuleModel = exports.SegmentConditionModel = exports.getMatchingFunctions = exports.semverMatchingFunction = exports.matchingFunctions = exports.any = exports.all = void 0;
 const semver = require("semver");
+const models_js_1 = require("../features/models.js");
 const index_js_1 = require("../utils/index.js");
 const constants_js_1 = require("./constants.js");
 const util_js_1 = require("./util.js");
+const constants_js_2 = require("../features/constants.js");
+const models_js_2 = require("../evaluation/models.js");
 const all = (iterable) => iterable.filter(e => !!e).length === iterable.length;
 exports.all = all;
 const any = (iterable) => iterable.filter(e => !!e).length > 0;
@@ -16,15 +19,33 @@ exports.matchingFunctions = {
     [constants_js_1.CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => thisValue > otherValue,
     [constants_js_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => thisValue >= otherValue,
     [constants_js_1.CONDITION_OPERATORS.NOT_EQUAL]: (thisValue, otherValue) => thisValue != otherValue,
-    [constants_js_1.CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => !!otherValue && otherValue.includes(thisValue)
+    [constants_js_1.CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => {
+        try {
+            return !!otherValue && otherValue.includes(thisValue);
+        }
+        catch {
+            return false;
+        }
+    }
+};
+// Semver library throws an error if the version is invalid, in this case, we want to catch and return false
+const safeSemverCompare = (semverMatchingFunction) => {
+    return (conditionValue, traitValue) => {
+        try {
+            return semverMatchingFunction(conditionValue, traitValue);
+        }
+        catch {
+            return false;
+        }
+    };
 };
 exports.semverMatchingFunction = {
     ...exports.matchingFunctions,
-    [constants_js_1.CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => semver.eq(thisValue, otherValue),
-    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => semver.gt(otherValue, thisValue),
-    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => semver.gte(otherValue, thisValue),
-    [constants_js_1.CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => semver.gt(thisValue, otherValue),
-    [constants_js_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => semver.gte(thisValue, otherValue)
+    [constants_js_1.CONDITION_OPERATORS.EQUAL]: safeSemverCompare((conditionValue, traitValue) => semver.eq(traitValue, conditionValue)),
+    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN]: safeSemverCompare((conditionValue, traitValue) => semver.gt(traitValue, conditionValue)),
+    [constants_js_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: safeSemverCompare((conditionValue, traitValue) => semver.gte(traitValue, conditionValue)),
+    [constants_js_1.CONDITION_OPERATORS.LESS_THAN]: safeSemverCompare((conditionValue, traitValue) => semver.lt(traitValue, conditionValue)),
+    [constants_js_1.CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: safeSemverCompare((conditionValue, traitValue) => semver.lte(traitValue, conditionValue))
 };
 const getMatchingFunctions = (semver) => semver ? exports.semverMatchingFunction : exports.matchingFunctions;
 exports.getMatchingFunctions = getMatchingFunctions;
@@ -37,11 +58,11 @@ class SegmentConditionModel {
     };
     operator;
     value;
-    property_;
+    property;
     constructor(operator, value, property) {
         this.operator = operator;
         this.value = value;
-        this.property_ = property;
+        this.property = property;
     }
     matchesTraitValue(traitValue) {
         const evaluators = {
@@ -51,17 +72,49 @@ class SegmentConditionModel {
                     !traitValue.includes(this.value?.toString()));
             },
             evaluateRegex: (traitValue) => {
-                return !!this.value && !!traitValue?.toString().match(new RegExp(this.value));
+                try {
+                    if (!this.value) {
+                        return false;
+                    }
+                    const regex = new RegExp(this.value?.toString());
+                    return !!traitValue?.toString().match(regex);
+                }
+                catch {
+                    return false;
+                }
             },
             evaluateModulo: (traitValue) => {
-                if (isNaN(parseFloat(traitValue)) || !this.value) {
+                const parsedTraitValue = parseFloat(traitValue);
+                if (isNaN(parsedTraitValue) || !this.value) {
+                    return false;
+                }
+                const parts = this.value.toString().split('|');
+                if (parts.length !== 2) {
+                    return false;
+                }
+                const divisor = parseFloat(parts[0]);
+                const remainder = parseFloat(parts[1]);
+                if (isNaN(divisor) || isNaN(remainder) || divisor === 0) {
                     return false;
                 }
-                const parts = this.value.split('|');
-                const [divisor, reminder] = [parseFloat(parts[0]), parseFloat(parts[1])];
-                return traitValue % divisor === reminder;
+                return parsedTraitValue % divisor === remainder;
             },
             evaluateIn: (traitValue) => {
+                if (!traitValue || typeof traitValue === 'boolean') {
+                    return false;
+                }
+                if (Array.isArray(this.value)) {
+                    return this.value.includes(traitValue.toString());
+                }
+                if (typeof this.value === 'string') {
+                    try {
+                        const parsed = JSON.parse(this.value);
+                        if (Array.isArray(parsed)) {
+                            return parsed.includes(traitValue.toString());
+                        }
+                    }
+                    catch { }
+                }
                 return this.value?.split(',').includes(traitValue.toString());
             }
         };
@@ -107,5 +160,54 @@ class SegmentModel {
         this.id = id;
         this.name = name;
     }
+    static fromSegmentResult(segmentResults, evaluationContext) {
+        const segmentModels = [];
+        if (!evaluationContext.segments) {
+            return [];
+        }
+        for (const segmentResult of segmentResults) {
+            if (segmentResult.metadata?.source === models_js_2.SegmentSource.IDENTITY_OVERRIDE) {
+                continue;
+            }
+            const segmentMetadataId = segmentResult.metadata?.id;
+            if (!segmentMetadataId) {
+                continue;
+            }
+            const segmentContext = evaluationContext.segments[segmentMetadataId.toString()];
+            if (segmentContext) {
+                const segment = new SegmentModel(segmentMetadataId, segmentContext.name);
+                segment.rules = segmentContext.rules.map(rule => new SegmentRuleModel(rule.type));
+                segment.featureStates = SegmentModel.createFeatureStatesFromOverrides(segmentContext.overrides || []);
+                segmentModels.push(segment);
+            }
+        }
+        return segmentModels;
+    }
+    static createFeatureStatesFromOverrides(overrides) {
+        if (!overrides)
+            return [];
+        return overrides
+            .filter(override => {
+            const overrideMetadataId = override?.metadata?.id;
+            return typeof overrideMetadataId === 'number';
+        })
+            .map(override => {
+            const overrideMetadataId = override.metadata.id;
+            const feature = new models_js_1.FeatureModel(overrideMetadataId, override.name, override.variants?.length && override.variants.length > 0
+                ? constants_js_2.CONSTANTS.MULTIVARIATE
+                : constants_js_2.CONSTANTS.STANDARD);
+            const featureState = new models_js_1.FeatureStateModel(feature, override.enabled, override.priority || 0);
+            if (override.value !== undefined) {
+                featureState.setValue(override.value);
+            }
+            if (override.variants && override.variants.length > 0) {
+                featureState.multivariateFeatureStateValues = this.createMultivariateValues(override.variants);
+            }
+            return featureState;
+        });
+    }
+    static createMultivariateValues(variants) {
+        return variants.map(variant => new models_js_1.MultivariateFeatureStateValueModel(new models_js_1.MultivariateFeatureOptionModel(variant.value, variant.id), variant.weight, variant.id));
+    }
 }
 exports.SegmentModel = SegmentModel;

package/build/cjs/flagsmith-engine/utils/hashing/index.d.ts

@@ -6,4 +6,4 @@
  * @param  {} iterations=1 num times to include each id in the generated string to hash
  * @returns number number between 0 (inclusive) and 100 (exclusive)
  */
-export declare function getHashedPercentateForObjIds(objectIds: Array<any>, iterations?: number): number;
+export declare function getHashedPercentageForObjIds(objectIds: Array<any>, iterations?: number): number;

package/build/cjs/flagsmith-engine/utils/hashing/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHashedPercentateForObjIds = void 0;
+exports.getHashedPercentageForObjIds = void 0;
 const node_crypto_1 = require("node:crypto");
 const md5 = (data) => (0, node_crypto_1.createHash)('md5').update(data).digest('hex');
 const makeRepeated = (arr, repeats) => Array.from({ length: repeats }, () => arr).flat();
@@ -13,7 +13,7 @@ const makeRepeated = (arr, repeats) => Array.from({ length: repeats }, () => arr
  * @param  {} iterations=1 num times to include each id in the generated string to hash
  * @returns number number between 0 (inclusive) and 100 (exclusive)
  */
-function getHashedPercentateForObjIds(objectIds, iterations = 1) {
+function getHashedPercentageForObjIds(objectIds, iterations = 1) {
     let toHash = makeRepeated(objectIds, iterations).join(',');
     const hashedValue = md5(toHash);
     const hashedInt = BigInt('0x' + hashedValue);
@@ -22,8 +22,8 @@ function getHashedPercentateForObjIds(objectIds, iterations = 1) {
     /* istanbul ignore next */
     if (value === 100) {
         /* istanbul ignore next */
-        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+        return getHashedPercentageForObjIds(objectIds, iterations + 1);
     }
     return value;
 }
-exports.getHashedPercentateForObjIds = getHashedPercentateForObjIds;
+exports.getHashedPercentageForObjIds = getHashedPercentageForObjIds;

package/build/cjs/sdk/index.d.ts

@@ -1,10 +1,8 @@
 import { Dispatcher } from 'undici-types';
-import { EnvironmentModel } from '../flagsmith-engine/index.js';
-import { IdentityModel } from '../flagsmith-engine/index.js';
 import { BaseOfflineHandler } from './offline_handlers.js';
 import { DefaultFlag, Flags } from './models.js';
 import { EnvironmentDataPollingManager } from './polling_manager.js';
-import { SegmentModel } from '../flagsmith-engine/index.js';
+import { SegmentModel, EnvironmentModel, IdentityModel } from '../flagsmith-engine/index.js';
 import { FlagsmithConfig, FlagsmithTraitValue, TraitConfig } from './types.js';
 export { AnalyticsProcessor, AnalyticsProcessorOptions } from './analytics.js';
 export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';

package/build/cjs/sdk/index.js

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flagsmith = exports.EnvironmentDataPollingManager = exports.Flags = exports.DefaultFlag = exports.BaseFlag = exports.FlagsmithClientError = exports.FlagsmithAPIError = exports.AnalyticsProcessor = void 0;
-const index_js_1 = require("../flagsmith-engine/index.js");
 const util_js_1 = require("../flagsmith-engine/environments/util.js");
-const index_js_2 = require("../flagsmith-engine/index.js");
-const index_js_3 = require("../flagsmith-engine/index.js");
 const analytics_js_1 = require("./analytics.js");
 const errors_js_1 = require("./errors.js");
 const models_js_1 = require("./models.js");
 const polling_manager_js_1 = require("./polling_manager.js");
 const utils_js_1 = require("./utils.js");
-const evaluators_js_1 = require("../flagsmith-engine/segments/evaluators.js");
+const index_js_1 = require("../flagsmith-engine/index.js");
 const pino_1 = require("pino");
+const mappers_js_1 = require("../flagsmith-engine/evaluation/evaluationContext/mappers.js");
 var analytics_js_2 = require("./analytics.js");
 Object.defineProperty(exports, "AnalyticsProcessor", { enumerable: true, get: function () { return analytics_js_2.AnalyticsProcessor; } });
 var errors_js_2 = require("./errors.js");
@@ -230,7 +228,12 @@ class Flagsmith {
             key,
             value: traits?.[key]
         })));
-        return (0, evaluators_js_1.getIdentitySegments)(environment, identityModel);
+        const context = (0, mappers_js_1.getEvaluationContext)(environment, identityModel);
+        if (!context) {
+            throw new errors_js_1.FlagsmithClientError('Local evaluation required to obtain identity segments');
+        }
+        const evaluationResult = (0, index_js_1.getEvaluationResult)(context);
+        return index_js_1.SegmentModel.fromSegmentResult(evaluationResult.segments, context);
     }
     async fetchEnvironment() {
         const deferred = new utils_js_1.Deferred();
@@ -361,11 +364,12 @@ class Flagsmith {
     }
     async getEnvironmentFlagsFromDocument() {
         const environment = await this.getEnvironment();
-        const flags = models_js_1.Flags.fromFeatureStateModels({
-            featureStates: (0, index_js_1.getEnvironmentFeatureStates)(environment),
-            analyticsProcessor: this.analyticsProcessor,
-            defaultFlagHandler: this.defaultFlagHandler
-        });
+        const context = (0, mappers_js_1.getEvaluationContext)(environment, undefined, undefined, true);
+        if (!context) {
+            throw new errors_js_1.FlagsmithClientError('Unable to get flags. No environment present.');
+        }
+        const evaluationResult = (0, index_js_1.getEvaluationResult)(context);
+        const flags = models_js_1.Flags.fromEvaluationResult(evaluationResult);
         if (!!this.cache) {
             await this.cache.set('flags', flags);
         }
@@ -377,13 +381,12 @@ class Flagsmith {
             key,
             value: traits[key]
         })));
-        const featureStates = (0, index_js_1.getIdentityFeatureStates)(environment, identityModel);
-        const flags = models_js_1.Flags.fromFeatureStateModels({
-            featureStates: featureStates,
-            analyticsProcessor: this.analyticsProcessor,
-            defaultFlagHandler: this.defaultFlagHandler,
-            identityID: identityModel.djangoID || identityModel.compositeKey
-        });
+        const context = (0, mappers_js_1.getEvaluationContext)(environment, identityModel);
+        if (!context) {
+            throw new errors_js_1.FlagsmithClientError('Unable to get flags. No environment present.');
+        }
+        const evaluationResult = (0, index_js_1.getEvaluationResult)(context);
+        const flags = models_js_1.Flags.fromEvaluationResult(evaluationResult, this.defaultFlagHandler, this.analyticsProcessor);
         if (!!this.cache) {
             await this.cache.set(`flags-${identifier}`, flags);
         }
@@ -421,13 +424,13 @@ class Flagsmith {
         return flags;
     }
     getIdentityModel(environment, identifier, traits) {
-        const traitModels = traits.map(trait => new index_js_3.TraitModel(trait.key, trait.value));
+        const traitModels = traits.map(trait => new index_js_1.TraitModel(trait.key, trait.value));
         let identityWithOverrides = this.identitiesWithOverridesByIdentifier?.get(identifier);
         if (identityWithOverrides) {
             identityWithOverrides.updateTraits(traitModels);
             return identityWithOverrides;
         }
-        return new index_js_2.IdentityModel('0', traitModels, [], environment.apiKey, identifier);
+        return new index_js_1.IdentityModel('0', traitModels, [], environment.apiKey, identifier);
     }
 }
 exports.Flagsmith = Flagsmith;

package/build/cjs/sdk/models.d.ts

@@ -1,6 +1,7 @@
+import { EvaluationResultWithMetadata } from '../flagsmith-engine/evaluation/models.js';
 import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
 import { AnalyticsProcessor } from './analytics.js';
-type FlagValue = string | number | boolean | undefined;
+type FlagValue = string | number | boolean | undefined | null;
 /**
  * A Flagsmith feature. It has an enabled/disabled state, and an optional {@link FlagValue}.
  */
@@ -38,12 +39,17 @@ export declare class Flag extends BaseFlag {
      * The programmatic name for this feature, unique per Flagsmith project.
      */
     featureName: string;
+    /**
+     * The reason for this feature, unique per Flagsmith project.
+     */
+    reason?: string;
     constructor(params: {
         value: FlagValue;
         enabled: boolean;
         isDefault?: boolean;
         featureId: number;
         featureName: string;
+        reason?: string;
     });
     static fromFeatureStateModel(fsm: FeatureStateModel, identityId: number | string | undefined): Flag;
     static fromAPIFlag(flagData: any): Flag;
@@ -61,6 +67,7 @@ export declare class Flags {
         defaultFlagHandler?: (v: string) => DefaultFlag;
         analyticsProcessor?: AnalyticsProcessor;
     });
+    static fromEvaluationResult(evaluationResult: EvaluationResultWithMetadata, defaultFlagHandler?: (v: string) => DefaultFlag, analyticsProcessor?: AnalyticsProcessor): Flags;
     static fromFeatureStateModels(data: {
         featureStates: FeatureStateModel[];
         analyticsProcessor?: AnalyticsProcessor;

package/build/cjs/sdk/models.js

@@ -46,10 +46,15 @@ class Flag extends BaseFlag {
      * The programmatic name for this feature, unique per Flagsmith project.
      */
     featureName;
+    /**
+     * The reason for this feature, unique per Flagsmith project.
+     */
+    reason;
     constructor(params) {
         super(params.value, params.enabled, !!params.isDefault);
         this.featureId = params.featureId;
         this.featureName = params.featureName;
+        this.reason = params.reason;
     }
     static fromFeatureStateModel(fsm, identityId) {
         return new Flag({
@@ -64,7 +69,8 @@ class Flag extends BaseFlag {
             enabled: flagData['enabled'],
             value: flagData['feature_state_value'] ?? flagData['value'],
             featureId: flagData['feature']['id'],
-            featureName: flagData['feature']['name']
+            featureName: flagData['feature']['name'],
+            reason: flagData['feature']['reason']
         });
     }
 }
@@ -78,6 +84,28 @@ class Flags {
         this.defaultFlagHandler = data.defaultFlagHandler;
         this.analyticsProcessor = data.analyticsProcessor;
     }
+    static fromEvaluationResult(evaluationResult, defaultFlagHandler, analyticsProcessor) {
+        const flags = {};
+        for (const flag of Object.values(evaluationResult.flags)) {
+            const flagMetadataId = flag.metadata?.id;
+            if (!flagMetadataId) {
+                throw new Error(`FlagResult metadata.id is missing for feature "${flag.name}". ` +
+                    `This indicates a bug in the SDK, please report it.`);
+            }
+            flags[flag.name] = new Flag({
+                enabled: flag.enabled,
+                value: flag.value ?? null,
+                featureId: flagMetadataId,
+                featureName: flag.name,
+                reason: flag.reason
+            });
+        }
+        return new Flags({
+            flags: flags,
+            defaultFlagHandler: defaultFlagHandler,
+            analyticsProcessor: analyticsProcessor
+        });
+    }
     static fromFeatureStateModels(data) {
         const flags = {};
         for (const fs of data.featureStates) {

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

@@ -18,5 +18,6 @@ export declare class EnvironmentModel {
     project: ProjectModel;
     featureStates: FeatureStateModel[];
     identityOverrides: IdentityModel[];
-    constructor(id: number, apiKey: string, project: ProjectModel);
+    name: string;
+    constructor(id: number, apiKey: string, project: ProjectModel, name: string);
 }

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

@@ -24,9 +24,11 @@ export class EnvironmentModel {
     project;
     featureStates = [];
     identityOverrides = [];
-    constructor(id, apiKey, project) {
+    name;
+    constructor(id, apiKey, project, name) {
         this.id = id;
         this.apiKey = apiKey;
         this.project = project;
+        this.name = name;
     }
 }

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

@@ -5,7 +5,7 @@ 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);
+    const environmentModel = new EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project, environmentJSON.name);
     environmentModel.featureStates = featureStates;
     if (!!environmentJSON.identity_overrides) {
         environmentModel.identityOverrides = environmentJSON.identity_overrides.map((identityData) => buildIdentityModel(identityData));

package/build/esm/flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.d.ts

@@ -0,0 +1,230 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+/**
+ * Unique environment key. May be used for selecting a value for a multivariate feature, or for % split segmentation.
+ */
+export type Key = string;
+/**
+ * An environment's human-readable name.
+ */
+export type Name = string;
+/**
+ * A unique identifier for an identity as displayed in the Flagsmith UI.
+ */
+export type Identifier = string;
+/**
+ * Key used when selecting a value for a multivariate feature, or for % split segmentation. Set to an internal identifier or a composite value based on the environment key and identifier, depending on Flagsmith implementation.
+ */
+export type Key1 = string;
+/**
+ * Unique segment key used for % split segmentation.
+ */
+export type Key2 = string;
+/**
+ * The name of the segment.
+ */
+export type Name1 = string;
+/**
+ * Segment rule type. Represents a logical quantifier for the conditions and sub-rules.
+ */
+export type Type = 'ALL' | 'ANY' | 'NONE';
+export type SegmentCondition = SegmentCondition1 | InSegmentCondition;
+/**
+ * A reference to the identity trait or value in the evaluation context.
+ */
+export type Property = string;
+/**
+ * The operator to use for evaluating the condition.
+ */
+export type Operator = 'EQUAL' | 'GREATER_THAN' | 'LESS_THAN' | 'LESS_THAN_INCLUSIVE' | 'CONTAINS' | 'GREATER_THAN_INCLUSIVE' | 'NOT_CONTAINS' | 'NOT_EQUAL' | 'REGEX' | 'PERCENTAGE_SPLIT' | 'MODULO' | 'IS_SET' | 'IS_NOT_SET' | 'IN';
+/**
+ * The value to compare against the trait or context value.
+ */
+export type Value = string;
+/**
+ * A reference to the identity trait or value in the evaluation context.
+ */
+export type Property1 = string;
+/**
+ * The operator to use for evaluating the condition.
+ */
+export type Operator1 = 'IN';
+/**
+ * The values to compare against the trait or context value.
+ */
+export type Value1 = string[];
+/**
+ * Conditions that must be met for the rule to apply.
+ */
+export type Conditions = SegmentCondition[];
+/**
+ * Sub-rules nested within the segment rule.
+ */
+export type SubRules = SegmentRule[];
+/**
+ * Rules that define the segment.
+ */
+export type Rules = SegmentRule[];
+/**
+ * Unique feature key used when selecting a variant if the feature is multivariate. Set to an internal identifier or a UUID, depending on Flagsmith implementation.
+ */
+export type Key3 = string;
+/**
+ * Feature name.
+ */
+export type Name2 = string;
+/**
+ * Indicates whether the feature is enabled in the environment.
+ */
+export type Enabled = boolean;
+/**
+ * A default environment value for the feature. If the feature is multivariate, this will be the control value.
+ */
+export type Value2 = string | number | boolean | null;
+/**
+ * The value of the feature.
+ */
+export type Value3 = string | number | boolean | null;
+/**
+ * The weight of the feature value variant, as a percentage number (i.e. 100.0).
+ */
+export type Weight = number;
+/**
+ * Priority of the feature flag variant. Lower values indicate a higher priority when multiple variants apply to the same context key.
+ */
+export type VariantPriority = number;
+/**
+ * An array of environment default values associated with the feature. Empty for standard features, or contains multiple values for multivariate features.
+ */
+export type Variants = FeatureValue[];
+/**
+ * Priority of the feature context. Lower values indicate a higher priority when multiple contexts apply to the same feature.
+ */
+export type FeaturePriority = number;
+/**
+ * Feature overrides for the segment.
+ */
+export type Overrides = FeatureContext[];
+/**
+ * A context object containing the necessary information to evaluate Flagsmith feature flags.
+ */
+export interface EvaluationContext {
+    environment: EnvironmentContext;
+    /**
+     * Identity context used for identity-based evaluation.
+     */
+    identity?: IdentityContext | null;
+    segments?: Segments;
+    features?: Features;
+    [k: string]: unknown;
+}
+/**
+ * Environment context required for evaluation.
+ */
+export interface EnvironmentContext {
+    key: Key;
+    name: Name;
+    [k: string]: unknown;
+}
+/**
+ * Represents an identity context for feature flag evaluation.
+ */
+export interface IdentityContext {
+    identifier: Identifier;
+    key?: Key1;
+    traits?: Traits;
+    [k: string]: unknown;
+}
+/**
+ * A map of traits associated with the identity, where the key is the trait name and the value is the trait value.
+ */
+export interface Traits {
+    [k: string]: string | number | boolean | null;
+}
+/**
+ * Segments applicable to the evaluation context.
+ */
+export interface Segments {
+    [k: string]: SegmentContext;
+}
+/**
+ * Represents a segment context for feature flag evaluation.
+ */
+export interface SegmentContext {
+    key: Key2;
+    name: Name1;
+    rules: Rules;
+    overrides?: Overrides;
+    metadata?: SegmentMetadata;
+    [k: string]: unknown;
+}
+/**
+ * Represents a rule within a segment for feature flag evaluation.
+ */
+export interface SegmentRule {
+    type: Type;
+    conditions?: Conditions;
+    rules?: SubRules;
+    [k: string]: unknown;
+}
+/**
+ * Represents a condition within a segment rule for feature flag evaluation.
+ */
+export interface SegmentCondition1 {
+    property: Property;
+    operator: Operator;
+    value: Value;
+    [k: string]: unknown;
+}
+/**
+ * Represents an IN condition within a segment rule for feature flag evaluation.
+ */
+export interface InSegmentCondition {
+    property: Property1;
+    operator: Operator1;
+    value: Value1;
+    [k: string]: unknown;
+}
+/**
+ * Represents a feature context for feature flag evaluation.
+ */
+export interface FeatureContext {
+    key: Key3;
+    name: Name2;
+    enabled: Enabled;
+    value: Value2;
+    variants?: Variants;
+    priority?: FeaturePriority;
+    metadata?: FeatureMetadata;
+    [k: string]: unknown;
+}
+/**
+ * Represents a multivariate value for a feature flag.
+ */
+export interface FeatureValue {
+    value: Value3;
+    weight: Weight;
+    priority: VariantPriority;
+    [k: string]: unknown;
+}
+/**
+ * Additional metadata associated with the feature.
+ */
+export interface FeatureMetadata {
+    [k: string]: unknown;
+}
+/**
+ * Additional metadata associated with the segment.
+ */
+export interface SegmentMetadata {
+    [k: string]: unknown;
+}
+/**
+ * Features to be evaluated in the context.
+ */
+export interface Features {
+    [k: string]: FeatureContext;
+}

package/build/esm/flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.js

@@ -0,0 +1,7 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+export {};