flagmint-js-sdk 1.2.26 → 2.2.0

package/dist/sdk/core/config-sync/rulesStore.d.ts

@@ -0,0 +1,56 @@
+import type { ConfigSyncPayload, DeltaConfigPayload, DeltasCatchUpPayload, FullConfigPayload, LeasePayload, RulesCacheSnapshot, SdkFlagConfig, SdkSegment } from './types';
+export type RulesState = {
+    version: number;
+    expiresAt: number;
+    flags: Map<string, SdkFlagConfig>;
+    segments: Map<string, SdkSegment>;
+    /** false when lease expired offline — fail closed (defaults only). */
+    ready: boolean;
+    /** Set when a delta's fromVersion does not match — reconnect with fullConfig. */
+    needsFullConfig: boolean;
+};
+export type ApplyResult = {
+    ok: true;
+    state: RulesState;
+} | {
+    ok: false;
+    reason: 'bad_signature' | 'version_gap' | 'stale' | 'expired' | 'invalid_payload';
+    state: RulesState;
+};
+export declare function createEmptyRulesState(): RulesState;
+/**
+ * Pure reducer for config-sync actions (signatures already verified).
+ */
+export declare function reduceRules(state: RulesState, action: ConfigSyncPayload, now?: number): ApplyResult;
+/**
+ * In-memory rules store: verify MAC → reduce → optional localCache snapshot.
+ */
+export declare class RulesStore {
+    private state;
+    private macKey;
+    constructor(macKey?: Uint8Array | null, initial?: RulesState);
+    setMacKey(macKey: Uint8Array | null): void;
+    getMacKey(): Uint8Array | null;
+    getState(): RulesState;
+    /**
+     * Fail-closed readiness: lease not expired and store marked ready.
+     */
+    isReady(now?: number): boolean;
+    markExpired(): void;
+    getFlag(key: string): SdkFlagConfig | undefined;
+    /**
+     * Fail-closed default for a flag key (last-known `default_value` only).
+     */
+    getFailClosedDefault(key: string): unknown;
+    wantsFullConfig(now?: number): boolean;
+    sinceVersion(now?: number): number | undefined;
+    /**
+     * Verify signature with the session MAC key, then apply the reducer.
+     */
+    applySigned(payload: ConfigSyncPayload, now?: number): ApplyResult;
+    /** Apply without MAC (unit tests / already-verified payloads). */
+    applyTrusted(payload: ConfigSyncPayload, now?: number): ApplyResult;
+    toSnapshot(): RulesCacheSnapshot;
+    hydrateFromSnapshot(snapshot: RulesCacheSnapshot, now?: number): void;
+}
+export type { LeasePayload, FullConfigPayload, DeltaConfigPayload, DeltasCatchUpPayload };

package/dist/sdk/core/config-sync/signPayload.d.ts

@@ -0,0 +1,17 @@
+import type { SignableConfigBody } from './types';
+/**
+ * Stable JSON for HMAC: sort object keys recursively so field order cannot
+ * invalidate signatures across language runtimes.
+ * Must match FF-EU `canonicalizeForSigning`.
+ */
+export declare function canonicalizeForSigning(value: unknown): string;
+/**
+ * HMAC-SHA256 hex digest over the payload with `signature` omitted.
+ */
+export declare function signConfigPayload(body: SignableConfigBody, secret: Uint8Array | string): string;
+/**
+ * Verify HMAC-SHA256 hex `signature` on a config-sync payload.
+ * Prefer the ASL ECDH-derived session MAC key.
+ */
+export declare function verifyConfigPayloadSignature(body: SignableConfigBody, secret: Uint8Array | string): boolean;
+export declare function isConfigPayloadExpired(expiresAt: number, now?: number): boolean;

package/dist/sdk/core/config-sync/stringHash.d.ts

@@ -0,0 +1,7 @@
+/**
+ * djb2 variant matching npm `string-hash` (and Go `evaluate.StringHash`).
+ * Iterates right-to-left with XOR — required for rollout bucket parity.
+ */
+export declare function stringHash(input: string): number;
+/** Stable bucket in [0, 99] for percentage / variant rollouts. */
+export declare function hashPercent(input: string): number;

