@mergedapp/feature-flags 0.1.3

package/dist/openfeature/web.js

@@ -0,0 +1,3 @@
+export { createLoggingHook, createStaticContextHook } from "./hooks.js";
+export { DEFAULT_TARGETING_KEY_ATTRIBUTE, createDefaultOpenFeatureContextMapper, mergeFeatureFlagEvaluationContexts, } from "./context.js";
+export { createOpenFeatureWebProvider, MergedOpenFeatureWebProvider, } from "./web-provider.js";

package/dist/persistence.d.ts

@@ -0,0 +1,39 @@
+import type { FeatureFlagClientConfig, FeatureFlagRuntimeStatus, FeatureFlagSnapshotStore, PersistedFeatureFlagSnapshot } from "./types.js";
+type ScopeParts = {
+    scopeKey: string;
+    organizationId: string;
+    environmentId: string;
+    teamId: string | null;
+    clientKeyFingerprint: string;
+    contextHash: string;
+};
+export declare function serializeCanonicalValue(value: unknown): string;
+export declare function createDefaultFeatureFlagRuntimeStatus(): FeatureFlagRuntimeStatus;
+export declare function buildSnapshotScopeParts<TFlags extends object = object>(params: {
+    config: FeatureFlagClientConfig<TFlags>;
+    keyPrefix?: string;
+}): Promise<ScopeParts>;
+export declare function createPersistedFeatureFlagSnapshot(params: {
+    scope: ScopeParts;
+    token: string;
+    publicKeyPem: string;
+    fetchedAt: string;
+    tokenExpiresAt: string | null;
+}): PersistedFeatureFlagSnapshot;
+export declare function doesSnapshotMatchScope(params: {
+    snapshot: PersistedFeatureFlagSnapshot;
+    scope: ScopeParts;
+}): boolean;
+export declare function isBrowserPersistenceAvailable(): boolean;
+export declare function createLocalStorageFeatureFlagSnapshotStore(): FeatureFlagSnapshotStore;
+export declare function createFileFeatureFlagSnapshotStore(params?: {
+    rootDirectory?: string;
+}): FeatureFlagSnapshotStore;
+export declare function resolveSnapshotStore<TFlags extends object = object>(params: {
+    config: FeatureFlagClientConfig<TFlags>;
+}): Promise<FeatureFlagSnapshotStore | null>;
+export declare function getSnapshotKeyPrefix<TFlags extends object = object>(params: {
+    config: FeatureFlagClientConfig<TFlags>;
+}): string;
+export declare function decodeJwtPayload(token: string): Record<string, unknown>;
+export {};

package/dist/persistence.js

