@coframe/sdk 1.1.29 → 1.1.31

package/dist/pkg/server.cjs.js

@@ -22,6 +22,30 @@ function sanitizeUserContext(userContext) {
     return userContext;
 }
 
+function getGlobalScope() {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+}
+const generateUUID = () => {
+    var _a;
+    const cryptoObject = (_a = getGlobalScope()) === null || _a === void 0 ? void 0 : _a.crypto;
+    if (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID)
+        return cryptoObject.randomUUID();
+    return `${1e7}${ -1e3}${ -4e3}${ -8e3}${ -1e11}`.replace(/[018]/g, (c) => {
+        var _a, _b;
+        const randomValue = (_b = (_a = cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues) === null || _a === void 0 ? void 0 : _a.call(cryptoObject, new Uint8Array(1))[0]) !== null && _b !== void 0 ? _b : 0;
+        return (c ^
+            (randomValue & (15 >> (c / 4)))).toString(16);
+    });
+};
+
 async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext, previewVariantId, headers, referrer) {
     const payload = { projectId, currentUrl };
     if (referrer !== undefined) {
@@ -48,6 +72,246 @@ async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext,
     }
 }
 
+const FEATURE_FLAG_EVENT_TYPE = 'feature_flag_called';
+const FEATURE_FLAG_BATCH_BYTES = 48 * 1024;
+function resolveFeatureFlagIngestBase(customUrl) {
+    const normalized = customUrl === null || customUrl === void 0 ? void 0 : customUrl.trim().replace(/\/+$/, '');
+    return normalized || "https://ingest.app.coframe.com/ingest/v2";
+}
+function featureFlagEventsEndpoint(ingestBase, projectId) {
+    return `${ingestBase}/batched_events/${projectId}/`;
+}
+function featureFlagValue(result) {
+    var _a;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+function snapshotPayload(payload) {
+    return payload === null
+        ? null
+        : JSON.parse(JSON.stringify(payload));
+}
+function newEventId() {
+    const cryptoObject = globalThis.crypto;
+    if ((cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID) || (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues)) {
+        return generateUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+        const random = Math.floor(Math.random() * 16);
+        return (char === 'x' ? random : (random & 0x3) | 0x8).toString(16);
+    });
+}
+function createFeatureFlagTrackingEvent(access) {
+    var _a;
+    const { result, response } = access;
+    const errors = [];
+    if (response.errorsWhileComputingFlags) {
+        errors.push('errors_while_computing_flags');
+    }
+    if (!result)
+        errors.push('flag_missing');
+    return {
+        event_id: newEventId(),
+        project_id: access.projectId,
+        session_id: access.sessionId,
+        type: FEATURE_FLAG_EVENT_TYPE,
+        time: new Date().toISOString(),
+        url: access.url,
+        user_token: access.userToken,
+        content: {
+            metadata: {
+                key: access.key,
+                ...(result
+                    ? {
+                        value: featureFlagValue(result),
+                        payload: snapshotPayload('payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null),
+                        version: result.metadata.version,
+                        reason: result.reason,
+                    }
+                    : {}),
+                request_id: response.requestId,
+                snapshot_version: response.snapshotVersion,
+                ...(errors.length > 0 ? { error: errors.join(',') } : {}),
+            },
+        },
+    };
+}
+function jsonBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function chunkFeatureFlagEvents(events) {
+    const chunks = [];
+    let current = [];
+    for (const event of events) {
+        if (current.length > 0 &&
+            jsonBytes([...current, event]) > FEATURE_FLAG_BATCH_BYTES) {
+            chunks.push(current);
+            current = [];
+        }
+        current.push(event);
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}
+
+const FLUSH_INTERVAL_MS = 3000;
+const BATCH_SIZE = 32;
+const MAX_QUEUE_SIZE = 1000;
+const MAX_RETRIES = 3;
+const INGEST_TIMEOUT_MS = 3000;
+let queue = [];
+let flushTimer;
+let inFlight;
+let warnedQueueFull = false;
+let warnedTransport = false;
+let warnedTrackingFailure = false;
+function scheduleFlush() {
+    var _a;
+    if (flushTimer !== undefined)
+        return;
+    flushTimer = setInterval(() => void flushOnce(), FLUSH_INTERVAL_MS);
+    const timer = flushTimer;
+    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+}
+function enqueue(item) {
+    queue.push(item);
+    if (queue.length > MAX_QUEUE_SIZE) {
+        queue.shift();
+        if (!warnedQueueFull) {
+            warnedQueueFull = true;
+            console.warn('[Coframe] Feature Flag server tracking queue is full');
+        }
+    }
+    scheduleFlush();
+    if (queue.length >= BATCH_SIZE)
+        void flushOnce();
+}
+function trackFeatureFlagServerAccess(access) {
+    var _a;
+    const ingestBase = resolveFeatureFlagIngestBase(access.ingestUrl);
+    const commonAccess = {
+        projectId: access.projectId,
+        sessionId: '',
+        userToken: access.userToken,
+        url: (_a = access.currentUrl) !== null && _a !== void 0 ? _a : '',
+        key: access.key,
+        result: access.result,
+        response: access.response,
+    };
+    const endpoint = featureFlagEventsEndpoint(ingestBase, access.projectId);
+    enqueue({
+        endpoint,
+        event: createFeatureFlagTrackingEvent(commonAccess),
+        attempts: 0,
+    });
+}
+function trackFeatureFlagServerReads(context, response, readResults) {
+    var _a;
+    try {
+        for (const [key, result] of readResults()) {
+            trackFeatureFlagServerAccess({
+                projectId: context.projectId,
+                userToken: (_a = context.userToken) !== null && _a !== void 0 ? _a : '',
+                currentUrl: context.currentUrl,
+                ingestUrl: context.ingestUrl,
+                key,
+                result,
+                response,
+            });
+        }
+    }
+    catch (_b) {
+        if (!warnedTrackingFailure) {
+            warnedTrackingFailure = true;
+            console.warn('[Coframe] Feature Flag server tracking failed');
+        }
+    }
+}
+function warnTransport() {
+    if (warnedTransport)
+        return;
+    warnedTransport = true;
+    console.warn('[Coframe] Failed to send Feature Flag server tracking');
+}
+async function sendGroup(endpoint, items) {
+    var _a;
+    const failed = [];
+    let chunks;
+    try {
+        chunks = chunkFeatureFlagEvents(items.map((item) => item.event));
+    }
+    catch (_b) {
+        warnTransport();
+        return failed;
+    }
+    let offset = 0;
+    for (const chunk of chunks) {
+        const chunkItems = items.slice(offset, offset + chunk.length);
+        offset += chunk.length;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), INGEST_TIMEOUT_MS);
+        const timer = timeout;
+        (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+        try {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'text/plain' },
+                body: JSON.stringify(chunk),
+                signal: controller.signal,
+            });
+            if (!response.ok)
+                throw new Error(`Feature Flag ingest failed (${response.status})`);
+        }
+        catch (_c) {
+            for (const item of chunkItems) {
+                if (item.attempts < MAX_RETRIES) {
+                    failed.push({ ...item, attempts: item.attempts + 1 });
+                }
+            }
+            warnTransport();
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    return failed;
+}
+function flushOnce() {
+    var _a;
+    if (inFlight)
+        return inFlight;
+    if (queue.length === 0)
+        return Promise.resolve();
+    const pending = queue;
+    queue = [];
+    const groups = new Map();
+    for (const item of pending) {
+        const group = (_a = groups.get(item.endpoint)) !== null && _a !== void 0 ? _a : [];
+        group.push(item);
+        groups.set(item.endpoint, group);
+    }
+    inFlight = Promise.all(Array.from(groups, ([endpoint, items]) => sendGroup(endpoint, items)))
+        .then((failedGroups) => {
+        for (const failed of failedGroups) {
+            for (const item of failed)
+                enqueue(item);
+        }
+    })
+        .finally(() => {
+        inFlight = undefined;
+    });
+    return inFlight;
+}
+async function flushFeatureFlagEvents() {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
+        if (inFlight)
+            await inFlight;
+        if (queue.length === 0)
+            return;
+        await flushOnce();
+    }
+}
+
 async function requestFeatureFlags(options) {
     var _a, _b;
     const controller = new AbortController();
@@ -88,15 +352,23 @@ async function requestFeatureFlags(options) {
         clearTimeout(timeout);
     }
 }