package/dist/sdk/core/config-sync/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Wire types for SSE config-sync (aligned with FF-EU `modules/evaluator/config-sync.ts`).
+ */
+export type SdkFlagConfig = {
+    key: string;
+    type: 'boolean' | 'string' | 'number' | 'json';
+    is_active: boolean;
+    default_value: unknown;
+    off_variation_id?: string | null;
+    targeting_rules: unknown[];
+    variations: Array<{
+        id: string;
+        value: unknown;
+        key?: string;
+        name?: string;
+    }>;
+    rollouts: Record<string, unknown>;
+    analytics_enabled: boolean;
+};
+export type SdkSegment = {
+    id: string;
+    rules: unknown[];
+    logical_op?: string;
+    force?: boolean;
+};
+export type SignableConfigBody = Record<string, unknown> & {
+    signature?: string;
+};
+export type LeasePayload = {
+    type: 'lease';
+    version: number;
+    serverNow: number;
+    expiresAt: number;
+    signature: string;
+};
+export type FullConfigPayload = {
+    type: 'fullConfig';
+    version: number;
+    compiledAt: number;
+    expiresAt: number;
+    flags: SdkFlagConfig[];
+    segments: Record<string, SdkSegment>;
+    warnings?: string[];
+    signature: string;
+};
+export type DeltaConfigPayload = {
+    type: 'delta';
+    fromVersion: number;
+    toVersion: number;
+    compiledAt: number;
+    expiresAt: number;
+    upserts: SdkFlagConfig[];
+    deletes: string[];
+    segments: Record<string, SdkSegment>;
+    signature: string;
+};
+export type DeltasCatchUpPayload = {
+    type: 'deltas';
+    fromVersion: number;
+    toVersion: number;
+    expiresAt: number;
+    items: DeltaConfigPayload[];
+    signature: string;
+};
+export type ConfigSyncPayload = LeasePayload | FullConfigPayload | DeltaConfigPayload | DeltasCatchUpPayload;
+/** Persisted cache for reconnect (`fullConfig` vs `sinceVersion`). */
+export type RulesCacheSnapshot = {
+    version: number;
+    expiresAt: number;
+    flags: SdkFlagConfig[];
+    segments: Record<string, SdkSegment>;
+};

package/dist/sdk/core/helpers/applicationEvents.d.ts

