flagsmith-nodejs 3.3.3 → 4.0.0-beta.1

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

@@ -0,0 +1,36 @@
+// Segment Rules
+export const ALL_RULE = 'ALL';
+export const ANY_RULE = 'ANY';
+export const NONE_RULE = 'NONE';
+export const RULE_TYPES = [ALL_RULE, ANY_RULE, NONE_RULE];
+// Segment Condition Operators
+export const EQUAL = 'EQUAL';
+export const GREATER_THAN = 'GREATER_THAN';
+export const LESS_THAN = 'LESS_THAN';
+export const LESS_THAN_INCLUSIVE = 'LESS_THAN_INCLUSIVE';
+export const CONTAINS = 'CONTAINS';
+export const GREATER_THAN_INCLUSIVE = 'GREATER_THAN_INCLUSIVE';
+export const NOT_CONTAINS = 'NOT_CONTAINS';
+export const NOT_EQUAL = 'NOT_EQUAL';
+export const REGEX = 'REGEX';
+export const PERCENTAGE_SPLIT = 'PERCENTAGE_SPLIT';
+export const IS_SET = 'IS_SET';
+export const IS_NOT_SET = 'IS_NOT_SET';
+export const MODULO = 'MODULO';
+export const IN = 'IN';
+export const CONDITION_OPERATORS = {
+    EQUAL,
+    GREATER_THAN,
+    LESS_THAN,
+    LESS_THAN_INCLUSIVE,
+    CONTAINS,
+    GREATER_THAN_INCLUSIVE,
+    NOT_CONTAINS,
+    NOT_EQUAL,
+    REGEX,
+    PERCENTAGE_SPLIT,
+    IS_SET,
+    IS_NOT_SET,
+    MODULO,
+    IN
+};

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

@@ -0,0 +1,7 @@
+import { EnvironmentModel } from '../environments/models.js';
+import { IdentityModel } from '../identities/models.js';
+import { TraitModel } from '../identities/traits/models.js';
+import { SegmentConditionModel, SegmentModel } from './models.js';
+export declare function getIdentitySegments(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): SegmentModel[];
+export declare function evaluateIdentityInSegment(identity: IdentityModel, segment: SegmentModel, overrideTraits?: TraitModel[]): boolean;
+export declare function traitsMatchSegmentCondition(identityTraits: TraitModel[], condition: SegmentConditionModel, segmentId: number | string, identityId: number | string): boolean;

package/build/esm/flagsmith-engine/segments/evaluators.js

@@ -0,0 +1,31 @@
+import { getHashedPercentateForObjIds } from '../utils/hashing/index.js';
+import { PERCENTAGE_SPLIT, IS_SET, IS_NOT_SET } from './constants.js';
+export function getIdentitySegments(environment, identity, overrideTraits) {
+    return environment.project.segments.filter(segment => evaluateIdentityInSegment(identity, segment, overrideTraits));
+}
+export function evaluateIdentityInSegment(identity, segment, overrideTraits) {
+    return (segment.rules.length > 0 &&
+        segment.rules.filter(rule => traitsMatchSegmentRule(overrideTraits || identity.identityTraits, rule, segment.id, identity.djangoID || identity.compositeKey)).length === segment.rules.length);
+}
+function traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId) {
+    const matchesConditions = rule.conditions.length > 0
+        ? rule.matchingFunction()(rule.conditions.map(condition => traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId)))
+        : true;
+    return (matchesConditions &&
+        rule.rules.filter(rule => traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId)).length === rule.rules.length);
+}
+export function traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId) {
+    if (condition.operator == PERCENTAGE_SPLIT) {
+        var hashedPercentage = getHashedPercentateForObjIds([segmentId, identityId]);
+        return hashedPercentage <= parseFloat(String(condition.value));
+    }
+    const traits = identityTraits.filter(t => t.traitKey === condition.property_);
+    const trait = traits.length > 0 ? traits[0] : undefined;
+    if (condition.operator === IS_SET) {
+        return !!trait;
+    }
+    else if (condition.operator === IS_NOT_SET) {
+        return trait == undefined;
+    }
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}

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