@@ -0,0 +1,203 @@
+const DEFAULT_SNAPSHOT_KEY_PREFIX = "merged-feature-flags";
+const SNAPSHOT_SCHEMA_VERSION = 1;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+let nodeModulePromise = null;
+async function getNodeModules() {
+    if (!nodeModulePromise) {
+        nodeModulePromise = Promise.all([
+            import("node:crypto"),
+            import("node:fs/promises"),
+            import("node:os"),
+            import("node:path"),
+        ]).then(([crypto, fs, os, path]) => ({ crypto, fs, os, path }));
+    }
+    return nodeModulePromise;
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeValue(item));
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => [key, normalizeValue(entryValue)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+export function serializeCanonicalValue(value) {
+    return JSON.stringify(normalizeValue(value));
+}
+export function createDefaultFeatureFlagRuntimeStatus() {
+    return {
+        source: "defaults",
+        isStale: false,
+        lastSuccessfulRefreshAt: null,
+        tokenExpiresAt: null,
+        lastError: null,
+    };
+}
+async function sha256Hex(value) {
+    if (globalThis.crypto?.subtle) {
+        const digest = await globalThis.crypto.subtle.digest("SHA-256", textEncoder.encode(value));
+        return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    }
+    const { crypto } = await getNodeModules();
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+export async function buildSnapshotScopeParts(params) {
+    const contextHash = await sha256Hex(serializeCanonicalValue(params.config.evaluationContext ?? null));
+    const clientKeyFingerprint = await sha256Hex(params.config.clientKey);
+    const prefix = params.keyPrefix?.trim() || DEFAULT_SNAPSHOT_KEY_PREFIX;
+    const scopeMaterial = serializeCanonicalValue({
+        apiUrl: params.config.apiUrl.replace(/\/$/, ""),
+        organizationId: params.config.organizationId.trim(),
+        environmentId: params.config.environmentId.trim(),
+        teamId: params.config.teamId?.trim() || null,
+        clientKeyFingerprint,
+        contextHash,
+    });
+    return {
+        scopeKey: `${prefix}:${await sha256Hex(scopeMaterial)}`,
+        organizationId: params.config.organizationId.trim(),
+        environmentId: params.config.environmentId.trim(),
+        teamId: params.config.teamId?.trim() || null,
+        clientKeyFingerprint,
+        contextHash,
+    };
+}
+function buildSnapshotRecord(params) {
+    return {
+        schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+        scopeKey: params.scope.scopeKey,
+        organizationId: params.scope.organizationId,
+        environmentId: params.scope.environmentId,
+        teamId: params.scope.teamId,
+        clientKeyFingerprint: params.scope.clientKeyFingerprint,
+        contextHash: params.scope.contextHash,
+        token: params.token,
+        publicKeyPem: params.publicKeyPem,
+        fetchedAt: params.fetchedAt,
+        tokenExpiresAt: params.tokenExpiresAt,
+    };
+}
+export function createPersistedFeatureFlagSnapshot(params) {
+    return buildSnapshotRecord(params);
+}
+export function doesSnapshotMatchScope(params) {
+    return (params.snapshot.schemaVersion === SNAPSHOT_SCHEMA_VERSION &&
+        params.snapshot.scopeKey === params.scope.scopeKey &&
+        params.snapshot.organizationId === params.scope.organizationId &&
+        params.snapshot.environmentId === params.scope.environmentId &&
+        params.snapshot.teamId === params.scope.teamId &&
+        params.snapshot.clientKeyFingerprint === params.scope.clientKeyFingerprint &&
+        params.snapshot.contextHash === params.scope.contextHash);
+}
+export function isBrowserPersistenceAvailable() {
+    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+export function createLocalStorageFeatureFlagSnapshotStore() {
+    return {
+        async load(key) {
+            if (!isBrowserPersistenceAvailable()) {
+                return null;
+            }
+            try {
+                const raw = window.localStorage.getItem(key);
+                return raw ? JSON.parse(raw) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async save(key, snapshot) {
+            if (!isBrowserPersistenceAvailable()) {
+                return;
+            }
+            try {
+                window.localStorage.setItem(key, JSON.stringify(snapshot));
+            }
+            catch {
+            }
+        },
+        async remove(key) {
+            if (!isBrowserPersistenceAvailable()) {
+                return;
+            }
+            try {
+                window.localStorage.removeItem(key);
+            }
+            catch {
+            }
+        },
+    };
+}
+function sanitizeKeyForFilename(key) {
+    return encodeURIComponent(key);
+}
+export function createFileFeatureFlagSnapshotStore(params) {
+    return {
+        async load(key) {
+            const { fs, os, path } = await getNodeModules();
+            const rootDirectory = params?.rootDirectory ?? path.join(os.tmpdir(), DEFAULT_SNAPSHOT_KEY_PREFIX);
+            const filePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.json`);
+            try {
+                const raw = await fs.readFile(filePath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        async save(key, snapshot) {
+            const { fs, os, path } = await getNodeModules();
+            const rootDirectory = params?.rootDirectory ?? path.join(os.tmpdir(), DEFAULT_SNAPSHOT_KEY_PREFIX);
+            const filePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.json`);
+            const tempFilePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+            await fs.mkdir(rootDirectory, { recursive: true });
+            await fs.writeFile(tempFilePath, JSON.stringify(snapshot), "utf-8");
+            await fs.rename(tempFilePath, filePath);
+        },
+        async remove(key) {
+            const { fs, os, path } = await getNodeModules();
+            const rootDirectory = params?.rootDirectory ?? path.join(os.tmpdir(), DEFAULT_SNAPSHOT_KEY_PREFIX);
+            const filePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.json`);
+            try {
+                await fs.rm(filePath, { force: true });
+            }
+            catch {
+            }
+        },
+    };
+}
+export async function resolveSnapshotStore(params) {
+    const persistence = params.config.snapshotPersistence;
+    if (persistence === false) {
+        return null;
+    }
+    if (persistence?.store) {
+        return persistence.store;
+    }
+    if (isBrowserPersistenceAvailable()) {
+        return createLocalStorageFeatureFlagSnapshotStore();
+    }
+    return createFileFeatureFlagSnapshotStore();
+}
+export function getSnapshotKeyPrefix(params) {
+    const persistence = params.config.snapshotPersistence;
+    return persistence?.keyPrefix?.trim() || DEFAULT_SNAPSHOT_KEY_PREFIX;
+}
+export function decodeJwtPayload(token) {
+    const segments = token.split(".");
+    if (segments.length !== 3) {
+        throw new Error("JWT must contain exactly three segments.");
+    }
+    const payloadSegment = segments[1];
+    const normalized = payloadSegment.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+    const payloadBytes = typeof atob === "function"
+        ? Uint8Array.from(atob(padded), (character) => character.charCodeAt(0))
+        : Uint8Array.from(Buffer.from(padded, "base64"));
+    return JSON.parse(textDecoder.decode(payloadBytes));
+}

package/dist/react/hooks.d.ts

@@ -0,0 +1,52 @@
+import type { EvaluatedFlag } from "@repo/types-v2";
+import { type ReactNode } from "react";
+import type { MergedFeatureFlags } from "../client.js";
+import type { FlagRegistry } from "../types.js";
+import { type FeatureFlagClient, type FeatureFlagLoadState } from "./provider.js";
+export declare function resolveFlagFromContext(params: {
+    client: Pick<FeatureFlagClient, "getFlag">;
+    flags: EvaluatedFlag[];
+    idOrName: string;
+}): EvaluatedFlag | undefined;
+export declare function useFeatureFlagStatus(): FeatureFlagLoadState;
+export declare function useUntypedFeatureFlag(idOrName: string): {
+    enabled: boolean;
+    value: unknown;
+};
+export declare function useUntypedFeatureFlags(): EvaluatedFlag[];
+export declare function useUntypedFeatureFlagClient(): FeatureFlagClient;
+export type FeatureFlagRenderState<TValue> = {
+    enabled: boolean;
+    value: TValue | undefined;
+    status: FeatureFlagLoadState;
+};
+type FeatureFlagMatchValue<TValue> = Extract<TValue, string | number | boolean>;
+export type TypedFeatureFlagProps<TFlags extends FlagRegistry, K extends string & keyof TFlags> = {
+    name: K;
+    children: ReactNode | ((props: FeatureFlagRenderState<TFlags[K]>) => ReactNode);
+    fallback?: ReactNode;
+    loading?: ReactNode;
+    matchValue?: FeatureFlagMatchValue<TFlags[K]>;
+};
+export type FeatureFlagComponentProps<TFlags extends FlagRegistry> = {
+    [K in string & keyof TFlags]: TypedFeatureFlagProps<TFlags, K>;
+}[string & keyof TFlags];
+export type TypedFeatureFlagComponent<TFlags extends FlagRegistry> = <K extends string & keyof TFlags>(props: TypedFeatureFlagProps<TFlags, K>) => ReactNode;
+export declare function createTypedHooks<TFlags extends FlagRegistry>(): {
+    FeatureFlagProvider: (props: {
+        client: FeatureFlagClient;
+        blockUntilReady: boolean;
+        loadingFallback?: ReactNode;
+        initialFlags?: EvaluatedFlag[];
+        children: ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    FeatureFlag: TypedFeatureFlagComponent<TFlags>;
+    useFeatureFlag: <K extends string & keyof TFlags>(name: K) => {
+        enabled: boolean;
+        value: TFlags[K] | undefined;
+    };
+    useFeatureFlags: () => EvaluatedFlag[];
+    useFeatureFlagClient: () => MergedFeatureFlags<TFlags>;
+    useFeatureFlagStatus: () => FeatureFlagLoadState;
+};
+export {};

package/dist/react/hooks.js

@@ -0,0 +1,78 @@
+import { useContext } from "react";
+import { FeatureFlagContext, FeatureFlagProvider, } from "./provider.js";
+function useFeatureFlagContext() {
+    const context = useContext(FeatureFlagContext);
+    if (!context) {
+        throw new Error("Feature flag hooks and components must be used within a <FeatureFlagProvider>.");
+    }
+    return context;
+}
+export function resolveFlagFromContext(params) {
+    return (params.flags.find((flag) => flag.id === params.idOrName || flag.name === params.idOrName) ??
+        params.client.getFlag(params.idOrName));
+}
+export function useFeatureFlagStatus() {
+    const { loadState } = useFeatureFlagContext();
+    return loadState;
+}
+export function useUntypedFeatureFlag(idOrName) {
+    const { client, flags } = useFeatureFlagContext();
+    const flag = resolveFlagFromContext({ client, flags, idOrName });
+    return { enabled: flag?.enabled ?? false, value: flag?.value };
+}
+export function useUntypedFeatureFlags() {
+    const { flags } = useFeatureFlagContext();
+    return flags;
+}
+export function useUntypedFeatureFlagClient() {
+    const { client } = useFeatureFlagContext();
+    return client;
+}
+export function createTypedHooks() {
+    function TypedFeatureFlagProvider(props) {
+        return FeatureFlagProvider(props);
+    }
+    function typedUseFeatureFlag(name) {
+        const { client, flags } = useFeatureFlagContext();
+        const flag = resolveFlagFromContext({ client, flags, idOrName: name });
+        return {
+            enabled: flag?.enabled ?? false,
+            value: flag?.value,
+        };
+    }
+    function typedUseFeatureFlags() {
+        const { flags } = useFeatureFlagContext();
+        return flags;
+    }
+    function typedUseFeatureFlagClient() {
+        const { client } = useFeatureFlagContext();
+        return client;
+    }
+    function typedUseFeatureFlagStatus() {
+        return useFeatureFlagStatus();
+    }
+    const TypedFeatureFlag = (props) => {
+        const { children, fallback, loading, matchValue, name } = props;
+        const status = typedUseFeatureFlagStatus();
+        const { enabled, value } = typedUseFeatureFlag(name);
+        if (status.isLoading) {
+            return loading ?? fallback ?? null;
+        }
+        const shouldRenderChildren = typeof matchValue === "undefined" ? enabled : Object.is(value, matchValue);
+        if (!shouldRenderChildren) {
+            return fallback ?? null;
+        }
+        if (typeof children === "function") {
+            return children({ enabled, value, status });
+        }
+        return children;
+    };
+    return {
+        FeatureFlagProvider: TypedFeatureFlagProvider,
+        FeatureFlag: TypedFeatureFlag,
+        useFeatureFlag: typedUseFeatureFlag,
+        useFeatureFlags: typedUseFeatureFlags,
+        useFeatureFlagClient: typedUseFeatureFlagClient,
+        useFeatureFlagStatus: typedUseFeatureFlagStatus,
+    };
+}

package/dist/react/provider.d.ts

@@ -0,0 +1,71 @@
+import { type ReactNode } from "react";
+import type { EvaluatedFlag } from "@repo/types-v2";
+import type { FeatureFlagRuntimeStatus } from "../types.js";
+export interface FeatureFlagClient {
+    initialize(): Promise<void>;
+    destroy(): void;
+    isEnabled(name: string): boolean;
+    getValue(name: string): unknown;
+    getFlag(name: string): EvaluatedFlag | undefined;
+    getAllFlags(): EvaluatedFlag[];
+    getSnapshot(): EvaluatedFlag[];
+    getStatus(): FeatureFlagRuntimeStatus;
+    subscribe(onStoreChange: () => void): () => void;
+    refresh(): Promise<void>;
+}
+export type FeatureFlagProviderStatus = "idle" | "loading" | "ready" | "error";
+export type FeatureFlagLoadState = {
+    status: FeatureFlagProviderStatus;
+    isLoading: boolean;
+    isReady: boolean;
+    error: Error | null;
+    source: FeatureFlagRuntimeStatus["source"];
+    isStale: boolean;
+    lastSuccessfulRefreshAt: string | null;
+    tokenExpiresAt: string | null;
+};
+export type FeatureFlagContextValue = {
+    client: FeatureFlagClient;
+    flags: EvaluatedFlag[];
+    loadState: FeatureFlagLoadState;
+};
+export declare const FeatureFlagContext: import("react").Context<FeatureFlagContextValue | null>;
+export type FeatureFlagProviderProps = {
+    client: FeatureFlagClient;
+    blockUntilReady: boolean;
+    loadingFallback?: ReactNode;
+    initialFlags?: EvaluatedFlag[];
+    children: ReactNode;
+};
+export declare function createFeatureFlagLoadState(params: {
+    status: FeatureFlagProviderStatus;
+    error: Error | null;
+    runtimeStatus: FeatureFlagRuntimeStatus;
+}): FeatureFlagLoadState;
+export declare function shouldRenderFeatureFlagLoadingFallback(params: {
+    blockUntilReady: boolean;
+    loadState: FeatureFlagLoadState;
+}): boolean;
+export declare function createSnapshotStore(params: {
+    client: FeatureFlagClient;
+    initialFlags?: EvaluatedFlag[];
+}): {
+    subscribe(onStoreChange: () => void): () => void;
+    getSnapshot(): {
+        id: string;
+        name: string;
+        type: "BOOLEAN" | "STRING" | "NUMBER" | "JSON" | "ARRAY";
+        teamId: string | null;
+        enabled: boolean;
+        value: unknown;
+    }[];
+    getServerSnapshot(): {
+        id: string;
+        name: string;
+        type: "BOOLEAN" | "STRING" | "NUMBER" | "JSON" | "ARRAY";
+        teamId: string | null;
+        enabled: boolean;
+        value: unknown;
+    }[];
+};
+export declare function FeatureFlagProvider(props: FeatureFlagProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/provider.js

@@ -0,0 +1,99 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useEffect, useMemo, useState, useSyncExternalStore } from "react";
+export const FeatureFlagContext = createContext(null);
+const EMPTY_EVALUATED_FLAGS = [];
+export function createFeatureFlagLoadState(params) {
+    return {
+        status: params.status,
+        isLoading: params.status === "loading",
+        isReady: params.status === "ready",
+        error: params.error ?? params.runtimeStatus.lastError,
+        source: params.runtimeStatus.source,
+        isStale: params.runtimeStatus.isStale,
+        lastSuccessfulRefreshAt: params.runtimeStatus.lastSuccessfulRefreshAt,
+        tokenExpiresAt: params.runtimeStatus.tokenExpiresAt,
+    };
+}
+export function shouldRenderFeatureFlagLoadingFallback(params) {
+    return params.blockUntilReady && params.loadState.isLoading;
+}
+export function createSnapshotStore(params) {
+    let cachedFlags = params.initialFlags ?? params.client.getSnapshot();
+    let hasObservedClientUpdate = false;
+    function areSnapshotsEqual(left, right) {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index++) {
+            const leftFlag = left[index];
+            const rightFlag = right[index];
+            if (leftFlag?.id !== rightFlag?.id ||
+                leftFlag?.name !== rightFlag?.name ||
+                leftFlag?.type !== rightFlag?.type ||
+                leftFlag?.teamId !== rightFlag?.teamId ||
+                leftFlag?.enabled !== rightFlag?.enabled ||
+                JSON.stringify(leftFlag?.value) !== JSON.stringify(rightFlag?.value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return {
+        subscribe(onStoreChange) {
+            return params.client.subscribe(() => {
+                hasObservedClientUpdate = true;
+                onStoreChange();
+            });
+        },
+        getSnapshot() {
+            const current = params.client.getSnapshot();
+            const shouldAdoptClientSnapshot = current.length > 0 || !params.initialFlags || hasObservedClientUpdate;
+            if (shouldAdoptClientSnapshot && !areSnapshotsEqual(current, cachedFlags)) {
+                cachedFlags = current;
+            }
+            return cachedFlags;
+        },
+        getServerSnapshot() {
+            return params.initialFlags ?? EMPTY_EVALUATED_FLAGS;
+        },
+    };
+}
+export function FeatureFlagProvider(props) {
+    const { client, blockUntilReady, loadingFallback, initialFlags, children } = props;
+    const [status, setStatus] = useState(initialFlags ? "ready" : "loading");
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let isDisposed = false;
+        setStatus(initialFlags ? "ready" : "loading");
+        setError(null);
+        client.initialize()
+            .then(() => {
+            if (isDisposed) {
+                return;
+            }
+            setStatus("ready");
+        })
+            .catch((initializationError) => {
+            if (isDisposed) {
+                return;
+            }
+            setStatus("error");
+            setError(initializationError instanceof Error
+                ? initializationError
+                : new Error("Unknown feature flag initialization error."));
+        });
+        return () => {
+            isDisposed = true;
+            client.destroy();
+        };
+    }, [client, initialFlags]);
+    const snapshotStore = useMemo(() => createSnapshotStore({ client, initialFlags }), [client, initialFlags]);
+    const flags = useSyncExternalStore(snapshotStore.subscribe, snapshotStore.getSnapshot, snapshotStore.getServerSnapshot);
+    const runtimeStatus = useSyncExternalStore(client.subscribe, client.getStatus.bind(client), client.getStatus.bind(client));
+    const loadState = useMemo(() => createFeatureFlagLoadState({ status, error, runtimeStatus }), [error, runtimeStatus, status]);
+    const value = useMemo(() => ({ client, flags, loadState }), [client, flags, loadState]);
+    if (shouldRenderFeatureFlagLoadingFallback({ blockUntilReady, loadState })) {
+        return _jsx(_Fragment, { children: loadingFallback ?? null });
+    }
+    return _jsx(FeatureFlagContext.Provider, { value: value, children: children });
+}

package/dist/react.cjs

@@ -0,0 +1 @@
+module.exports = require("./cjs/react.js")

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+export { FeatureFlagProvider, type FeatureFlagProviderProps, type FeatureFlagClient } from "./react/provider.js";
+export { createTypedHooks } from "./react/hooks.js";

package/dist/react.js

@@ -0,0 +1,2 @@
+export { FeatureFlagProvider } from "./react/provider.js";
+export { createTypedHooks } from "./react/hooks.js";

package/dist/remote-evaluator.d.ts

@@ -0,0 +1,28 @@
+import type { EvaluatedFlag, FeatureFlagEvaluationContext } from "@repo/types-v2";
+import type { FeatureFlagClientConfig } from "./types.js";
+export type RemoteFeatureFlagEvaluatorConfig = Pick<FeatureFlagClientConfig, "apiUrl" | "clientKey" | "organizationId" | "environmentId" | "teamId" | "publicKey">;
+export type RemoteFeatureFlagEvaluationResult = {
+    expiresAt: string | null;
+    fetchedAt: string;
+    flags: EvaluatedFlag[];
+};
+export declare class RemoteFeatureFlagEvaluator {
+    private publicKeyPem;
+    private publicKeyCrypto;
+    private readonly evaluationCache;
+    private readonly inflightEvaluations;
+    private readonly apiUrl;
+    private readonly clientKey;
+    private readonly organizationId;
+    private readonly environmentId;
+    private readonly teamId;
+    constructor(config: RemoteFeatureFlagEvaluatorConfig);
+    evaluate(context: FeatureFlagEvaluationContext | null | undefined): Promise<RemoteFeatureFlagEvaluationResult>;
+    private evaluateUncached;
+    private isCachedEvaluationValid;
+    private fetchSignedFlags;
+    private fetchPublicKey;
+    private verifyWithRetry;
+    private ensureVerificationKey;
+    private fetchWithTimeout;
+}