-function evaluateFlags(options) {
-    return requestFeatureFlags(options);
+async function evaluateFlags(options) {
+    const response = await requestFeatureFlags(options);
+    if (response && options.sendEvent !== false) {
+        trackFeatureFlagServerReads(options, response, () => Object.entries(response.flags));
+    }
+    return response;
 }
 async function getFeatureFlagResult(key, options) {
     const response = await requestFeatureFlags({
         ...options,
         selector: { names: [key] },
     });
-    return response === null || response === void 0 ? void 0 : response.flags[key];
+    const result = response === null || response === void 0 ? void 0 : response.flags[key];
+    if (response && options.sendEvent !== false) {
+        trackFeatureFlagServerReads(options, response, () => [[key, result]]);
+    }
+    return result;
 }
 async function getFeatureFlag(key, options) {
     var _a;
@@ -194,6 +466,7 @@ async function getProjectData(options) {
 }
 
 exports.evaluateFlags = evaluateFlags;
+exports.flushFeatureFlagEvents = flushFeatureFlagEvents;
 exports.getFeatureFlag = getFeatureFlag;
 exports.getFeatureFlagPayload = getFeatureFlagPayload;
 exports.getFeatureFlagResult = getFeatureFlagResult;

package/dist/pkg/server.esm.mjs

@@ -20,6 +20,30 @@ function sanitizeUserContext(userContext) {
     return userContext;
 }
 
+function getGlobalScope() {
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+}
+const generateUUID = () => {
+    var _a;
+    const cryptoObject = (_a = getGlobalScope()) === null || _a === void 0 ? void 0 : _a.crypto;
+    if (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID)
+        return cryptoObject.randomUUID();
+    return `${1e7}${ -1e3}${ -4e3}${ -8e3}${ -1e11}`.replace(/[018]/g, (c) => {
+        var _a, _b;
+        const randomValue = (_b = (_a = cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues) === null || _a === void 0 ? void 0 : _a.call(cryptoObject, new Uint8Array(1))[0]) !== null && _b !== void 0 ? _b : 0;
+        return (c ^
+            (randomValue & (15 >> (c / 4)))).toString(16);
+    });
+};
+
 async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext, previewVariantId, headers, referrer) {
     const payload = { projectId, currentUrl };
     if (referrer !== undefined) {
@@ -46,6 +70,246 @@ async function fetchProjectFromEdge(projectId, currentUrl, signal, userContext,
     }
 }
 
+const FEATURE_FLAG_EVENT_TYPE = 'feature_flag_called';
+const FEATURE_FLAG_BATCH_BYTES = 48 * 1024;
+function resolveFeatureFlagIngestBase(customUrl) {
+    const normalized = customUrl === null || customUrl === void 0 ? void 0 : customUrl.trim().replace(/\/+$/, '');
+    return normalized || "https://ingest.app.coframe.com/ingest/v2";
+}
+function featureFlagEventsEndpoint(ingestBase, projectId) {
+    return `${ingestBase}/batched_events/${projectId}/`;
+}
+function featureFlagValue(result) {
+    var _a;
+    return (_a = result.variant) !== null && _a !== void 0 ? _a : result.enabled;
+}
+function snapshotPayload(payload) {
+    return payload === null
+        ? null
+        : JSON.parse(JSON.stringify(payload));
+}
+function newEventId() {
+    const cryptoObject = globalThis.crypto;
+    if ((cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.randomUUID) || (cryptoObject === null || cryptoObject === void 0 ? void 0 : cryptoObject.getRandomValues)) {
+        return generateUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+        const random = Math.floor(Math.random() * 16);
+        return (char === 'x' ? random : (random & 0x3) | 0x8).toString(16);
+    });
+}
+function createFeatureFlagTrackingEvent(access) {
+    var _a;
+    const { result, response } = access;
+    const errors = [];
+    if (response.errorsWhileComputingFlags) {
+        errors.push('errors_while_computing_flags');
+    }
+    if (!result)
+        errors.push('flag_missing');
+    return {
+        event_id: newEventId(),
+        project_id: access.projectId,
+        session_id: access.sessionId,
+        type: FEATURE_FLAG_EVENT_TYPE,
+        time: new Date().toISOString(),
+        url: access.url,
+        user_token: access.userToken,
+        content: {
+            metadata: {
+                key: access.key,
+                ...(result
+                    ? {
+                        value: featureFlagValue(result),
+                        payload: snapshotPayload('payload' in result ? ((_a = result.payload) !== null && _a !== void 0 ? _a : null) : null),
+                        version: result.metadata.version,
+                        reason: result.reason,
+                    }
+                    : {}),
+                request_id: response.requestId,
+                snapshot_version: response.snapshotVersion,
+                ...(errors.length > 0 ? { error: errors.join(',') } : {}),
+            },
+        },
+    };
+}
+function jsonBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function chunkFeatureFlagEvents(events) {
+    const chunks = [];
+    let current = [];
+    for (const event of events) {
+        if (current.length > 0 &&
+            jsonBytes([...current, event]) > FEATURE_FLAG_BATCH_BYTES) {
+            chunks.push(current);
+            current = [];
+        }
+        current.push(event);
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}
+
+const FLUSH_INTERVAL_MS = 3000;
+const BATCH_SIZE = 32;
+const MAX_QUEUE_SIZE = 1000;
+const MAX_RETRIES = 3;
+const INGEST_TIMEOUT_MS = 3000;
+let queue = [];
+let flushTimer;
+let inFlight;
+let warnedQueueFull = false;
+let warnedTransport = false;
+let warnedTrackingFailure = false;
+function scheduleFlush() {
+    var _a;
+    if (flushTimer !== undefined)
+        return;
+    flushTimer = setInterval(() => void flushOnce(), FLUSH_INTERVAL_MS);
+    const timer = flushTimer;
+    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+}
+function enqueue(item) {
+    queue.push(item);
+    if (queue.length > MAX_QUEUE_SIZE) {
+        queue.shift();
+        if (!warnedQueueFull) {
+            warnedQueueFull = true;
+            console.warn('[Coframe] Feature Flag server tracking queue is full');
+        }
+    }
+    scheduleFlush();
+    if (queue.length >= BATCH_SIZE)
+        void flushOnce();
+}
+function trackFeatureFlagServerAccess(access) {
+    var _a;
+    const ingestBase = resolveFeatureFlagIngestBase(access.ingestUrl);
+    const commonAccess = {
+        projectId: access.projectId,
+        sessionId: '',
+        userToken: access.userToken,
+        url: (_a = access.currentUrl) !== null && _a !== void 0 ? _a : '',
+        key: access.key,
+        result: access.result,
+        response: access.response,
+    };
+    const endpoint = featureFlagEventsEndpoint(ingestBase, access.projectId);
+    enqueue({
+        endpoint,
+        event: createFeatureFlagTrackingEvent(commonAccess),
+        attempts: 0,
+    });
+}
+function trackFeatureFlagServerReads(context, response, readResults) {
+    var _a;
+    try {
+        for (const [key, result] of readResults()) {
+            trackFeatureFlagServerAccess({
+                projectId: context.projectId,
+                userToken: (_a = context.userToken) !== null && _a !== void 0 ? _a : '',
+                currentUrl: context.currentUrl,
+                ingestUrl: context.ingestUrl,
+                key,
+                result,
+                response,
+            });
+        }
+    }
+    catch (_b) {
+        if (!warnedTrackingFailure) {
+            warnedTrackingFailure = true;
+            console.warn('[Coframe] Feature Flag server tracking failed');
+        }
+    }
+}
+function warnTransport() {
+    if (warnedTransport)
+        return;
+    warnedTransport = true;
+    console.warn('[Coframe] Failed to send Feature Flag server tracking');
+}
+async function sendGroup(endpoint, items) {
+    var _a;
+    const failed = [];
+    let chunks;
+    try {
+        chunks = chunkFeatureFlagEvents(items.map((item) => item.event));
+    }
+    catch (_b) {
+        warnTransport();
+        return failed;
+    }
+    let offset = 0;
+    for (const chunk of chunks) {
+        const chunkItems = items.slice(offset, offset + chunk.length);
+        offset += chunk.length;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), INGEST_TIMEOUT_MS);
+        const timer = timeout;
+        (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+        try {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'text/plain' },
+                body: JSON.stringify(chunk),
+                signal: controller.signal,
+            });
+            if (!response.ok)
+                throw new Error(`Feature Flag ingest failed (${response.status})`);
+        }
+        catch (_c) {
+            for (const item of chunkItems) {
+                if (item.attempts < MAX_RETRIES) {
+                    failed.push({ ...item, attempts: item.attempts + 1 });
+                }
+            }
+            warnTransport();
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    return failed;
+}
+function flushOnce() {
+    var _a;
+    if (inFlight)
+        return inFlight;
+    if (queue.length === 0)
+        return Promise.resolve();
+    const pending = queue;
+    queue = [];
+    const groups = new Map();
+    for (const item of pending) {
+        const group = (_a = groups.get(item.endpoint)) !== null && _a !== void 0 ? _a : [];
+        group.push(item);
+        groups.set(item.endpoint, group);
+    }
+    inFlight = Promise.all(Array.from(groups, ([endpoint, items]) => sendGroup(endpoint, items)))
+        .then((failedGroups) => {
+        for (const failed of failedGroups) {
+            for (const item of failed)
+                enqueue(item);
+        }
+    })
+        .finally(() => {
+        inFlight = undefined;
+    });
+    return inFlight;
+}
+async function flushFeatureFlagEvents() {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
+        if (inFlight)
+            await inFlight;
+        if (queue.length === 0)
+            return;
+        await flushOnce();
+    }
+}
+
 async function requestFeatureFlags(options) {
     var _a, _b;
     const controller = new AbortController();
@@ -86,15 +350,23 @@ async function requestFeatureFlags(options) {
         clearTimeout(timeout);
     }
 }