@@ -0,0 +1,37 @@
+import { FeatureStateModel } from '../features/models.js';
+export declare const all: (iterable: Array<any>) => boolean;
+export declare const any: (iterable: Array<any>) => boolean;
+export declare const matchingFunctions: {
+    [x: string]: (thisValue: any, otherValue: any) => any;
+};
+export declare const semverMatchingFunction: {
+    [x: string]: ((thisValue: any, otherValue: any) => any) | ((thisValue: any, otherValue: any) => boolean);
+};
+export declare const getMatchingFunctions: (semver: boolean) => {
+    [x: string]: (thisValue: any, otherValue: any) => any;
+};
+export declare class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS: {
+        [key: string]: string;
+    };
+    operator: string;
+    value: string | null | undefined;
+    property_: string | null | undefined;
+    constructor(operator: string, value?: string | null | undefined, property?: string | null | undefined);
+    matchesTraitValue(traitValue: any): any;
+}
+export declare class SegmentRuleModel {
+    type: string;
+    rules: SegmentRuleModel[];
+    conditions: SegmentConditionModel[];
+    constructor(type: string);
+    static none(iterable: Array<any>): boolean;
+    matchingFunction(): CallableFunction;
+}
+export declare class SegmentModel {
+    id: number;
+    name: string;
+    rules: SegmentRuleModel[];
+    featureStates: FeatureStateModel[];
+    constructor(id: number, name: string);
+}

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