@@ -0,0 +1,27 @@
+export declare const MAX_EVENT_BATCH = 20;
+export declare const EVENT_FLUSH_MS = 2000;
+export type ApplicationEventKind = 'error' | 'custom';
+export interface ApplicationEvent {
+    flagKey: string;
+    kind: ApplicationEventKind;
+    eventName?: string;
+    variationValue?: unknown;
+    userKey?: string;
+    timestamp: string;
+    extra?: Record<string, unknown>;
+}
+export declare function eventsUrlFromRestEndpoint(restEndpoint: string): string;
+/**
+ * API base for `POST …/context` (and similar) from the REST evaluate URL.
+ * Stream hosts may be SSE-only (`STREAM_HOSTS`); context must stay on the API host.
+ *
+ * `https://api…/evaluator/evaluate` → `https://api…/evaluator/v2/flags`
+ */
+export declare function flagsBaseFromRestEndpoint(restEndpoint: string): string;
+export declare function userKeyFromContext(context: Record<string, unknown> | undefined): string | undefined;
+export declare function extraFromError(error: unknown, extra?: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * When the server has sent an analytics map, only flags with analytics on
+ * are reported. A null map means an older server — send and let ingest drop.
+ */
+export declare function shouldReportApplicationEvent(analyticsByFlag: Record<string, boolean> | null, flagKey: string): boolean;

package/dist/sdk/core/helpers/connectionShare.d.ts

@@ -0,0 +1,222 @@
+/**
+ * Same-origin connection sharing for Flagmint streaming transports.
+ *
+ * When two or more FlagClient instances run in the same origin — typical cases
+ * are a host page plus sibling iframes, or two widgets on one Python-embedded
+ * page — each would otherwise open its own ASL handshake and SSE/long-poll
+ * stream. That doubles evaluation quota and is almost never intended.
+ *
+ * This hub elects a single **leader** per API key:
+ *
+ * - **Leader** holds the real transport (handshake + EventSource). It broadcasts
+ *   flag snapshots and errors over {@link BroadcastChannel}.
+ * - **Followers** skip handshake and EventSource. They apply the leader's flags
+ *   and forward `updateContext()` to the leader, which runs it on the shared
+ *   stream.
+ *
+ * Leadership is stored in `localStorage` (`flagmint_share_lock:<apiKey>`) with a
+ * short TTL and heartbeat. `destroy()` and a `pagehide` / `beforeunload` listener
+ * post `bye` and release the lock so another member can take over immediately.
+ * If the document is killed without those events, followers wait until the lock
+ * TTL expires.
+ *
+ * Sharing is a **browser** feature. Node cluster workers each need their own
+ * stream — {@link isConnectionSharingAvailable} is false there. Do not share
+ * when two clients on one page must keep different evaluation contexts at the
+ * same time; `/context` is per connection, so the last write wins.
+ *
+ * Trust: `BroadcastChannel` and `localStorage` are same-origin. Any document
+ * on this origin (including a third-party iframe you host there) can join the
+ * group, POST a context through the leader's authenticated stream, and read
+ * the flags broadcast back. That is expected among trusted siblings. If the
+ * origin serves untrusted content, set `shareConnection: false`.
+ *
+ * @module connectionShare
+ */
+import type { Transport } from '../../core/transports/Transport';
+/** Role this document plays in the share group for a given API key. */
+export type ShareRole = 'leader' | 'follower';
+/**
+ * Persistence used for the leadership lock.
+ * Defaults to `localStorage` so sibling iframes on the same origin can compete.
+ */
+export interface ShareStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * Cross-document bus. Production uses {@link BroadcastChannel};
+ * tests inject an in-memory implementation.
+ */
+export interface ShareChannel {
+    postMessage(data: unknown): void;
+    close(): void;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+}
+/**
+ * Test/runtime hooks. Omit in production — the hub uses `BroadcastChannel`,
+ * `localStorage`, and `setInterval`.
+ */
+export interface ConnectionShareOptions {
+    /** Override `new BroadcastChannel(name)` (tests). */
+    channelFactory?: (name: string) => ShareChannel;
+    /** Override `localStorage` for the leadership lock (tests). */
+    storage?: ShareStorage;
+    /** Clock used for lock expiry. */
+    now?: () => number;
+    setTimer?: (handler: () => void, ms: number) => ReturnType<typeof setInterval>;
+    clearTimer?: (id: ReturnType<typeof setInterval>) => void;
+    /** Delay used to stagger lock confirmation (tests inject a no-op). */
+    delay?: (ms: number) => Promise<void>;
+}
+/**
+ * Whether this runtime can share a stream across documents.
+ *
+ * @returns `true` in a browser with {@link BroadcastChannel} (includes same-origin
+ * iframes). `false` in Node, so cluster workers each keep their own connection.
+ */
+export declare function isConnectionSharingAvailable(): boolean;
+/**
+ * Elects a single streaming leader per API key across same-origin documents.
+ *
+ * {@link FlagClient} constructs one hub when `shareConnection` is enabled (the
+ * browser default). The leader opens SSE; followers use
+ * {@link ConnectionShareHub.createFollowerTransport} instead.
+ *
+ * @template C Evaluation context forwarded from follower `updateContext` calls.
+ * @template T Flag value type in snapshots broadcast by the leader.
+ */
+export declare class ConnectionShareHub<C = Record<string, unknown>, T = unknown> {
+    private readonly apiKey;
+    /** Stable id for this document in channel messages and the lock record. */
+    readonly memberId: string;
+    private role;
+    private channel;
+    private heartbeatId;
+    private watchId;
+    private closed;
+    private latestFlags;
+    private flagsWaiters;
+    private flagsTimeouts;
+    private contextWaiters;
+    private onPromoteCallback?;
+    private leaderContextHandler?;
+    private followerFlagsCallback?;
+    private followerErrorCallback?;
+    private readonly now;
+    private readonly storage;
+    private readonly channelFactory?;
+    private readonly setTimer;
+    private readonly clearTimer;
+    private readonly delay;
+    private unloadHandler?;
+    private readonly lockKey;
+    private readonly channelName;
+    /**
+     * @param apiKey Share groups are keyed by API key. Distinct keys never share.
+     * @param options Optional test doubles for channel, storage, and timers.
+     */
+    constructor(apiKey: string, options?: ConnectionShareOptions);
+    /** `leader` if this document holds the lock; otherwise `follower`. */
+    get currentRole(): ShareRole;
+    /**
+     * Join the share group: compete for the lock, subscribe to the channel.
+     *
+     * If {@link BroadcastChannel} is missing, this member becomes leader locally
+     * and never shares (same as a Node process).
+     *
+     * @returns The role this member should take. Only the leader should call
+     * ASL handshake / `SseTransport.init()`.
+     */
+    join(): Promise<ShareRole>;
+    /**
+     * Invoked after a follower wins the lock (leader `bye` or expired heartbeat).
+     * The client should open a real transport here, then
+     * {@link ConnectionShareHub.broadcastFlags}.
+     */
+    onPromote(callback: () => void | Promise<void>): void;
+    /**
+     * Leader-only: run `updateContext` on the real transport when a follower
+     * sends `context-request`. The context is whatever that same-origin
+     * document posted; the leader does not authenticate the sender beyond origin.
+     */
+    setLeaderContextHandler(handler: (context: C, options?: {
+        persist?: boolean;
+    }) => Promise<Record<string, T>>): void;
+    /**
+     * Leader-only: publish the current evaluated flags to all followers.
+     * No-op on followers (avoids echo loops).
+     */
+    broadcastFlags(flags: Record<string, T>): void;
+    /** Leader-only: mirror a transport `onError` (auth, quota) to followers. */
+    broadcastError(error: Error): void;
+    /**
+     * Transport used by follower FlagClients. `init` waits for the leader
+     * snapshot; `fetchFlags` RPCs `updateContext` through the leader.
+     * `destroy` is a no-op — {@link ConnectionShareHub.destroy} owns teardown.
+     */
+    createFollowerTransport(): Transport<C, T>;
+    /**
+     * Leave the share group. Leaders release the lock and post `bye` so another
+     * iframe can open the stream. Also invoked from `pagehide` / `beforeunload`.
+     * Channel close is deferred one tick so `bye` can flush on native
+     * {@link BroadcastChannel}.
+     */
+    destroy(): void;
+    private bindUnloadListener;
+    private unbindUnloadListener;
+    /**
+     * JSON-clone then post. Native `BroadcastChannel` structured-clones the
+     * payload; Vue reactive Proxies and similar host objects throw
+     * `DataCloneError`. JSON.stringify can walk those Proxies.
+     */
+    private post;
+    /** Open the BroadcastChannel for this API key, or a test factory channel. */
+    private openChannel;
+    /** Mark this member leader and start lock heartbeat + `alive` pings. */
+    private becomeLeader;
+    /**
+     * Follower poll: if the lock is free or expired, take it and run
+     * {@link ConnectionShareHub.onPromote}.
+     */
+    private maybeTakeover;
+    /** Dispatch a {@link ShareMessage} from another document in the group. */
+    private handleMessage;
+    /**
+     * Leader: evaluate a follower's context on the real transport and reply.
+     * Any same-origin document can trigger this; the resulting flags are
+     * broadcast to the whole group.
+     */
+    private handleContextRequest;
+    /**
+     * Block until the leader has sent a `flags` snapshot, or {@link FOLLOWER_WAIT_MS}.
+     * Used by follower `init()`.
+     */
+    private waitForFlags;
+    /**
+     * Follower `fetchFlags`: ask the leader to POST `/context` and wait for
+     * `context-result`. Leaders run the handler locally.
+     *
+     * The posted context is not origin-isolated beyond BroadcastChannel itself.
+     * Untrusted same-origin frames must not share a connection with a trusted
+     * leader — set `shareConnection: false` on those clients.
+     */
+    private requestContextUpdate;
+    /** Read the leadership lock, or `null` if missing/corrupt. */
+    private readLock;
+    /**
+     * Write the lock, wait so a competing write can land, then re-read.
+     * localStorage has no compare-and-set; the delay plus confirm is the
+     * best we can do so two iframes do not both become leader.
+     *
+     * @returns `true` if this member still owns the lock after the confirm.
+     */
+    private tryAcquireLock;
+    /** Extend lock expiry; no-op if another member stole the lock. */
+    private refreshLock;
+    /** Drop the lock only if this member still owns it. */
+    private releaseLock;
+}

package/dist/sdk/core/helpers/jsonCloneable.d.ts

@@ -0,0 +1,2 @@
+export declare const ERR_CONTEXT_NOT_CLONEABLE = "ERR_CONTEXT_NOT_CLONEABLE";
+export declare function toJsonCloneable<T>(value: T): T;

package/dist/sdk/core/transports/SSETransport.d.ts

@@ -0,0 +1,142 @@
+import type { Transport } from './Transport';
+export interface SseTransportConfig<C = unknown, T = unknown> {
+    endpoint: string;
+    apiKey: string;
+    context: any;
+    wrapper?: {
+        name: string;
+        version: string;
+    };
+    EventSourceImpl?: any;
+    /**
+     * When true, stream uses config-sync (`fullConfig` / `sinceVersion`) and
+     * listens for lease / fullConfig / delta / deltas instead of evaluated `flags`.
+     */
+    configSync?: boolean;
+    /** Build config-mode query params for each connect/reconnect. */
+    getConfigSyncParams?: () => {
+        wantFullConfig: boolean;
+        sinceVersion?: number;
+    };
+    /**
+     * Apply a signed config-sync payload (verify + reduce). Return whether the
+     * rules store is ready enough to publish evaluated flags.
+     */
+    onConfigSyncEvent?: (eventName: 'lease' | 'fullConfig' | 'delta' | 'deltas', payload: Record<string, unknown>) => {
+        publish: boolean;
+    };
+    /** Evaluate current rules store against the given (or last) context. */
+    getEvaluatedFlags?: (context: C) => Record<string, T>;
+    /** Analytics map from the rules store (flag key → analytics_enabled). */
+    getAnalyticsMap?: () => Record<string, boolean>;
+    /**
+     * When true (config sync), POST /context is fire-and-forget telemetry —
+     * flags are re-evaluated locally and returned immediately.
+     */
+    contextAsTelemetry?: boolean;
+    /**
+     * API base for `POST …/context` (defaults to `endpoint`). Use the API host
+     * when `endpoint` is a stream-only hostname.
+     */
+    contextEndpoint?: string;
+}
+/**
+ * A Server-Sent Events (SSE) transport implementation responsible for
+ * maintaining a persistent streaming connection to the Flagmint platform.
+ *
+ * Handshake: `POST /auth/asl-handshake` issues a single-use sessionId.
+ * Stream: `GET {endpoint}/stream?sessionId&context&sdkVersion&platform&wrapper*`
+ *   emits `connected` then `flags`. Heartbeats are SSE comments (`: heartbeat`)
+ *   and are not visible to EventSource — they only keep the TCP connection alive.
+ * Context: `POST {contextEndpoint|endpoint}/context` with `x-api-key` returns 202 and the
+ *   re-evaluated flags arrive on the existing stream after a 400ms debounce.
+ *   Prefer the API host when `endpoint` is stream-only (`STREAM_HOSTS`).
+ *
+ * @template C The shape of the evaluation context sent to the Flagmint server.
+ * @template T The feature flag value type returned by the platform.
+ *
+ * @implements {Transport<C, T>}
+ */
+export declare class SseTransport<C, T> implements Transport<C, T> {
+    private endpoint;
+    private sessionId;
+    private refreshTokenCallback?;
+    private configOptions?;
+    private eventSource;
+    private flags;
+    private context;
+    private lastSentContext;
+    private connectionId;
+    private onFlagsUpdatedCallback?;
+    private onAnalyticsUpdatedCallback?;
+    private onErrorCallback?;
+    private initialFlagsReceived;
+    private initialFlagsResolve;
+    private initialFlagsReject;
+    private nextFlagsResolve;
+    private connectPromise;
+    private connectResolve;
+    private connectReject;
+    private connectionListener?;
+    private flagsListener?;
+    private leaseListener?;
+    private fullConfigListener?;
+    private deltaListener?;
+    private deltasListener?;
+    private quotaListener?;
+    private errorListener?;
+    private reconnectTimeoutId;
+    private reconnectAttempts;
+    private terminalClose;
+    private contextUpdateQueue;
+    /** Wall time when the current SSE `connected` event was received (debug lifecycle). */
+    private connectedAtMs;
+    constructor(endpoint: string, sessionId: string, initialContext: C, refreshTokenCallback?: (() => Promise<string>) | undefined, configOptions?: Partial<SseTransportConfig<C, T>> | undefined);
+    private get configSyncEnabled();
+    init(): Promise<void>;
+    /**
+     * POST /v2/flags/context. FF-EU always returns 202 and pushes the next
+     * `flags` event on the open SSE stream (after a 400ms debounce). The HTTP
+     * body does not contain evaluated flags — browser and Node share this path.
+     */
+    fetchFlags(context: C, options?: {
+        persist?: boolean;
+    }): Promise<Record<string, T>>;
+    onFlagsUpdated(callback: (flags: Record<string, T>) => void): void;
+    onAnalyticsUpdated(callback: (analytics: Record<string, boolean>) => void): void;
+    onError(callback: (error: Error) => void): void;
+    destroy(): void;
+    /**
+     * Opt-in SSE lifecycle lines (`FlagClient` `debugLog: true`).
+     * Example: `[SseTransport] disconnected connectionId=… upMs=900012 reason=network_error retryInMs=1500`
+     */
+    private logLifecycle;
+    private logLifecycleConnected;
+    private logLifecycleDisconnected;
+    private get apiKey();
+    /** Host for POST /context — API when stream host is SSE-only. */
+    private get contextBase();
+    private applyFlags;
+    private emitError;
+    private performContextUpdate;
+    /** Fire-and-forget observed-context telemetry for config-sync mode. */
+    private postContextTelemetry;
+    private safeReadJson;
+    private quotaExtra;
+    private handleQuotaPayload;
+    private cleanupEventSource;
+    private resolveEventSourceImpl;
+    private connect;
+    private scheduleActiveReconnection;
+    private createConnectionListener;
+    private createFlagsListener;
+    private createConfigSyncListener;
+    private createQuotaListener;
+    /**
+     * Named `error` events from FF-EU (`event: error`) after the stream is hijacked.
+     * Distinct from EventSource.onerror, which fires on network/connection failure.
+     */
+    private createStreamErrorListener;
+    private mapStreamErrorCode;
+    private resetInitialResolvers;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagmint-js-sdk",
-  "version": "1.2.26",
+  "version": "2.2.0",
   "description": "Framework-agnostic JavaScript SDK for managing feature flags in Flagmint applications.",
   "author": "Flagmint Team",
   "license": "BSD 3-Clause",
@@ -22,7 +22,10 @@
   "scripts": {
     "clean": "rimraf dist",
     "build": "npm run clean && vite build",
-    "test": "jest --runInBand --detectOpenHandles"
+    "test": "jest --runInBand --detectOpenHandles",
+    "simulate:unreachable": "npm run build && node ./scripts/simulate-unreachable-server.js",
+    "simulate:cache-fallback": "npm run build && node ./scripts/simulate-cache-adapter-fallback.js",
+    "simulate:asl-gen": "npm run build && node ./scripts/test-asl-handshake.mjs"
   },
   "peerDependencies": {
     "crypto": "*"
@@ -42,7 +45,11 @@
     "vite-plugin-dts": "^2.0.0"
   },
   "dependencies": {
-    "buffer": "^6.0.3"
+    "@noble/ciphers": "^2.2.0",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
+    "buffer": "^6.0.3",
+    "node-fetch": "^3.3.2"
   },
   "optionalDependencies": {
     "ws": "^8.0.0"

package/dist/sdk/core/transports/WebsocketTransport.d.ts

@@ -1,33 +0,0 @@
-import type { Transport } from './Transport';
-type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'failed';
-export declare class WebSocketTransport<C, T> implements Transport<C, T> {
-    private wsUrl;
-    private apiKey;
-    private maxRetries;
-    private initialBackoffMs;
-    private socket;
-    private flags;
-    private context;
-    private isReady;
-    private initialFlagsReceived;
-    private initialFlagsPromise;
-    private initialFlagsResolve;
-    private initialFlagsReject;
-    private onFlagsUpdatedCallback?;
-    private onConnectionStateCallback?;
-    private retries;
-    private reconnectTimeoutId;
-    constructor(wsUrl: string, apiKey: string, maxRetries?: number, initialBackoffMs?: number);
-    init(): Promise<void>;
-    private waitForInitialFlags;
-    private connectWithRetry;
-    private cleanupSocket;
-    private setConnectionState;
-    private getWebSocketImplementation;
-    fetchFlags(context: C): Promise<Record<string, T>>;
-    onFlagsUpdated(callback: (flags: Record<string, T>) => void): void;
-    onConnectionStateChanged(callback: (state: ConnectionState) => void): void;
-    destroy(): void;
-    private sendContext;
-}
-export {};