flagsmith-nodejs 3.3.2 → 4.0.0-beta.1

package/build/esm/sdk/index.js

@@ -0,0 +1,390 @@
+import { getEnvironmentFeatureStates, getIdentityFeatureStates } from '../flagsmith-engine/index.js';
+import { buildEnvironmentModel } from '../flagsmith-engine/environments/util.js';
+import { IdentityModel } from '../flagsmith-engine/index.js';
+import { TraitModel } from '../flagsmith-engine/index.js';
+import { AnalyticsProcessor } from './analytics.js';
+import { FlagsmithAPIError } from './errors.js';
+import { Flags } from './models.js';
+import { EnvironmentDataPollingManager } from './polling_manager.js';
+import { generateIdentitiesData, retryFetch } from './utils.js';
+import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators.js';
+import { pino } from 'pino';
+export { AnalyticsProcessor } from './analytics.js';
+export { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
+export { DefaultFlag, Flags } from './models.js';
+export { EnvironmentDataPollingManager } from './polling_manager.js';
+const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
+const DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
+export 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 || 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 EnvironmentDataPollingManager(this, this.environmentRefreshIntervalSeconds);
+                this.environmentDataPollingManager.start();
+                this.updateEnvironment();
+            }
+            this.analyticsProcessor = data.enableAnalytics
+                ? new 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 = 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 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 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 buildEnvironmentModel(environment_data);
+    }
+    async getEnvironmentFlagsFromDocument() {
+        const flags = Flags.fromFeatureStateModels({
+            featureStates: 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 = getIdentityFeatureStates(this.environment, identityModel);
+        const flags = 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 = 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 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 = generateIdentitiesData(identifier, traits, transient);
+            const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
+            const flags = 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 Flags({
+                    flags: {},
+                    defaultFlagHandler: this.defaultFlagHandler
+                });
+            }
+            throw e;
+        }
+    }
+    getIdentityModel(identifier, traits) {
+        const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
+        let identityWithOverrides = this.identitiesWithOverridesByIdentifier?.get(identifier);
+        if (identityWithOverrides) {
+            identityWithOverrides.updateTraits(traitModels);
+            return identityWithOverrides;
+        }
+        return new IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
+    }
+}
+export default Flagsmith;

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

@@ -0,0 +1,55 @@
+import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
+import { AnalyticsProcessor } from './analytics.js';
+export declare class BaseFlag {
+    enabled: boolean;
+    value: string | number | boolean | undefined;
+    isDefault: boolean;
+    constructor(value: string | number | boolean | undefined, enabled: boolean, isDefault: boolean);
+}
+export declare class DefaultFlag extends BaseFlag {
+    constructor(value: string | number | boolean | undefined, enabled: boolean);
+}
+export declare class Flag extends BaseFlag {
+    featureId: number;
+    featureName: string;
+    constructor(params: {
+        value: string | number | boolean | undefined;
+        enabled: boolean;
+        isDefault?: boolean;
+        featureId: number;
+        featureName: string;
+    });
+    static fromFeatureStateModel(fsm: FeatureStateModel, identityId: number | string | undefined): Flag;
+    static fromAPIFlag(flagData: any): Flag;
+}
+export declare class Flags {
+    flags: {
+        [key: string]: Flag;
+    };
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    analyticsProcessor?: AnalyticsProcessor;
+    constructor(data: {
+        flags: {
+            [key: string]: Flag;
+        };
+        defaultFlagHandler?: (v: string) => DefaultFlag;
+        analyticsProcessor?: AnalyticsProcessor;
+    });
+    static fromFeatureStateModels(data: {
+        featureStates: FeatureStateModel[];
+        analyticsProcessor?: AnalyticsProcessor;
+        defaultFlagHandler?: (f: string) => DefaultFlag;
+        identityID?: string | number;
+    }): Flags;
+    static fromAPIFlags(data: {
+        apiFlags: {
+            [key: string]: any;
+        }[];
+        analyticsProcessor?: AnalyticsProcessor;
+        defaultFlagHandler?: (v: string) => DefaultFlag;
+    }): Flags;
+    allFlags(): Flag[];
+    getFlag(featureName: string): BaseFlag;
+    getFeatureValue(featureName: string): any;
+    isFeatureEnabled(featureName: string): boolean;
+}

package/build/esm/sdk/models.js

@@ -0,0 +1,94 @@
+export class BaseFlag {
+    enabled;
+    value;
+    isDefault;
+    constructor(value, enabled, isDefault) {
+        this.value = value;
+        this.enabled = enabled;
+        this.isDefault = isDefault;
+    }
+}
+export class DefaultFlag extends BaseFlag {
+    constructor(value, enabled) {
+        super(value, enabled, true);
+    }
+}
+export 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']
+        });
+    }
+}
+export 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;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { EnvironmentModel } from '../flagsmith-engine/environments/models.js';
+export declare class BaseOfflineHandler {
+    getEnvironment(): EnvironmentModel;
+}
+export declare class LocalFileHandler extends BaseOfflineHandler {
+    environment: EnvironmentModel;
+    constructor(environment_document_path: string);
+    getEnvironment(): EnvironmentModel;
+}

package/build/esm/sdk/offline_handlers.js

@@ -0,0 +1,18 @@
+import * as fs from 'fs';
+import { buildEnvironmentModel } from '../flagsmith-engine/environments/util.js';
+export class BaseOfflineHandler {
+    getEnvironment() {
+        throw new Error('Not implemented');
+    }
+}
+export class LocalFileHandler extends BaseOfflineHandler {
+    environment;
+    constructor(environment_document_path) {
+        super();
+        const environment_document = fs.readFileSync(environment_document_path, 'utf8');
+        this.environment = buildEnvironmentModel(JSON.parse(environment_document));
+    }
+    getEnvironment() {
+        return this.environment;
+    }
+}

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

@@ -0,0 +1,9 @@
+import Flagsmith from './index.js';
+export declare class EnvironmentDataPollingManager {
+    private interval?;
+    private main;
+    private refreshIntervalSeconds;
+    constructor(main: Flagsmith, refreshIntervalSeconds: number);
+    start(): void;
+    stop(): void;
+}

package/build/esm/sdk/polling_manager.js

@@ -0,0 +1,25 @@
+export 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);
+    }
+}

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

@@ -0,0 +1,38 @@
+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>;
+    has(key: string): boolean | Promise<boolean>;
+    [key: string]: any;
+}
+export type Fetch = typeof fetch;
+export interface FlagsmithConfig {
+    environmentKey?: string;
+    apiUrl?: string;
+    agent?: Dispatcher;
+    fetch?: Fetch;
+    customHeaders?: {
+        [key: string]: any;
+    };
+    requestTimeoutSeconds?: number;
+    enableLocalEvaluation?: boolean;
+    environmentRefreshIntervalSeconds?: number;
+    retries?: number;
+    enableAnalytics?: boolean;
+    defaultFlagHandler?: (featureName: string) => DefaultFlag;
+    cache?: FlagsmithCache;
+    onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
+    logger?: Logger;
+    offlineMode?: boolean;
+    offlineHandler?: BaseOfflineHandler;
+}
+export interface ITraitConfig {
+    value: FlagsmithTraitValue;
+    transient?: boolean;
+}
+export declare type FlagsmithTraitValue = IFlagsmithValue;

package/build/esm/sdk/types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/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 {};