@@ -0,0 +1,102 @@
+import semver from 'semver';
+import { getCastingFunction as getCastingFunction } from '../utils/index.js';
+import { ALL_RULE, ANY_RULE, NONE_RULE, NOT_CONTAINS, REGEX, MODULO, IN, CONDITION_OPERATORS } from './constants.js';
+import { isSemver } from './util.js';
+export const all = (iterable) => iterable.filter(e => !!e).length === iterable.length;
+export const any = (iterable) => iterable.filter(e => !!e).length > 0;
+export const matchingFunctions = {
+    [CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => thisValue == otherValue,
+    [CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => otherValue > thisValue,
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => otherValue >= thisValue,
+    [CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => thisValue > otherValue,
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => thisValue >= otherValue,
+    [CONDITION_OPERATORS.NOT_EQUAL]: (thisValue, otherValue) => thisValue != otherValue,
+    [CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => !!otherValue && otherValue.includes(thisValue),
+};
+export const semverMatchingFunction = {
+    ...matchingFunctions,
+    [CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => semver.eq(thisValue, otherValue),
+    [CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => semver.gt(otherValue, thisValue),
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => semver.gte(otherValue, thisValue),
+    [CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => semver.gt(thisValue, otherValue),
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => semver.gte(thisValue, otherValue),
+};
+export const getMatchingFunctions = (semver) => (semver ? semverMatchingFunction : matchingFunctions);
+export class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS = {
+        [NOT_CONTAINS]: 'evaluateNotContains',
+        [REGEX]: 'evaluateRegex',
+        [MODULO]: 'evaluateModulo',
+        [IN]: 'evaluateIn'
+    };
+    operator;
+    value;
+    property_;
+    constructor(operator, value, property) {
+        this.operator = operator;
+        this.value = value;
+        this.property_ = property;
+    }
+    matchesTraitValue(traitValue) {
+        const evaluators = {
+            evaluateNotContains: (traitValue) => {
+                return typeof traitValue == "string" &&
+                    !!this.value &&
+                    !traitValue.includes(this.value?.toString());
+            },
+            evaluateRegex: (traitValue) => {
+                return !!this.value && !!traitValue?.toString().match(new RegExp(this.value));
+            },
+            evaluateModulo: (traitValue) => {
+                if (isNaN(parseFloat(traitValue)) || !this.value) {
+                    return false;
+                }
+                const parts = (this.value).split("|");
+                const [divisor, reminder] = [parseFloat(parts[0]), parseFloat(parts[1])];
+                return traitValue % divisor === reminder;
+            },
+            evaluateIn: (traitValue) => {
+                return this.value?.split(',').includes(traitValue.toString());
+            },
+        };
+        // TODO: move this logic to the evaluator module
+        if (this.EXCEPTION_OPERATOR_METHODS[this.operator]) {
+            const evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
+            return evaluatorFunction(traitValue);
+        }
+        const defaultFunction = (x, y) => false;
+        const matchingFunctionSet = getMatchingFunctions(isSemver(this.value));
+        const matchingFunction = matchingFunctionSet[this.operator] || defaultFunction;
+        const traitType = isSemver(this.value) ? 'semver' : typeof traitValue;
+        const castToTypeOfTraitValue = getCastingFunction(traitType);
+        return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
+    }
+}
+export class SegmentRuleModel {
+    type;
+    rules = [];
+    conditions = [];
+    constructor(type) {
+        this.type = type;
+    }
+    static none(iterable) {
+        return iterable.filter(e => !!e).length === 0;
+    }
+    matchingFunction() {
+        return {
+            [ANY_RULE]: any,
+            [ALL_RULE]: all,
+            [NONE_RULE]: SegmentRuleModel.none
+        }[this.type];
+    }
+}
+export class SegmentModel {
+    id;
+    name;
+    rules = [];
+    featureStates = [];
+    constructor(id, name) {
+        this.id = id;
+        this.name = name;
+    }
+}

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

@@ -0,0 +1,6 @@
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models.js';
+export declare function buildSegmentConditionModel(segmentConditionJSON: any): SegmentConditionModel;
+export declare function buildSegmentRuleModel(ruleModelJSON: any): SegmentRuleModel;
+export declare function buildSegmentModel(segmentModelJSON: any): SegmentModel;
+export declare function isSemver(value: any): boolean;
+export declare function removeSemverSuffix(value: string): string;

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

@@ -0,0 +1,23 @@
+import { buildFeatureStateModel } from '../features/util.js';
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models.js';
+export function buildSegmentConditionModel(segmentConditionJSON) {
+    return new SegmentConditionModel(segmentConditionJSON.operator, segmentConditionJSON.value, segmentConditionJSON.property_);
+}
+export function buildSegmentRuleModel(ruleModelJSON) {
+    const ruleModel = new SegmentRuleModel(ruleModelJSON.type);
+    ruleModel.rules = ruleModelJSON.rules.map((r) => buildSegmentRuleModel(r));
+    ruleModel.conditions = ruleModelJSON.conditions.map((c) => buildSegmentConditionModel(c));
+    return ruleModel;
+}
+export function buildSegmentModel(segmentModelJSON) {
+    const model = new SegmentModel(segmentModelJSON.id, segmentModelJSON.name);
+    model.featureStates = segmentModelJSON['feature_states'].map((fs) => buildFeatureStateModel(fs));
+    model.rules = segmentModelJSON['rules'].map((r) => buildSegmentRuleModel(r));
+    return model;
+}
+export function isSemver(value) {
+    return typeof value == 'string' && value.endsWith(':semver');
+}
+export function removeSemverSuffix(value) {
+    return value.replace(':semver', '');
+}

package/build/esm/flagsmith-engine/utils/collections.d.ts

@@ -0,0 +1,3 @@
+import { FeatureStateModel } from '../features/models.js';
+export declare class IdentityFeaturesList extends Array<FeatureStateModel> {
+}

package/build/esm/flagsmith-engine/utils/collections.js

@@ -0,0 +1,2 @@
+export class IdentityFeaturesList extends Array {
+}

package/build/esm/flagsmith-engine/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class FeatureStateNotFound extends Error {
+}

package/build/esm/flagsmith-engine/utils/errors.js

@@ -0,0 +1,2 @@
+export class FeatureStateNotFound extends Error {
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @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;

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

@@ -0,0 +1,50 @@
+import md5 from 'md5';
+import bigInt from 'big-integer';
+const makeRepeated = (arr, repeats) => Array.from({ length: repeats }, () => arr).flat();
+// https://stackoverflow.com/questions/12532871/how-to-convert-a-very-large-hex-number-to-decimal-in-javascript
+function h2d(s) {
+    function add(x, y) {
+        var c = 0, r = [];
+        var x = x.split('').map(Number);
+        var y = y.split('').map(Number);
+        while (x.length || y.length) {
+            var s = (x.pop() || 0) + (y.pop() || 0) + c;
+            r.unshift(s < 10 ? s : s - 10);
+            c = s < 10 ? 0 : 1;
+        }
+        if (c)
+            r.unshift(c);
+        return r.join('');
+    }
+    var dec = '0';
+    s.split('').forEach(function (chr) {
+        var n = parseInt(chr, 16);
+        for (var t = 8; t; t >>= 1) {
+            dec = add(dec, dec);
+            if (n & t)
+                dec = add(dec, '1');
+        }
+    });
+    return dec;
+}
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @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 function getHashedPercentateForObjIds(objectIds, iterations = 1) {
+    let toHash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = md5(toHash);
+    const hashedInt = bigInt(h2d(hashedValue));
+    const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
+    if (value === 100) {
+        /* istanbul ignore next */
+        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+    }
+    return value;
+}

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

@@ -0,0 +1 @@
+export declare function getCastingFunction(traitType: 'boolean' | 'string' | 'number' | 'semver' | any): CallableFunction;

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

@@ -0,0 +1,13 @@
+import { removeSemverSuffix } from "../segments/util.js";
+export function getCastingFunction(traitType) {
+    switch (traitType) {
+        case 'boolean':
+            return (x) => !['False', 'false'].includes(x);
+        case 'number':
+            return (x) => parseFloat(x);
+        case 'semver':
+            return (x) => removeSemverSuffix(x);
+        default:
+            return (x) => String(x);
+    }
+}

package/build/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { AnalyticsProcessor, FlagsmithAPIError, FlagsmithClientError, EnvironmentDataPollingManager, FlagsmithCache, DefaultFlag, Flags, default } from './sdk/index.js';
+export { FlagsmithConfig } from './sdk/types.js';
+export { EnvironmentModel, FeatureStateModel, IdentityModel, TraitModel, SegmentModel, OrganisationModel } from './flagsmith-engine/index.js';

package/build/esm/index.js

@@ -0,0 +1,4 @@
+import Flagsmith from "./sdk/index.js";
+export { AnalyticsProcessor, FlagsmithAPIError, FlagsmithClientError, EnvironmentDataPollingManager, DefaultFlag, Flags, default } from './sdk/index.js';
+export { EnvironmentModel, FeatureStateModel, IdentityModel, TraitModel, SegmentModel, OrganisationModel } from './flagsmith-engine/index.js';
+module.exports = Flagsmith;

package/build/esm/sdk/analytics.d.ts

@@ -0,0 +1,35 @@
+import { Logger } from 'pino';
+import { Fetch } from "./types.js";
+export declare class AnalyticsProcessor {
+    private analyticsEndpoint;
+    private environmentKey;
+    private lastFlushed;
+    analyticsData: {
+        [key: string]: any;
+    };
+    private requestTimeoutMs;
+    private logger;
+    private currentFlush;
+    private customFetch;
+    /**
+     * AnalyticsProcessor is used to track how often individual Flags are evaluated within
+     * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+     *
+     * @param data.environmentKey environment key obtained from the Flagsmith UI
+     * @param data.baseApiUrl base api url to override when using self hosted version
+     * @param data.requestTimeoutMs used to tell requests to stop waiting for a response after a
+            given number of milliseconds
+     */
+    constructor(data: {
+        environmentKey: string;
+        baseApiUrl: string;
+        requestTimeoutMs?: number;
+        logger?: Logger;
+        fetch?: Fetch;
+    });
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    flush(): Promise<void>;
+    trackFeature(featureName: string): void;
+}

package/build/esm/sdk/analytics.js

@@ -0,0 +1,69 @@
+import { pino } from 'pino';
+const ANALYTICS_ENDPOINT = 'analytics/flags/';
+// Used to control how often we send data(in seconds)
+const ANALYTICS_TIMER = 10;
+export class AnalyticsProcessor {
+    analyticsEndpoint;
+    environmentKey;
+    lastFlushed;
+    analyticsData;
+    requestTimeoutMs = 3000;
+    logger;
+    currentFlush;
+    customFetch;
+    /**
+     * AnalyticsProcessor is used to track how often individual Flags are evaluated within
+     * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+     *
+     * @param data.environmentKey environment key obtained from the Flagsmith UI
+     * @param data.baseApiUrl base api url to override when using self hosted version
+     * @param data.requestTimeoutMs used to tell requests to stop waiting for a response after a
+            given number of milliseconds
+     */
+    constructor(data) {
+        this.analyticsEndpoint = data.baseApiUrl + ANALYTICS_ENDPOINT;
+        this.environmentKey = data.environmentKey;
+        this.lastFlushed = Date.now();
+        this.analyticsData = {};
+        this.requestTimeoutMs = data.requestTimeoutMs || this.requestTimeoutMs;
+        this.logger = data.logger || pino();
+        this.customFetch = data.fetch ?? fetch;
+    }
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    async flush() {
+        if (this.currentFlush || !Object.keys(this.analyticsData).length) {
+            return;
+        }
+        try {
+            this.currentFlush = this.customFetch(this.analyticsEndpoint, {
+                method: 'POST',
+                body: JSON.stringify(this.analyticsData),
+                signal: AbortSignal.timeout(this.requestTimeoutMs),
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Environment-Key': this.environmentKey
+                }
+            });
+            await this.currentFlush;
+        }
+        catch (error) {
+            // We don't want failing to write analytics to cause any exceptions in the main
+            // thread so we just swallow them here.
+            this.logger.warn('Failed to post analytics to Flagsmith API. Not clearing data, will retry.');
+            return;
+        }
+        finally {
+            this.currentFlush = undefined;
+        }
+        this.analyticsData = {};
+        this.lastFlushed = Date.now();
+    }
+    trackFeature(featureName) {
+        this.analyticsData[featureName] = (this.analyticsData[featureName] || 0) + 1;
+        if (Date.now() - this.lastFlushed > ANALYTICS_TIMER * 1000) {
+            this.flush();
+        }
+    }
+}

package/build/esm/sdk/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class FlagsmithClientError extends Error {
+}
+export declare class FlagsmithAPIError extends Error {
+}

package/build/esm/sdk/errors.js

@@ -0,0 +1,4 @@
+export class FlagsmithClientError extends Error {
+}
+export class FlagsmithAPIError extends Error {
+}

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

@@ -0,0 +1,131 @@
+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 { FlagsmithConfig, FlagsmithTraitValue, ITraitConfig } from './types.js';
+export { AnalyticsProcessor } from './analytics.js';
+export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
+export { DefaultFlag, Flags } from './models.js';
+export { EnvironmentDataPollingManager } from './polling_manager.js';
+export { FlagsmithCache, FlagsmithConfig } from './types.js';
+export declare class Flagsmith {
+    environmentKey?: string;
+    apiUrl?: string;
+    customHeaders?: {
+        [key: string]: any;
+    };
+    agent?: Dispatcher;
+    requestTimeoutMs?: number;
+    enableLocalEvaluation?: boolean;
+    environmentRefreshIntervalSeconds: number;
+    retries?: number;
+    enableAnalytics: boolean;
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    environmentFlagsUrl?: string;
+    identitiesUrl?: string;
+    environmentUrl?: string;
+    environmentDataPollingManager?: EnvironmentDataPollingManager;
+    environment: EnvironmentModel;
+    offlineMode: boolean;
+    offlineHandler?: BaseOfflineHandler;
+    identitiesWithOverridesByIdentifier?: Map<string, IdentityModel>;
+    private cache?;
+    private onEnvironmentChange?;
+    private analyticsProcessor?;
+    private logger;
+    private customFetch;
+    /**
+     * A Flagsmith client.
+     *
+     * Provides an interface for interacting with the Flagsmith http API.
+     * Basic Usage::
+     *
+     * import flagsmith from Flagsmith
+     * const flagsmith = new Flagsmith({environmentKey: '<your API key>'});
+     * const environmentFlags = flagsmith.getEnvironmentFlags();
+     * const featureEnabled = environmentFlags.isFeatureEnabled('foo');
+     * const identityFlags = flagsmith.getIdentityFlags('identifier', {'foo': 'bar'});
+     * const featureEnabledForIdentity = identityFlags.isFeatureEnabled("foo")
+     *
+     *  @param {string} data.environmentKey: The environment key obtained from Flagsmith interface
+     *      Required unless offlineMode is True.
+        @param {string} data.apiUrl: Override the URL of the Flagsmith API to communicate with
+        @param  data.customHeaders: Additional headers to add to requests made to the
+            Flagsmith API
+        @param {number} data.requestTimeoutSeconds: Number of seconds to wait for a request to
+            complete before terminating the request
+        @param {boolean} data.enableLocalEvaluation: Enables local evaluation of flags
+        @param {number} data.environmentRefreshIntervalSeconds: If using local evaluation,
+            specify the interval period between refreshes of local environment data
+        @param {number} data.retries: a urllib3.Retry object to use on all http requests to the
+            Flagsmith API
+        @param {boolean} data.enableAnalytics: if enabled, sends additional requests to the Flagsmith
+            API to power flag analytics charts
+        @param data.defaultFlagHandler: callable which will be used in the case where
+            flags cannot be retrieved from the API or a non-existent feature is
+            requested
+        @param data.logger: an instance of the pino Logger class to use for logging
+        @param {boolean} data.offlineMode: sets the client into offline mode. Relies on offlineHandler for
+            evaluating flags.
+        @param {BaseOfflineHandler} data.offlineHandler: provide a handler for offline logic. Used to get environment
+            document from another source when in offlineMode. Works in place of
+            defaultFlagHandler if offlineMode is not set and using remote evaluation.
+    */
+    constructor(data?: FlagsmithConfig);
+    /**
+     * Get all the default for flags for the current environment.
+     *
+     * @returns Flags object holding all the flags for the current environment.
+     */
+    getEnvironmentFlags(): Promise<Flags>;
+    /**
+     * Get all the flags for the current environment for a given identity. Will also
+        upsert all traits to the Flagsmith API for future evaluations. Providing a
+        trait with a value of None will remove the trait from the identity if it exists.
+     *
+     * @param  {string} identifier a unique identifier for the identity in the current
+            environment, e.g. email address, username, uuid
+     * @param  {{[key:string]:any | ITraitConfig}} traits? a dictionary of traits to add / update on the identity in
+            Flagsmith, e.g. {"num_orders": 10} or {age: {value: 30, transient: true}}
+     * @returns Flags object holding all the flags for the given identity.
+     */
+    getIdentityFlags(identifier: string, traits?: {
+        [key: string]: FlagsmithTraitValue | ITraitConfig;
+    }, transient?: boolean): Promise<Flags>;
+    /**
+     * Get the segments for the current environment for a given identity. Will also
+        upsert all traits to the Flagsmith API for future evaluations. Providing a
+        trait with a value of None will remove the trait from the identity if it exists.
+     *
+     * @param  {string} identifier a unique identifier for the identity in the current
+            environment, e.g. email address, username, uuid
+     * @param  {{[key:string]:any}} traits? a dictionary of traits to add / update on the identity in
+            Flagsmith, e.g. {"num_orders": 10}
+     * @returns Segments that the given identity belongs to.
+     */
+    getIdentitySegments(identifier: string, traits?: {
+        [key: string]: any;
+    }): Promise<SegmentModel[]>;
+    /**
+     * Updates the environment state for local flag evaluation.
+     * Sets a local promise to prevent race conditions in getIdentityFlags / getIdentitySegments.
+     * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
+     */
+    updateEnvironment(): Promise<void>;
+    close(): Promise<void>;
+    private getJSONResponse;
+    /**
+     * This promise ensures that the environment is retrieved before attempting to locally evaluate.
+     */
+    private environmentPromise;
+    private getEnvironmentFromApi;
+    private getEnvironmentFlagsFromDocument;
+    private getIdentityFlagsFromDocument;
+    private getEnvironmentFlagsFromApi;
+    private getIdentityFlagsFromApi;
+    private getIdentityModel;
+}
+export default Flagsmith;