flagsmith-nodejs 3.3.3 → 4.0.0

package/build/cjs/sdk/index.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flagsmith = exports.EnvironmentDataPollingManager = exports.Flags = exports.DefaultFlag = 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 pino_1 = require("pino");
+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");
+Object.defineProperty(exports, "FlagsmithAPIError", { enumerable: true, get: function () { return errors_js_2.FlagsmithAPIError; } });
+Object.defineProperty(exports, "FlagsmithClientError", { enumerable: true, get: function () { return errors_js_2.FlagsmithClientError; } });
+var models_js_2 = require("./models.js");
+Object.defineProperty(exports, "DefaultFlag", { enumerable: true, get: function () { return models_js_2.DefaultFlag; } });
+Object.defineProperty(exports, "Flags", { enumerable: true, get: function () { return models_js_2.Flags; } });
+var polling_manager_js_2 = require("./polling_manager.js");
+Object.defineProperty(exports, "EnvironmentDataPollingManager", { enumerable: true, get: function () { return polling_manager_js_2.EnvironmentDataPollingManager; } });
+const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
+const DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
+class Flagsmith {
+    environmentKey = undefined;
+    apiUrl = undefined;
+    customHeaders;
+    agent;
+    requestTimeoutMs;
+    enableLocalEvaluation = false;
+    environmentRefreshIntervalSeconds = 60;
+    retries;
+    enableAnalytics = false;
+    defaultFlagHandler;
+    environmentFlagsUrl;
+    identitiesUrl;
+    environmentUrl;
+    environmentDataPollingManager;
+    environment;
+    offlineMode = false;
+    offlineHandler = undefined;
+    identitiesWithOverridesByIdentifier;
+    cache;
+    onEnvironmentChange;
+    analyticsProcessor;
+    logger;
+    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 = {}) {
+        // if (!data.offlineMode && !data.environmentKey) {
+        //     throw new Error('ValueError: environmentKey is required.');
+        // }
+        this.agent = data.agent;
+        this.customFetch = data.fetch ?? fetch;
+        this.environmentKey = data.environmentKey;
+        this.apiUrl = data.apiUrl || this.apiUrl;
+        this.customHeaders = data.customHeaders;
+        this.requestTimeoutMs =
+            1000 * (data.requestTimeoutSeconds ?? DEFAULT_REQUEST_TIMEOUT_SECONDS);
+        this.enableLocalEvaluation = data.enableLocalEvaluation;
+        this.environmentRefreshIntervalSeconds =
+            data.environmentRefreshIntervalSeconds || this.environmentRefreshIntervalSeconds;
+        this.retries = data.retries;
+        this.enableAnalytics = data.enableAnalytics || false;
+        this.defaultFlagHandler = data.defaultFlagHandler;
+        this.onEnvironmentChange = data.onEnvironmentChange;
+        this.logger = data.logger || (0, pino_1.pino)();
+        this.offlineMode = data.offlineMode || false;
+        this.offlineHandler = data.offlineHandler;
+        // argument validation
+        if (this.offlineMode && !this.offlineHandler) {
+            throw new Error('ValueError: offlineHandler must be provided to use offline mode.');
+        }
+        else if (this.defaultFlagHandler && this.offlineHandler) {
+            throw new Error('ValueError: Cannot use both defaultFlagHandler and offlineHandler.');
+        }
+        if (this.offlineHandler) {
+            this.environment = this.offlineHandler.getEnvironment();
+        }
+        if (!!data.cache) {
+            const missingMethods = ['has', 'get', 'set'].filter(method => data.cache && !data.cache[method]);
+            if (missingMethods.length > 0) {
+                throw new Error(`Please implement the following methods in your cache: ${missingMethods.join(', ')}`);
+            }
+            this.cache = data.cache;
+        }
+        if (!this.offlineMode) {
+            if (!this.environmentKey) {
+                throw new Error('ValueError: environmentKey is required.');
+            }
+            const apiUrl = data.apiUrl || DEFAULT_API_URL;
+            this.apiUrl = apiUrl.endsWith('/') ? apiUrl : `${apiUrl}/`;
+            this.environmentFlagsUrl = `${this.apiUrl}flags/`;
+            this.identitiesUrl = `${this.apiUrl}identities/`;
+            this.environmentUrl = `${this.apiUrl}environment-document/`;
+            if (this.enableLocalEvaluation) {
+                if (!this.environmentKey.startsWith('ser.')) {
+                    console.error('In order to use local evaluation, please generate a server key in the environment settings page.');
+                }
+                this.environmentDataPollingManager = new polling_manager_js_1.EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
+                this.environmentDataPollingManager.start();
+                this.updateEnvironment();
+            }
+            this.analyticsProcessor = data.enableAnalytics
+                ? new analytics_js_1.AnalyticsProcessor({
+                    environmentKey: this.environmentKey,
+                    baseApiUrl: this.apiUrl,
+                    requestTimeoutMs: this.requestTimeoutMs,
+                    logger: this.logger
+                })
+                : undefined;
+        }
+    }
+    /**
+     * Get all the default for flags for the current environment.
+     *
+     * @returns Flags object holding all the flags for the current environment.
+     */
+    async getEnvironmentFlags() {
+        const cachedItem = !!this.cache && (await this.cache.get(`flags`));
+        if (!!cachedItem) {
+            return cachedItem;
+        }
+        if (this.enableLocalEvaluation && !this.offlineMode) {
+            return new Promise((resolve, reject) => this.environmentPromise.then(() => {
+                resolve(this.getEnvironmentFlagsFromDocument());
+            }).catch(e => reject(e)));
+        }
+        if (this.environment) {
+            return this.getEnvironmentFlagsFromDocument();
+        }
+        return this.getEnvironmentFlagsFromApi();
+    }
+    /**
+     * 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.
+     */
+    async getIdentityFlags(identifier, traits, transient = false) {
+        if (!identifier) {
+            throw new Error('`identifier` argument is missing or invalid.');
+        }
+        const cachedItem = !!this.cache && (await this.cache.get(`flags-${identifier}`));
+        if (!!cachedItem) {
+            return cachedItem;
+        }
+        traits = traits || {};
+        if (this.enableLocalEvaluation) {
+            return new Promise((resolve, reject) => this.environmentPromise.then(() => {
+                resolve(this.getIdentityFlagsFromDocument(identifier, traits || {}));
+            }).catch(e => reject(e)));
+        }
+        if (this.offlineMode) {
+            return this.getIdentityFlagsFromDocument(identifier, traits || {});
+        }
+        return this.getIdentityFlagsFromApi(identifier, traits, transient);
+    }
+    /**
+     * 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, traits) {
+        if (!identifier) {
+            throw new Error('`identifier` argument is missing or invalid.');
+        }
+        traits = traits || {};
+        if (this.enableLocalEvaluation) {
+            return new Promise((resolve, reject) => {
+                return this.environmentPromise.then(() => {
+                    const identityModel = this.getIdentityModel(identifier, Object.keys(traits || {}).map(key => ({
+                        key,
+                        value: traits?.[key]
+                    })));
+                    const segments = (0, evaluators_js_1.getIdentitySegments)(this.environment, identityModel);
+                    return resolve(segments);
+                }).catch(e => reject(e));
+            });
+        }
+        console.error('This function is only permitted with local evaluation.');
+        return Promise.resolve([]);
+    }
+    /**
+     * 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.
+     */
+    async updateEnvironment() {
+        try {
+            const request = this.getEnvironmentFromApi();
+            if (!this.environmentPromise) {
+                this.environmentPromise = request.then(res => {
+                    this.environment = res;
+                });
+                await this.environmentPromise;
+            }
+            else {
+                this.environment = await request;
+            }
+            if (this.environment.identityOverrides?.length) {
+                this.identitiesWithOverridesByIdentifier = new Map(this.environment.identityOverrides.map(identity => [
+                    identity.identifier,
+                    identity
+                ]));
+            }
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(null, this.environment);
+            }
+        }
+        catch (e) {
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(e, this.environment);
+            }
+        }
+    }
+    async close() {
+        this.environmentDataPollingManager?.stop();
+    }
+    async getJSONResponse(url, method, body) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.environmentKey) {
+            headers['X-Environment-Key'] = this.environmentKey;
+        }
+        if (this.customHeaders) {
+            for (const [k, v] of Object.entries(this.customHeaders)) {
+                headers[k] = v;
+            }
+        }
+        const data = await (0, utils_js_1.retryFetch)(url, {
+            dispatcher: this.agent,
+            method: method,
+            body: JSON.stringify(body),
+            headers: headers
+        }, this.retries, this.requestTimeoutMs, this.customFetch);
+        if (data.status !== 200) {
+            throw new errors_js_1.FlagsmithAPIError(`Invalid request made to Flagsmith API. Response status code: ${data.status}`);
+        }
+        return data.json();
+    }
+    /**
+     * This promise ensures that the environment is retrieved before attempting to locally evaluate.
+     */
+    environmentPromise;
+    async getEnvironmentFromApi() {
+        if (!this.environmentUrl) {
+            throw new Error('`apiUrl` argument is missing or invalid.');
+        }
+        const environment_data = await this.getJSONResponse(this.environmentUrl, 'GET');
+        return (0, util_js_1.buildEnvironmentModel)(environment_data);
+    }
+    async getEnvironmentFlagsFromDocument() {
+        const flags = models_js_1.Flags.fromFeatureStateModels({
+            featureStates: (0, index_js_1.getEnvironmentFeatureStates)(this.environment),
+            analyticsProcessor: this.analyticsProcessor,
+            defaultFlagHandler: this.defaultFlagHandler
+        });
+        if (!!this.cache) {
+            await this.cache.set('flags', flags);
+        }
+        return flags;
+    }
+    async getIdentityFlagsFromDocument(identifier, traits) {
+        const identityModel = this.getIdentityModel(identifier, Object.keys(traits).map(key => ({
+            key,
+            value: traits[key]
+        })));
+        const featureStates = (0, index_js_1.getIdentityFeatureStates)(this.environment, identityModel);
+        const flags = models_js_1.Flags.fromFeatureStateModels({
+            featureStates: featureStates,
+            analyticsProcessor: this.analyticsProcessor,
+            defaultFlagHandler: this.defaultFlagHandler,
+            identityID: identityModel.djangoID || identityModel.compositeKey
+        });
+        if (!!this.cache) {
+            await this.cache.set(`flags-${identifier}`, flags);
+        }
+        return flags;
+    }
+    async getEnvironmentFlagsFromApi() {
+        if (!this.environmentFlagsUrl) {
+            throw new Error('`apiUrl` argument is missing or invalid.');
+        }
+        try {
+            const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
+            const flags = models_js_1.Flags.fromAPIFlags({
+                apiFlags: apiFlags,
+                analyticsProcessor: this.analyticsProcessor,
+                defaultFlagHandler: this.defaultFlagHandler
+            });
+            if (!!this.cache) {
+                await this.cache.set('flags', flags);
+            }
+            return flags;
+        }
+        catch (e) {
+            if (this.offlineHandler) {
+                return this.getEnvironmentFlagsFromDocument();
+            }
+            if (this.defaultFlagHandler) {
+                return new models_js_1.Flags({
+                    flags: {},
+                    defaultFlagHandler: this.defaultFlagHandler
+                });
+            }
+            throw e;
+        }
+    }
+    async getIdentityFlagsFromApi(identifier, traits, transient = false) {
+        if (!this.identitiesUrl) {
+            throw new Error('`apiUrl` argument is missing or invalid.');
+        }
+        try {
+            const data = (0, utils_js_1.generateIdentitiesData)(identifier, traits, transient);
+            const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
+            const flags = models_js_1.Flags.fromAPIFlags({
+                apiFlags: jsonResponse['flags'],
+                analyticsProcessor: this.analyticsProcessor,
+                defaultFlagHandler: this.defaultFlagHandler
+            });
+            if (!!this.cache) {
+                await this.cache.set(`flags-${identifier}`, flags);
+            }
+            return flags;
+        }
+        catch (e) {
+            if (this.offlineHandler) {
+                return this.getIdentityFlagsFromDocument(identifier, traits);
+            }
+            if (this.defaultFlagHandler) {
+                return new models_js_1.Flags({
+                    flags: {},
+                    defaultFlagHandler: this.defaultFlagHandler
+                });
+            }
+            throw e;
+        }
+    }
+    getIdentityModel(identifier, traits) {
+        const traitModels = traits.map(trait => new index_js_3.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, [], this.environment.apiKey, identifier);
+    }
+}
+exports.Flagsmith = Flagsmith;
+exports.default = Flagsmith;