-function evaluateFlags(options) {
-    return requestFeatureFlags(options);
+async function evaluateFlags(options) {
+    const response = await requestFeatureFlags(options);
+    if (response && options.sendEvent !== false) {
+        trackFeatureFlagServerReads(options, response, () => Object.entries(response.flags));
+    }
+    return response;
 }
 async function getFeatureFlagResult(key, options) {
     const response = await requestFeatureFlags({
         ...options,
         selector: { names: [key] },
     });
-    return response === null || response === void 0 ? void 0 : response.flags[key];
+    const result = response === null || response === void 0 ? void 0 : response.flags[key];
+    if (response && options.sendEvent !== false) {
+        trackFeatureFlagServerReads(options, response, () => [[key, result]]);
+    }
+    return result;
 }
 async function getFeatureFlag(key, options) {
     var _a;
@@ -191,4 +463,4 @@ async function getProjectData(options) {
     return null;
 }
 
-export { evaluateFlags, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getProjectData, getRemoteConfig, isFeatureEnabled };
+export { evaluateFlags, flushFeatureFlagEvents, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getProjectData, getRemoteConfig, isFeatureEnabled };

package/dist/pkg/types/feature-flags.d.ts

@@ -27,20 +27,24 @@ interface FeatureFlagsConfig {
     selector?: FeatureFlagSelector;
     requestTimeoutMs?: number;
     cacheTtlMs?: number;
+    ingestUrl?: string;
 }
 
 type FeatureFlagsCallback = (flags: Record<string, FeatureFlagResult>, metadata: {
     errorsWhileComputingFlags: boolean;
     snapshotVersion: number;
 }) => void;
+interface FeatureFlagReadOptions {
+    sendEvent?: boolean;
+}
 declare function reloadFeatureFlags(): Promise<void>;
 declare function onFeatureFlags(callback: FeatureFlagsCallback): () => void;
-declare function getFeatureFlagResult(key: string): FeatureFlagResult | undefined;
-declare function getFeatureFlag(key: string): FeatureFlagValue | undefined;
-declare function isFeatureEnabled(key: string, options?: {
+declare function getFeatureFlagResult(key: string, options?: FeatureFlagReadOptions): FeatureFlagResult | undefined;
+declare function getFeatureFlag(key: string, options?: FeatureFlagReadOptions): FeatureFlagValue | undefined;
+declare function isFeatureEnabled(key: string, options?: FeatureFlagReadOptions & {
     defaultValue?: boolean;
 }): boolean | undefined;
-declare function getFeatureFlagPayload(key: string): JsonValue | null | undefined;
+declare function getFeatureFlagPayload(key: string, options?: FeatureFlagReadOptions): JsonValue | null | undefined;
 declare const getRemoteConfig: typeof getFeatureFlagPayload;
 
 interface FeatureFlagsInitOptions extends FeatureFlagsConfig {
@@ -72,4 +76,4 @@ declare const featureFlags: {
 };
 
 export { featureFlags, getFeatureFlag, getFeatureFlagPayload, getFeatureFlagResult, getRemoteConfig, getUserToken, initFeatureFlags, isFeatureEnabled, onFeatureFlags, reloadFeatureFlags, reset, setConsent, setUserToken };
-export type { FeatureFlagResult, FeatureFlagSelector, FeatureFlagValue, FeatureFlagsConfig, FeatureFlagsInitOptions, FeatureFlagsResponse, JsonValue };
+export type { FeatureFlagReadOptions, FeatureFlagResult, FeatureFlagSelector, FeatureFlagValue, FeatureFlagsConfig, FeatureFlagsInitOptions, FeatureFlagsResponse, JsonValue };

package/dist/pkg/types/react.d.ts

@@ -1,3 +1,4 @@
+import { FeatureFlagReadOptions } from '@coframe/sdk/feature-flags';
 import React, { ReactNode } from 'react';
 export { init, onLog, onTreatmentApplied, setConsent, setFeatureFlag, setPageHydrated, setUserToken, trackConversion } from '@coframe/sdk';
 
@@ -339,11 +340,11 @@ declare function CoframeProvider({ projectConfig, projectData, onTreatmentApplie
 declare function useCoframeTreatments(): TreatmentData[] | null;
 declare function useCoframeTreatment(experimentId: string): TreatmentData | undefined;
 declare function useCoframeVariant(experimentId: string): string | undefined;
-declare function useFeatureFlagResult(key: string): FeatureFlagResult | undefined;
-declare function useFeatureFlagVariantKey(key: string): FeatureFlagValue | undefined;
+declare function useFeatureFlagResult(key: string, options?: FeatureFlagReadOptions): FeatureFlagResult | undefined;
+declare function useFeatureFlagVariantKey(key: string, options?: FeatureFlagReadOptions): FeatureFlagValue | undefined;
 declare const useFeatureFlag: typeof useFeatureFlagVariantKey;
-declare function useFeatureFlagEnabled(key: string): boolean | undefined;
-declare function useFeatureFlagPayload(key: string): JsonValue | null | undefined;
+declare function useFeatureFlagEnabled(key: string, options?: FeatureFlagReadOptions): boolean | undefined;
+declare function useFeatureFlagPayload(key: string, options?: FeatureFlagReadOptions): JsonValue | null | undefined;
 
 export { CoframeProvider, useCoframeTreatment, useCoframeTreatments, useCoframeVariant, useFeatureFlag, useFeatureFlagEnabled, useFeatureFlagPayload, useFeatureFlagResult, useFeatureFlagVariantKey };
 export type { CoframeProviderProps };