package/build/{sdk → cjs/sdk}/models.d.ts

@@ -1,5 +1,5 @@
-import { FeatureStateModel } from '../flagsmith-engine/features/models';
-import { AnalyticsProcessor } from './analytics';
+import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
+import { AnalyticsProcessor } from './analytics.js';
 export declare class BaseFlag {
     enabled: boolean;
     value: string | number | boolean | undefined;

package/build/cjs/sdk/models.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flags = exports.Flag = exports.DefaultFlag = exports.BaseFlag = void 0;
+class BaseFlag {
+    enabled;
+    value;
+    isDefault;
+    constructor(value, enabled, isDefault) {
+        this.value = value;
+        this.enabled = enabled;
+        this.isDefault = isDefault;
+    }
+}
+exports.BaseFlag = BaseFlag;
+class DefaultFlag extends BaseFlag {
+    constructor(value, enabled) {
+        super(value, enabled, true);
+    }
+}
+exports.DefaultFlag = DefaultFlag;
+class Flag extends BaseFlag {
+    featureId;
+    featureName;
+    constructor(params) {
+        super(params.value, params.enabled, !!params.isDefault);
+        this.featureId = params.featureId;
+        this.featureName = params.featureName;
+    }
+    static fromFeatureStateModel(fsm, identityId) {
+        return new Flag({
+            value: fsm.getValue(identityId),
+            enabled: fsm.enabled,
+            featureId: fsm.feature.id,
+            featureName: fsm.feature.name
+        });
+    }
+    static fromAPIFlag(flagData) {
+        return new Flag({
+            enabled: flagData['enabled'],
+            value: flagData['feature_state_value'] || flagData['value'],
+            featureId: flagData['feature']['id'],
+            featureName: flagData['feature']['name']
+        });
+    }
+}
+exports.Flag = Flag;
+class Flags {
+    flags = {};
+    defaultFlagHandler;
+    analyticsProcessor;
+    constructor(data) {
+        this.flags = data.flags;
+        this.defaultFlagHandler = data.defaultFlagHandler;
+        this.analyticsProcessor = data.analyticsProcessor;
+    }
+    static fromFeatureStateModels(data) {
+        const flags = {};
+        for (const fs of data.featureStates) {
+            flags[fs.feature.name] = Flag.fromFeatureStateModel(fs, data.identityID);
+        }
+        return new Flags({
+            flags: flags,
+            defaultFlagHandler: data.defaultFlagHandler,
+            analyticsProcessor: data.analyticsProcessor
+        });
+    }
+    static fromAPIFlags(data) {
+        const flags = {};
+        for (const flagData of data.apiFlags) {
+            flags[flagData['feature']['name']] = Flag.fromAPIFlag(flagData);
+        }
+        return new Flags({
+            flags: flags,
+            defaultFlagHandler: data.defaultFlagHandler,
+            analyticsProcessor: data.analyticsProcessor
+        });
+    }
+    allFlags() {
+        return Object.values(this.flags);
+    }
+    getFlag(featureName) {
+        const flag = this.flags[featureName];
+        if (!flag) {
+            if (this.defaultFlagHandler) {
+                return this.defaultFlagHandler(featureName);
+            }
+            return { enabled: false, isDefault: true, value: undefined };
+        }
+        if (this.analyticsProcessor && flag.featureId) {
+            this.analyticsProcessor.trackFeature(flag.featureName);
+        }
+        return flag;
+    }
+    getFeatureValue(featureName) {
+        return this.getFlag(featureName).value;
+    }
+    isFeatureEnabled(featureName) {
+        return this.getFlag(featureName).enabled;
+    }
+}
+exports.Flags = Flags;

package/build/{sdk → cjs/sdk}/offline_handlers.d.ts

@@ -1,4 +1,4 @@
-import { EnvironmentModel } from '../flagsmith-engine/environments/models';
+import { EnvironmentModel } from '../flagsmith-engine/environments/models.js';
 export declare class BaseOfflineHandler {
     getEnvironment(): EnvironmentModel;
 }

package/build/cjs/sdk/offline_handlers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFileHandler = exports.BaseOfflineHandler = void 0;
+const fs = require("fs");
+const util_js_1 = require("../flagsmith-engine/environments/util.js");
+class BaseOfflineHandler {
+    getEnvironment() {
+        throw new Error('Not implemented');
+    }
+}
+exports.BaseOfflineHandler = BaseOfflineHandler;
+class LocalFileHandler extends BaseOfflineHandler {
+    environment;
+    constructor(environment_document_path) {
+        super();
+        const environment_document = fs.readFileSync(environment_document_path, 'utf8');
+        this.environment = (0, util_js_1.buildEnvironmentModel)(JSON.parse(environment_document));
+    }
+    getEnvironment() {
+        return this.environment;
+    }
+}
+exports.LocalFileHandler = LocalFileHandler;

package/build/{sdk → cjs/sdk}/polling_manager.d.ts

@@ -1,4 +1,4 @@
-import Flagsmith from '.';
+import Flagsmith from './index.js';
 export declare class EnvironmentDataPollingManager {
     private interval?;
     private main;

package/build/cjs/sdk/polling_manager.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentDataPollingManager = void 0;
+class EnvironmentDataPollingManager {
+    interval;
+    main;
+    refreshIntervalSeconds;
+    constructor(main, refreshIntervalSeconds) {
+        this.main = main;
+        this.refreshIntervalSeconds = refreshIntervalSeconds;
+    }
+    start() {
+        const updateEnvironment = () => {
+            if (this.interval)
+                clearInterval(this.interval);
+            this.interval = setInterval(async () => {
+                await this.main.updateEnvironment();
+            }, this.refreshIntervalSeconds * 1000);
+        };
+        updateEnvironment();
+    }
+    stop() {
+        if (!this.interval) {
+            return;
+        }
+        clearInterval(this.interval);
+    }
+}
+exports.EnvironmentDataPollingManager = EnvironmentDataPollingManager;

package/build/{sdk → cjs/sdk}/types.d.ts

@@ -1,18 +1,21 @@
-import { DefaultFlag, Flags } from "./models";
-import { EnvironmentModel } from "../flagsmith-engine";
-import { RequestInit } from "node-fetch";
-import { Logger } from "pino";
-import { BaseOfflineHandler } from "./offline_handlers";
+import { DefaultFlag, Flags } from './models.js';
+import { EnvironmentModel } from '../flagsmith-engine/index.js';
+import { Dispatcher } from 'undici-types';
+import { Logger } from 'pino';
+import { BaseOfflineHandler } from './offline_handlers.js';
+export type IFlagsmithValue<T = string | number | boolean | null> = T;
 export interface FlagsmithCache {
     get(key: string): Promise<Flags | undefined> | undefined;
-    set(key: string, value: Flags, ttl: string | number): boolean | Promise<boolean>;
+    set(key: string, value: Flags, ttl?: string | number): boolean | Promise<boolean>;
     has(key: string): boolean | Promise<boolean>;
     [key: string]: any;
 }
+export type Fetch = typeof fetch;
 export interface FlagsmithConfig {
     environmentKey?: string;
     apiUrl?: string;
-    agent?: RequestInit['agent'];
+    agent?: Dispatcher;
+    fetch?: Fetch;
     customHeaders?: {
         [key: string]: any;
     };
@@ -28,3 +31,8 @@ export interface FlagsmithConfig {
     offlineMode?: boolean;
     offlineHandler?: BaseOfflineHandler;
 }
+export interface ITraitConfig {
+    value: FlagsmithTraitValue;
+    transient?: boolean;
+}
+export declare type FlagsmithTraitValue = IFlagsmithValue;

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

@@ -0,0 +1,36 @@
+import { Fetch, FlagsmithTraitValue, ITraitConfig } from './types.js';
+import { Dispatcher } from "undici-types";
+type Traits = {
+    [key: string]: ITraitConfig | FlagsmithTraitValue;
+};
+export declare function isTraitConfig(traitValue: ITraitConfig | FlagsmithTraitValue): traitValue is ITraitConfig;
+export declare function generateIdentitiesData(identifier: string, traits: Traits, transient: boolean): {
+    identifier: string;
+    traits: ({
+        trait_key: string;
+        trait_value: string | number | boolean | null;
+        transient: boolean | undefined;
+    } | {
+        trait_key: string;
+        trait_value: string | number | boolean | null;
+        transient?: undefined;
+    })[];
+    transient: boolean;
+} | {
+    identifier: string;
+    traits: ({
+        trait_key: string;
+        trait_value: string | number | boolean | null;
+        transient: boolean | undefined;
+    } | {
+        trait_key: string;
+        trait_value: string | number | boolean | null;
+        transient?: undefined;
+    })[];
+    transient?: undefined;
+};
+export declare const delay: (ms: number) => Promise<unknown>;
+export declare const retryFetch: (url: string, fetchOptions: RequestInit & {
+    dispatcher?: Dispatcher;
+}, retries: number | undefined, timeoutMs: number | undefined, customFetch: Fetch) => Promise<Response>;
+export {};