featuredrop 1.1.0 → 1.3.0

package/dist/index.d.cts

@@ -1,7 +1,13 @@
+import { z } from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
 /** Entry type label — determines default icon/color in UI */
 type FeatureType = "feature" | "improvement" | "fix" | "breaking";
 /** Priority level for announcements */
 type FeaturePriority = "critical" | "normal" | "low";
+/** Motion preset for built-in component transitions */
+type FeatureDropAnimationPreset = "none" | "subtle" | "normal" | "playful";
 /** Call-to-action for a feature entry */
 interface FeatureCTA {
     /** Button/link label */
@@ -9,6 +15,106 @@ interface FeatureCTA {
     /** URL to navigate to */
     url: string;
 }
+/** Variant-level overrides for A/B announcement testing */
+interface FeatureVariant {
+    /** Optional variant-specific label override */
+    label?: string;
+    /** Optional variant-specific description override */
+    description?: string;
+    /** Optional variant-specific image override */
+    image?: string;
+    /** Optional variant-specific CTA override */
+    cta?: FeatureCTA;
+    /** Optional variant-specific metadata overrides */
+    meta?: Record<string, unknown>;
+}
+/** Audience targeting rule — determines which user segments see a feature */
+interface AudienceRule {
+    /** Plans that should see this feature (e.g. ["pro", "enterprise"]) */
+    plan?: string[];
+    /** Roles that should see this feature (e.g. ["admin", "editor"]) */
+    role?: string[];
+    /** Regions that should see this feature (e.g. ["us", "eu"]) */
+    region?: string[];
+    /** Arbitrary key-value pairs for custom matching logic */
+    custom?: Record<string, unknown>;
+}
+/** User context for audience targeting */
+interface UserContext {
+    /** Current user's plan (e.g. "pro", "free") */
+    plan?: string;
+    /** Current user's role (e.g. "admin", "viewer") */
+    role?: string;
+    /** Current user's region (e.g. "us", "eu") */
+    region?: string;
+    /** Arbitrary traits for custom matching logic */
+    traits?: Record<string, unknown>;
+}
+/** Custom audience matcher function */
+type AudienceMatchFn = (audience: AudienceRule, userContext: UserContext) => boolean;
+/** Feature flag resolver interface for gating announcement visibility */
+interface FeatureFlagBridge {
+    isEnabled: (flagKey: string, userContext?: UserContext) => boolean;
+}
+/** Dependency gates for progressive feature discovery */
+interface FeatureDependencies {
+    /** Features the user must have seen before this one can surface */
+    seen?: string[];
+    /** Features the user must have clicked before this one can surface */
+    clicked?: string[];
+    /** Features the user must have dismissed before this one can surface */
+    dismissed?: string[];
+}
+/** Runtime interaction state used to resolve dependency chains */
+interface FeatureDependencyState {
+    /** IDs marked as seen */
+    seenIds?: ReadonlySet<string>;
+    /** IDs marked as clicked */
+    clickedIds?: ReadonlySet<string>;
+    /** IDs marked as dismissed */
+    dismissedIds?: ReadonlySet<string>;
+}
+/** Runtime context used by trigger evaluation */
+interface TriggerContext {
+    /** Current app route/path */
+    path?: string;
+    /** Named events observed in this session */
+    events?: ReadonlySet<string>;
+    /** Named milestone flags reached in this session */
+    milestones?: ReadonlySet<string>;
+    /** Usage counters keyed by event/pattern name */
+    usage?: Record<string, number>;
+    /** Session elapsed time in milliseconds */
+    elapsedMs?: number;
+    /** Scroll completion percentage (0-100) */
+    scrollPercent?: number;
+    /** Optional additional trigger context */
+    metadata?: Record<string, unknown>;
+}
+type FeatureTrigger = {
+    type: "page";
+    match: string | RegExp;
+} | {
+    type: "usage";
+    event: string;
+    minActions?: number;
+} | {
+    type: "time";
+    minSeconds: number;
+} | {
+    type: "milestone";
+    event: string;
+} | {
+    type: "frustration";
+    pattern: string;
+    threshold?: number;
+} | {
+    type: "scroll";
+    minPercent?: number;
+} | {
+    type: "custom";
+    evaluate: (context: TriggerContext) => boolean;
+};
 /** A single feature entry in the manifest */
 interface FeatureEntry {
     /** Unique identifier for the feature */
@@ -17,6 +123,20 @@ interface FeatureEntry {
     label: string;
     /** Optional longer description (supports markdown in UI components) */
     description?: string;
+    /**
+     * Semantic version targeting.
+     * If provided as an object, requires `appVersion` to be supplied to the provider/helpers.
+     * - introduced: earliest app version that includes this feature
+     * - showNewUntil: stop showing "new" once appVersion reaches this
+     * - deprecatedAt: hide feature for app versions at or above this (optional safety)
+     * - showIn: range string, e.g. ">=2.5.0 <3.0.0"
+     */
+    version?: string | {
+        introduced?: string;
+        showNewUntil?: string;
+        deprecatedAt?: string;
+        showIn?: string;
+    };
     /** ISO date when this feature was released */
     releasedAt: string;
     /** ISO date after which the "new" badge should stop showing */
@@ -25,10 +145,12 @@ interface FeatureEntry {
     sidebarKey?: string;
     /** Optional grouping category (e.g. "ai", "billing", "core") */
     category?: string;
+    /** Optional product scope (`"*"`, `"askverdict"`, etc.) for multi-product manifests */
+    product?: string;
     /** Optional URL to link to (e.g. docs page, changelog entry) */
     url?: string;
-    /** Optional version string when this feature shipped */
-    version?: string;
+    /** Optional feature flag key; requires a flag bridge to evaluate */
+    flagKey?: string;
     /** Entry type — determines default icon/color in UI components */
     type?: FeatureType;
     /** Priority level — critical entries get special treatment in UI */
@@ -41,6 +163,16 @@ interface FeatureEntry {
     publishAt?: string;
     /** Optional arbitrary metadata */
     meta?: Record<string, unknown>;
+    /** A/B variants keyed by variant name (e.g. control, treatment_a) */
+    variants?: Record<string, FeatureVariant>;
+    /** Percentage split per variant (same order as variants object keys) */
+    variantSplit?: number[];
+    /** Audience targeting — if set, only matching users see this feature */
+    audience?: AudienceRule;
+    /** Dependency requirements (progressive disclosure sequencing) */
+    dependsOn?: FeatureDependencies;
+    /** Contextual trigger rule */
+    trigger?: FeatureTrigger;
 }
 /** The full feature manifest — an array of feature entries */
 type FeatureManifest = readonly FeatureEntry[];
@@ -61,6 +193,34 @@ interface StorageAdapter {
     /** Dismiss all features — sets watermark to `now` and clears dismissals */
     dismissAll(now: Date): Promise<void>;
 }
+/** Extended server-side dismissal state */
+interface DismissalState {
+    /** Server-side watermark */
+    watermark: string | null;
+    /** Dismissed feature IDs */
+    dismissedIds: string[];
+    /** ISO timestamp of last interaction */
+    lastSeen: string;
+    /** Estimated device count contributing to this state */
+    deviceCount: number;
+}
+/** Server-capable storage adapter */
+interface ServerStorageAdapter extends StorageAdapter {
+    /** Current user for this adapter instance */
+    userId: string;
+    /** Pull latest state from the server/database */
+    sync(): Promise<void>;
+    /** Dismiss multiple features at once */
+    dismissBatch(ids: string[]): Promise<void>;
+    /** Reset state for a target user */
+    resetUser(userId: string): Promise<void>;
+    /** Fetch multiple users' state */
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    /** Health check */
+    isHealthy(): Promise<boolean>;
+    /** Cleanup resources */
+    destroy(): Promise<void>;
+}
 /** Analytics event callbacks — pipe to your analytics provider */
 interface AnalyticsCallbacks {
     /** Fired when a feature badge becomes visible to the user */
@@ -77,6 +237,15 @@ interface AnalyticsCallbacks {
     onAllDismissed?: () => void;
 }
 
+/**
+ * Default audience matching logic.
+ *
+ * For each specified field (plan, role, region), checks if the user's
+ * value is included in the allowed list. Fields use AND logic between them,
+ * OR logic within each field's array. The `custom` field is ignored by
+ * the default matcher — use a custom `AudienceMatchFn` for that.
+ */
+declare function matchesAudience(audience: AudienceRule, userContext: UserContext): boolean;
 /**
  * Check if a single feature should show as "new".
  *
@@ -85,24 +254,27 @@ interface AnalyticsCallbacks {
  * 2. Feature was released after the watermark (or no watermark exists)
  * 3. Feature has not been individually dismissed
  * 4. If `publishAt` is set, current time must be after it (scheduled publishing)
+ * 5. If `audience` is set, user must match the targeting rules
+ * 6. If `flagKey` is set, the flag bridge must resolve it as enabled
+ * 7. If `product` is set, it must match the current product scope
  */
-declare function isNew(feature: FeatureEntry, watermark: string | null, dismissedIds: ReadonlySet<string>, now?: Date): boolean;
+declare function isNew(feature: FeatureEntry, watermark: string | null, dismissedIds: ReadonlySet<string>, now?: Date, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext, flagBridge?: FeatureFlagBridge, product?: string): boolean;
 /**
  * Get all features that are currently "new" for this user.
  */
-declare function getNewFeatures(manifest: FeatureManifest, storage: StorageAdapter, now?: Date): FeatureEntry[];
+declare function getNewFeatures(manifest: FeatureManifest, storage: StorageAdapter, now?: Date, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext, flagBridge?: FeatureFlagBridge, product?: string): FeatureEntry[];
 /**
  * Get the count of new features.
  */
-declare function getNewFeatureCount(manifest: FeatureManifest, storage: StorageAdapter, now?: Date): number;
+declare function getNewFeatureCount(manifest: FeatureManifest, storage: StorageAdapter, now?: Date, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext, flagBridge?: FeatureFlagBridge, product?: string): number;
 /**
  * Check if a specific sidebar key has a new feature.
  */
-declare function hasNewFeature(manifest: FeatureManifest, sidebarKey: string, storage: StorageAdapter, now?: Date): boolean;
+declare function hasNewFeature(manifest: FeatureManifest, sidebarKey: string, storage: StorageAdapter, now?: Date, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext, flagBridge?: FeatureFlagBridge, product?: string): boolean;
 /**
  * Get all features sorted by priority (critical first) then by release date (newest first).
  */
-declare function getNewFeaturesSorted(manifest: FeatureManifest, storage: StorageAdapter, now?: Date): FeatureEntry[];
+declare function getNewFeaturesSorted(manifest: FeatureManifest, storage: StorageAdapter, now?: Date, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext, flagBridge?: FeatureFlagBridge, product?: string): FeatureEntry[];
 
 /**
  * Create a frozen feature manifest from an array of entries.
@@ -117,7 +289,895 @@ declare function getFeatureById(manifest: FeatureManifest, id: string): FeatureE
 /**
  * Get all new features in a specific category.
  */
-declare function getNewFeaturesByCategory(manifest: FeatureManifest, category: string, storage: StorageAdapter, now?: Date): FeatureEntry[];
+declare function getNewFeaturesByCategory(manifest: FeatureManifest, category: string, storage: StorageAdapter, now?: Date, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string): FeatureEntry[];
+
+/**
+ * Parse a feature description from markdown into sanitized HTML.
+ * - Uses `marked` when installed (optional peer dep)
+ * - Falls back to a tiny built-in parser when `marked` is absent
+ * - Strips script tags, event handlers, and javascript:/data: URLs
+ */
+declare function parseDescription(markdown: string): string;
+
+interface ChangelogRendererOptions {
+    manifest: FeatureManifest;
+    storage: StorageAdapter;
+    userContext?: UserContext;
+    matchAudience?: AudienceMatchFn;
+    appVersion?: string;
+    flagBridge?: FeatureFlagBridge;
+    product?: string;
+    now?: () => Date;
+}
+interface ChangelogRendererState {
+    manifest: FeatureManifest;
+    newFeatures: FeatureEntry[];
+    newFeaturesSorted: FeatureEntry[];
+    newCount: number;
+    watermark: string | null;
+    dismissedIds: ReadonlySet<string>;
+}
+interface ChangelogRendererActions {
+    refresh: () => void;
+    dismiss: (id: string) => void;
+    dismissAll: () => Promise<void>;
+    setManifest: (manifest: FeatureManifest) => void;
+    setUserContext: (userContext?: UserContext) => void;
+    setAppVersion: (appVersion?: string) => void;
+    setAudienceMatcher: (matchAudience?: AudienceMatchFn) => void;
+    setFlagBridge: (flagBridge?: FeatureFlagBridge) => void;
+    setProduct: (product?: string) => void;
+}
+interface ChangelogRendererComputed {
+    isNew: (sidebarKey: string) => boolean;
+    getFeature: (sidebarKey: string) => FeatureEntry | undefined;
+    getFeatureById: (id: string) => FeatureEntry | undefined;
+    getFeaturesByCategory: (category: string) => FeatureEntry[];
+}
+interface ChangelogRenderer {
+    readonly state: ChangelogRendererState;
+    readonly actions: ChangelogRendererActions;
+    readonly computed: ChangelogRendererComputed;
+    subscribe: (listener: (state: ChangelogRendererState) => void) => () => void;
+}
+declare function createChangelogRenderer({ manifest: initialManifest, storage, userContext: initialUserContext, matchAudience: initialMatchAudience, appVersion: initialAppVersion, flagBridge: initialFlagBridge, product: initialProduct, now, }: ChangelogRendererOptions): ChangelogRenderer;
+
+interface SlackBridgeOptions {
+    webhookUrl: string;
+    username?: string;
+    iconEmoji?: string;
+    channel?: string;
+    formatter?: (feature: FeatureEntry) => Record<string, unknown>;
+}
+declare const SlackBridge: {
+    notify(feature: FeatureEntry, options: SlackBridgeOptions): Promise<void>;
+};
+interface DiscordBridgeOptions {
+    webhookUrl: string;
+    username?: string;
+    avatarUrl?: string;
+    formatter?: (feature: FeatureEntry) => Record<string, unknown>;
+}
+declare const DiscordBridge: {
+    notify(feature: FeatureEntry, options: DiscordBridgeOptions): Promise<void>;
+};
+interface WebhookBridgeOptions {
+    url: string;
+    headers?: Record<string, string>;
+    event?: string;
+    body?: Record<string, unknown>;
+}
+declare const WebhookBridge: {
+    post(feature: FeatureEntry, options: WebhookBridgeOptions): Promise<void>;
+};
+interface EmailDigestGeneratorOptions {
+    title?: string;
+    intro?: string;
+    template?: "default" | "minimal";
+    productName?: string;
+}
+declare const EmailDigestGenerator: {
+    generate(features: readonly FeatureEntry[], options?: EmailDigestGeneratorOptions): string;
+};
+interface RSSFeedGeneratorOptions {
+    title?: string;
+    link?: string;
+    description?: string;
+}
+declare const RSSFeedGenerator: {
+    generate(manifest: FeatureManifest, options?: RSSFeedGeneratorOptions): string;
+};
+
+interface ValidationIssue {
+    path: string;
+    message: string;
+    code: "invalid_type" | "missing_required" | "invalid_value" | "invalid_date" | "duplicate_id" | "circular_dependency";
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+}
+declare const featureEntryJsonSchema: {
+    readonly type: "object";
+    readonly required: readonly ["id", "label", "releasedAt", "showNewUntil"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+        };
+        readonly label: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+        };
+        readonly releasedAt: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly showNewUntil: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly flagKey: {
+            readonly type: "string";
+        };
+        readonly product: {
+            readonly type: "string";
+        };
+        readonly url: {
+            readonly type: "string";
+        };
+        readonly image: {
+            readonly type: "string";
+        };
+        readonly type: {
+            readonly enum: readonly ["feature", "improvement", "fix", "breaking"];
+        };
+        readonly priority: {
+            readonly enum: readonly ["critical", "normal", "low"];
+        };
+        readonly cta: {
+            readonly type: "object";
+            readonly properties: {
+                readonly label: {
+                    readonly type: "string";
+                };
+                readonly url: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly meta: {
+            readonly type: "object";
+        };
+    };
+};
+declare const featureManifestJsonSchema: {
+    readonly type: "array";
+    readonly items: {
+        readonly type: "object";
+        readonly required: readonly ["id", "label", "releasedAt", "showNewUntil"];
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+            };
+            readonly label: {
+                readonly type: "string";
+            };
+            readonly description: {
+                readonly type: "string";
+            };
+            readonly releasedAt: {
+                readonly type: "string";
+                readonly format: "date-time";
+            };
+            readonly showNewUntil: {
+                readonly type: "string";
+                readonly format: "date-time";
+            };
+            readonly flagKey: {
+                readonly type: "string";
+            };
+            readonly product: {
+                readonly type: "string";
+            };
+            readonly url: {
+                readonly type: "string";
+            };
+            readonly image: {
+                readonly type: "string";
+            };
+            readonly type: {
+                readonly enum: readonly ["feature", "improvement", "fix", "breaking"];
+            };
+            readonly priority: {
+                readonly enum: readonly ["critical", "normal", "low"];
+            };
+            readonly cta: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly label: {
+                        readonly type: "string";
+                    };
+                    readonly url: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly meta: {
+                readonly type: "object";
+            };
+        };
+    };
+};
+declare const featureEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    releasedAt: z.ZodEffects<z.ZodString, string, string>;
+    showNewUntil: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    flagKey: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
+    cta: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        url: string;
+    }, {
+        label: string;
+        url: string;
+    }>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodOptional<z.ZodObject<{
+        seen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        clicked: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dismissed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    label: z.ZodString;
+    releasedAt: z.ZodEffects<z.ZodString, string, string>;
+    showNewUntil: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    flagKey: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
+    cta: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        url: string;
+    }, {
+        label: string;
+        url: string;
+    }>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodOptional<z.ZodObject<{
+        seen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        clicked: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dismissed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    label: z.ZodString;
+    releasedAt: z.ZodEffects<z.ZodString, string, string>;
+    showNewUntil: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    flagKey: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
+    cta: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        url: string;
+    }, {
+        label: string;
+        url: string;
+    }>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodOptional<z.ZodObject<{
+        seen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        clicked: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dismissed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const featureManifestSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    releasedAt: z.ZodEffects<z.ZodString, string, string>;
+    showNewUntil: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    flagKey: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
+    cta: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        url: string;
+    }, {
+        label: string;
+        url: string;
+    }>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodOptional<z.ZodObject<{
+        seen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        clicked: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dismissed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    label: z.ZodString;
+    releasedAt: z.ZodEffects<z.ZodString, string, string>;
+    showNewUntil: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    flagKey: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
+    cta: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        url: string;
+    }, {
+        label: string;
+        url: string;
+    }>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodOptional<z.ZodObject<{
+        seen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        clicked: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dismissed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    label: z.ZodString;
+    releasedAt: z.ZodEffects<z.ZodString, string, string>;
+    showNewUntil: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    flagKey: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
+    cta: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        url: string;
+    }, {
+        label: string;
+        url: string;
+    }>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodOptional<z.ZodObject<{
+        seen: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        clicked: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dismissed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }, {
+        seen?: string[] | undefined;
+        clicked?: string[] | undefined;
+        dismissed?: string[] | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>, "many">;
+declare function validateManifest(data: unknown): ValidationResult;
+
+interface ChangedFeature {
+    id: string;
+    before: FeatureEntry;
+    after: FeatureEntry;
+    changedFields: string[];
+}
+interface ManifestDiff {
+    added: FeatureEntry[];
+    removed: FeatureEntry[];
+    changed: ChangedFeature[];
+}
+declare function diffManifest(before: FeatureManifest, after: FeatureManifest): ManifestDiff;
+interface ChangelogDiffOptions {
+    includeFieldChanges?: boolean;
+}
+declare function generateChangelogDiff(diff: ManifestDiff, options?: ChangelogDiffOptions): string;
+declare function validateManifestForCI(manifest: FeatureManifest): ValidationResult;
+
+interface CreateFlagBridgeOptions {
+    isEnabled: (flagKey: string, userContext?: UserContext) => boolean;
+}
+declare function createFlagBridge(options: CreateFlagBridgeOptions): FeatureFlagBridge;
+interface LaunchDarklyClientLike {
+    variation: (flagKey: string, user: Record<string, unknown>, defaultValue: boolean) => boolean;
+}
+interface LaunchDarklyBridgeOptions {
+    userResolver?: (userContext?: UserContext) => Record<string, unknown>;
+    defaultValue?: boolean;
+}
+declare class LaunchDarklyBridge implements FeatureFlagBridge {
+    private readonly client;
+    private readonly options;
+    constructor(client: LaunchDarklyClientLike, options?: LaunchDarklyBridgeOptions);
+    isEnabled(flagKey: string, userContext?: UserContext): boolean;
+}
+interface PostHogClientLike {
+    isFeatureEnabled: (flagKey: string, distinctId?: string, groups?: Record<string, string>, personProperties?: Record<string, unknown>) => boolean;
+}
+interface PostHogBridgeOptions {
+    distinctIdResolver?: (userContext?: UserContext) => string | undefined;
+    groupsResolver?: (userContext?: UserContext) => Record<string, string> | undefined;
+}
+declare class PostHogBridge implements FeatureFlagBridge {
+    private readonly client;
+    private readonly options;
+    constructor(client: PostHogClientLike, options?: PostHogBridgeOptions);
+    isEnabled(flagKey: string, userContext?: UserContext): boolean;
+}
+
+interface ManifestEditorProps {
+    features: readonly FeatureEntry[];
+    onSave: (updated: FeatureEntry[]) => Promise<void> | void;
+    readOnly?: boolean;
+    children?: ReactNode;
+}
+declare function ManifestEditor({ features, onSave, readOnly, children, }: ManifestEditorProps): react_jsx_runtime.JSX.Element;
+interface ScheduleCalendarProps {
+    features: readonly FeatureEntry[];
+    onSchedule: (featureId: string, publishAt: string) => Promise<void> | void;
+}
+declare function ScheduleCalendar({ features, onSchedule }: ScheduleCalendarProps): react_jsx_runtime.JSX.Element;
+interface PreviewPanelProps {
+    feature?: FeatureEntry | null;
+    components?: Array<"badge" | "changelog" | "spotlight" | "banner" | "toast">;
+}
+declare function PreviewPanel({ feature, components }: PreviewPanelProps): react_jsx_runtime.JSX.Element;
+interface AudienceBuilderProps {
+    segments?: string[];
+    roles?: string[];
+    regions?: string[];
+    value?: AudienceRule;
+    onChange?: (audience: AudienceRule) => void;
+    onSave?: (audience: AudienceRule) => Promise<void> | void;
+}
+declare function AudienceBuilder({ segments, roles, regions, value, onChange, onSave, }: AudienceBuilderProps): react_jsx_runtime.JSX.Element;
+
+type CMSFieldResolver = string | ((record: unknown) => unknown);
+interface CMSFieldMapping {
+    id?: CMSFieldResolver;
+    label?: CMSFieldResolver;
+    description?: CMSFieldResolver;
+    releasedAt?: CMSFieldResolver;
+    showNewUntil?: CMSFieldResolver;
+    sidebarKey?: CMSFieldResolver;
+    category?: CMSFieldResolver;
+    product?: CMSFieldResolver;
+    flagKey?: CMSFieldResolver;
+    url?: CMSFieldResolver;
+    image?: CMSFieldResolver;
+    publishAt?: CMSFieldResolver;
+    type?: CMSFieldResolver;
+    priority?: CMSFieldResolver;
+    ctaLabel?: CMSFieldResolver;
+    ctaUrl?: CMSFieldResolver;
+}
+interface CMSAdapter {
+    load: () => Promise<FeatureEntry[]>;
+}
+interface CMSAdapterBaseOptions {
+    fieldMapping?: CMSFieldMapping;
+    /** Throw when mapped entries are invalid. Default false (invalid entries are dropped). */
+    strictValidation?: boolean;
+}
+interface ContentfulAdapterOptions extends CMSAdapterBaseOptions {
+    spaceId: string;
+    accessToken: string;
+    contentType: string;
+    environment?: string;
+    locale?: string;
+    limit?: number;
+}
+interface SanityAdapterOptions extends CMSAdapterBaseOptions {
+    projectId: string;
+    dataset: string;
+    query: string;
+    token?: string;
+    apiVersion?: string;
+}
+interface StrapiAdapterOptions extends CMSAdapterBaseOptions {
+    baseUrl: string;
+    endpoint?: string;
+    token?: string;
+    query?: string;
+}
+interface NotionAdapterOptions extends CMSAdapterBaseOptions {
+    databaseId: string;
+    token: string;
+    notionVersion?: string;
+    filter?: Record<string, unknown>;
+    sorts?: Array<Record<string, unknown>>;
+}
+interface MarkdownAdapterFile {
+    source?: string;
+    markdown: string;
+}
+interface MarkdownAdapterOptions extends CMSAdapterBaseOptions {
+    pattern?: string;
+    cwd?: string;
+    entries?: MarkdownAdapterFile[];
+}
+declare class ContentfulAdapter implements CMSAdapter {
+    private readonly options;
+    constructor(options: ContentfulAdapterOptions);
+    load(): Promise<FeatureEntry[]>;
+}
+declare class SanityAdapter implements CMSAdapter {
+    private readonly options;
+    constructor(options: SanityAdapterOptions);
+    load(): Promise<FeatureEntry[]>;
+}
+declare class StrapiAdapter implements CMSAdapter {
+    private readonly options;
+    constructor(options: StrapiAdapterOptions);
+    load(): Promise<FeatureEntry[]>;
+}
+declare class NotionAdapter implements CMSAdapter {
+    private readonly options;
+    constructor(options: NotionAdapterOptions);
+    load(): Promise<FeatureEntry[]>;
+}
+declare class MarkdownAdapter implements CMSAdapter {
+    private readonly options;
+    constructor(options?: MarkdownAdapterOptions);
+    load(): Promise<FeatureEntry[]>;
+}
+
+interface FeatureDropTheme {
+    colors: {
+        primary: string;
+        background: string;
+        text: string;
+        textMuted: string;
+        border: string;
+        success: string;
+        warning: string;
+        error: string;
+    };
+    fonts: {
+        family: string;
+        sizeBase: string;
+        sizeSm: string;
+        sizeLg: string;
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    radii: {
+        sm: string;
+        md: string;
+        lg: string;
+        full: string;
+    };
+    shadows: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    zIndex: {
+        base: number;
+        tooltip: number;
+        modal: number;
+        overlay: number;
+    };
+}
+type FeatureDropThemePreset = "light" | "dark" | "auto" | "minimal" | "vibrant";
+type FeatureDropThemeOverrides = {
+    [K in keyof FeatureDropTheme]?: Partial<FeatureDropTheme[K]>;
+};
+type FeatureDropThemeInput = FeatureDropThemePreset | FeatureDropThemeOverrides | FeatureDropTheme;
+declare const FEATUREDROP_THEMES: {
+    readonly light: FeatureDropTheme;
+    readonly dark: FeatureDropTheme;
+    readonly minimal: FeatureDropTheme;
+    readonly vibrant: FeatureDropTheme;
+};
+declare function createTheme(overrides: FeatureDropThemeOverrides, base?: FeatureDropTheme): FeatureDropTheme;
+declare function resolveTheme(input?: FeatureDropThemeInput, options?: {
+    prefersDark?: boolean;
+}): FeatureDropTheme;
+declare function themeToCSSVariables(theme: FeatureDropTheme): Record<string, string | number>;
+
+interface FeatureDropTranslations {
+    newBadge: string;
+    whatsNewTitle: string;
+    markAllRead: string;
+    allCaughtUp: string;
+    close: string;
+    changelogTitle: string;
+    searchPlaceholder: string;
+    allCategories: string;
+    noUpdatesYet: string;
+    loadMore: string;
+    share: string;
+    skipToEntries: string;
+    newFeatureCount: (count: number) => string;
+    stepOf: (current: number, total: number) => string;
+    back: string;
+    next: string;
+    skip: string;
+    finish: string;
+    gotIt: string;
+    announcement: string;
+    feedbackTitle: string;
+    feedbackTrigger: string;
+    feedbackSubmitted: string;
+    submit: string;
+    cancel: string;
+    askLater: string;
+}
+declare function resolveLocale(locale?: string): string;
+declare function getLocaleDirection(locale?: string): "ltr" | "rtl";
+declare function formatDateForLocale(value: string | number | Date, locale?: string, options?: Intl.DateTimeFormatOptions): string;
+declare function formatRelativeTimeForLocale(value: string | number | Date, locale?: string, options?: {
+    now?: string | number | Date;
+    numeric?: Intl.RelativeTimeFormatNumeric;
+    style?: Intl.RelativeTimeFormatStyle;
+}): string;
+declare function resolveTranslations(locale?: string, overrides?: Partial<FeatureDropTranslations>): FeatureDropTranslations;
+declare const FEATUREDROP_TRANSLATIONS: {
+    readonly en: FeatureDropTranslations;
+};
+
+declare const FEATUREDROP_ANIMATION_PRESETS: readonly ["none", "subtle", "normal", "playful"];
+declare function resolveAnimationPreset(preset?: FeatureDropAnimationPreset, options?: {
+    reducedMotion?: boolean;
+}): FeatureDropAnimationPreset;
+type AnimationSurface = "toast" | "panel" | "modal" | "popover";
+type AnimationPhase = "enter" | "exit";
+type PulseSurface = "dot" | "beacon";
+declare function getEnterAnimation(preset: FeatureDropAnimationPreset, surface: AnimationSurface): string | undefined;
+declare function getExitAnimation(preset: FeatureDropAnimationPreset, surface: AnimationSurface): string | undefined;
+declare function getPulseAnimation(preset: FeatureDropAnimationPreset, surface?: PulseSurface): string | undefined;
+declare function getAnimationDurationMs(preset: FeatureDropAnimationPreset, surface: AnimationSurface, phase: AnimationPhase): number;
+
+/**
+ * Generate a simple RSS 2.0 feed from a feature manifest.
+ * Titles and descriptions are sanitized via `parseDescription`.
+ */
+declare function generateRSS(manifest: FeatureManifest, options?: {
+    title?: string;
+    link?: string;
+    description?: string;
+}): string;
+
+interface ThrottleOptions {
+    maxSimultaneousBadges?: number;
+    maxSimultaneousSpotlights?: number;
+    maxToastsPerSession?: number;
+    minTimeBetweenModals?: number;
+    minTimeBetweenTours?: number;
+    sessionCooldown?: number;
+    respectDoNotDisturb?: boolean;
+}
+interface ThrottleRuntimeState {
+    sessionStartedAt: number;
+    quietMode?: boolean;
+}
+interface ThrottleResult {
+    visible: FeatureEntry[];
+    queued: FeatureEntry[];
+}
+declare function applyAnnouncementThrottle(features: FeatureEntry[], options: ThrottleOptions | undefined, state: ThrottleRuntimeState, now?: number): ThrottleResult;
+
+type AdoptionEventType = "feature_seen" | "feature_clicked" | "feature_dismissed" | "tour_started" | "tour_completed" | "tour_skipped" | "checklist_task_completed" | "checklist_completed" | "survey_submitted" | "feedback_submitted" | "announcement_shown" | "cta_clicked";
+interface AdoptionEvent {
+    type: AdoptionEventType;
+    featureId?: string;
+    tourId?: string;
+    variant?: string;
+    timestamp: string;
+    sessionId?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+type AdoptionEventInput = Omit<AdoptionEvent, "timestamp"> & {
+    timestamp?: string;
+};
+interface AnalyticsAdapter {
+    track: (event: AdoptionEvent) => void | Promise<void>;
+    trackBatch?: (events: AdoptionEvent[]) => void | Promise<void>;
+}
+interface AnalyticsCollectorOptions {
+    adapter: AnalyticsAdapter;
+    batchSize?: number;
+    flushInterval?: number;
+    sampleRate?: number;
+    enabled?: boolean;
+    sessionId?: string;
+    userId?: string;
+    now?: () => Date;
+    random?: () => number;
+}
+declare class AnalyticsCollector {
+    private adapter;
+    private queue;
+    private batchSize;
+    private flushInterval;
+    private sampleRate;
+    private enabled;
+    private now;
+    private random;
+    private sessionId?;
+    private userId?;
+    private timer;
+    private flushing;
+    constructor(options: AnalyticsCollectorOptions);
+    setEnabled(enabled: boolean): void;
+    setContext(context: {
+        sessionId?: string;
+        userId?: string;
+    }): void;
+    getQueueSize(): number;
+    track(event: AdoptionEventInput): void;
+    flush(): Promise<void>;
+    destroy(): Promise<void>;
+    private startTimer;
+}
+declare class PostHogAdapter implements AnalyticsAdapter {
+    private readonly client;
+    constructor(client: {
+        capture: (event: string, properties?: Record<string, unknown>) => void;
+    });
+    track(event: AdoptionEvent): void;
+}
+declare class AmplitudeAdapter implements AnalyticsAdapter {
+    private readonly client;
+    constructor(client: {
+        track: (event: string, properties?: Record<string, unknown>) => void;
+    });
+    track(event: AdoptionEvent): void;
+}
+declare class MixpanelAdapter implements AnalyticsAdapter {
+    private readonly client;
+    constructor(client: {
+        track: (event: string, properties?: Record<string, unknown>) => void;
+    });
+    track(event: AdoptionEvent): void;
+}
+declare class SegmentAdapter implements AnalyticsAdapter {
+    private readonly client;
+    constructor(client: {
+        track: (event: string, properties?: Record<string, unknown>) => void;
+    });
+    track(event: AdoptionEvent): void;
+}
+declare class CustomAdapter implements AnalyticsAdapter {
+    private readonly handler;
+    constructor(handler: (event: AdoptionEvent) => void | Promise<void>);
+    track(event: AdoptionEvent): void | Promise<void>;
+}
+interface FeatureEngagementMetrics {
+    seen: number;
+    clicked: number;
+    dismissed: number;
+}
+interface AdoptionMetrics {
+    getAdoptionRate: (featureId: string) => number;
+    getTourCompletionRate: (tourId: string) => number;
+    getChecklistCompletionRate: (checklistId: string) => number;
+    getFeatureEngagement: (featureId: string) => FeatureEngagementMetrics;
+    getVariantPerformance: (featureId: string) => Record<string, number>;
+}
+declare function createAdoptionMetrics(events: AdoptionEvent[]): AdoptionMetrics;
+
+declare function resolveDependencyOrder(manifest: FeatureManifest): string[];
+declare function hasDependencyCycle(manifest: FeatureManifest): boolean;
+declare function sortFeaturesByDependencies(features: FeatureEntry[]): FeatureEntry[];
+
+declare function isTriggerMatch(trigger: FeatureTrigger | undefined, context?: TriggerContext): boolean;
+declare class TriggerEngine {
+    private context;
+    constructor(initial?: TriggerContext);
+    setPath(path: string): void;
+    trackEvent(event: string): void;
+    trackUsage(event: string, delta?: number): void;
+    trackMilestone(event: string): void;
+    setElapsedMs(elapsedMs: number): void;
+    setScrollPercent(scrollPercent: number): void;
+    setMetadata(next: Record<string, unknown>): void;
+    getContext(): TriggerContext;
+    evaluate(trigger: FeatureTrigger | undefined): boolean;
+    evaluateFeature(feature: Pick<FeatureEntry, "trigger">): boolean;
+}
+
+declare function getFeatureVariantName(feature: FeatureEntry): string | undefined;
+declare function applyFeatureVariant(feature: FeatureEntry, variantKey: string): FeatureEntry;
+declare function applyFeatureVariants(manifest: FeatureManifest, variantKey: string): FeatureEntry[];
+declare function getOrCreateVariantKey(explicitKey?: string): string;
+
+interface ManifestStats {
+    total: number;
+    byType: Record<string, number>;
+    byCategory: Record<string, number>;
+    newestRelease: string | null;
+    oldestRelease: string | null;
+}
+declare function computeManifestStats(entries: FeatureEntry[]): ManifestStats;
+declare function generateMarkdownChangelog(entries: FeatureEntry[]): string;
+interface DoctorReport {
+    checks: string[];
+    warnings: string[];
+    errors: string[];
+}
+declare function runDoctor(entries: FeatureEntry[], now?: Date): DoctorReport;
 
 interface LocalStorageAdapterOptions {
     /** Key prefix for localStorage entries. Default: "featuredrop" */
@@ -149,6 +1209,65 @@ declare class LocalStorageAdapter implements StorageAdapter {
     dismissAll(now: Date): Promise<void>;
 }
 
+interface IndexedDBAdapterOptions {
+    prefix?: string;
+    watermark?: string | null;
+    dbName?: string;
+    storeName?: string;
+    onDismissAll?: (now: Date) => Promise<void>;
+    /** Optional remote state fetch for offline-first sync reconciliation. */
+    onSyncState?: () => Promise<{
+        watermark?: string | null;
+        dismissedIds?: string[];
+    }>;
+    /** Optional remote flush for queued single-dismiss operations. */
+    onFlushDismissBatch?: (ids: string[]) => Promise<void>;
+    /** Optional remote flush for queued dismiss-all operations. */
+    onFlushDismissAll?: (watermark: string) => Promise<void>;
+    /** Delay before queued operations are flushed. Default: 500ms. */
+    flushDebounceMs?: number;
+    /** Attach online/visibility listeners to trigger sync+flush. Default: true in browser. */
+    autoSyncOnOnline?: boolean;
+}
+declare class IndexedDBAdapter implements StorageAdapter {
+    private readonly prefix;
+    private readonly dbName;
+    private readonly storeName;
+    private readonly onDismissAllCallback?;
+    private readonly onSyncStateCallback?;
+    private readonly onFlushDismissBatchCallback?;
+    private readonly onFlushDismissAllCallback?;
+    private readonly flushDebounceMs;
+    private readonly autoSyncOnOnline;
+    private watermark;
+    private dismissed;
+    private queue;
+    private readonly hydratePromise;
+    private flushTimer;
+    private flushing;
+    private readonly boundOnlineHandler;
+    private readonly boundVisibilityHandler;
+    constructor(options?: IndexedDBAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    /** Flush queued dismiss operations to optional remote callbacks. */
+    flushQueue(): Promise<void>;
+    /** Merge local state with optional remote source, then flush queued writes. */
+    syncFromRemote(): Promise<void>;
+    /** Cleanup optional browser listeners. */
+    destroy(): void;
+    private persist;
+    private hydrateFromIndexedDB;
+    private readIndexedDBState;
+    private writeIndexedDBState;
+    private openDb;
+    private scheduleFlush;
+    private getLastDismissAll;
+    private collectDismissBatch;
+}
+
 /**
  * In-memory storage adapter.
  *
@@ -169,4 +1288,392 @@ declare class MemoryAdapter implements StorageAdapter {
     dismissAll(now: Date): Promise<void>;
 }
 
-export { type AnalyticsCallbacks, type FeatureCTA, type FeatureEntry, type FeatureManifest, type FeaturePriority, type FeatureType, LocalStorageAdapter, type LocalStorageAdapterOptions, MemoryAdapter, type StorageAdapter, createManifest, getFeatureById, getNewFeatureCount, getNewFeatures, getNewFeaturesByCategory, getNewFeaturesSorted, hasNewFeature, isNew };
+interface RemoteAdapterOptions {
+    /** Base URL for the feature API (e.g. https://api.example.com/api/features) */
+    url: string;
+    /** Optional headers applied to all requests */
+    headers?: Record<string, string>;
+    /** Polling interval in ms for stale-while-revalidate (default: 5 minutes) */
+    fetchInterval?: number;
+    /** Data format, currently supports 'rest' (default) */
+    format?: "rest";
+    /** Optional user identifier to pass to state endpoint */
+    userId?: string;
+    /** Number of retries after the initial request (default: 3) */
+    retryAttempts?: number;
+    /** Base backoff delay used between retries (default: 250ms) */
+    retryBaseDelayMs?: number;
+    /** Consecutive failed operations before opening the circuit (default: 5) */
+    circuitBreakerThreshold?: number;
+    /** Cooldown period while the circuit is open (default: 60s) */
+    circuitBreakerCooldownMs?: number;
+    /** Optional sleep function override for test environments */
+    sleep?: (delayMs: number) => Promise<void>;
+    /** Optional timestamp function override for test environments */
+    now?: () => number;
+}
+declare class RemoteAdapter implements StorageAdapter {
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly fetchInterval;
+    private readonly userId?;
+    private dismissedIds;
+    private watermark;
+    private lastManifest;
+    private lastFetchTs;
+    private readonly retryAttempts;
+    private readonly retryBaseDelayMs;
+    private readonly circuitBreakerThreshold;
+    private readonly circuitBreakerCooldownMs;
+    private readonly sleep;
+    private readonly now;
+    private consecutiveFailures;
+    private circuitOpenUntil;
+    constructor(options: RemoteAdapterOptions);
+    /** Fetch manifest with stale-while-revalidate */
+    fetchManifest(force?: boolean): Promise<FeatureManifest>;
+    /** Fetch state (watermark + dismissed IDs) */
+    syncState(): Promise<void>;
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    /** Returns current adapter health; false while circuit breaker is open. */
+    isHealthy(): Promise<boolean>;
+    private flushDismiss;
+    private flushDismissAll;
+    private isCircuitOpen;
+    private markFailure;
+    private markSuccess;
+    private withRetry;
+}
+
+interface QueryResultRow {
+    watermark?: string | null;
+    dismissed_ids?: string[] | null;
+    dismissedIds?: string[] | null;
+    last_seen?: string | null;
+    lastSeen?: string | null;
+}
+interface PostgresQueryResult<T = QueryResultRow> {
+    rows: T[];
+    rowCount?: number | null;
+}
+type PostgresQueryFn = <T = QueryResultRow>(sql: string, params?: unknown[]) => Promise<PostgresQueryResult<T>>;
+interface PostgresAdapterOptions {
+    userId: string;
+    query: PostgresQueryFn;
+    tableName?: string;
+    autoMigrate?: boolean;
+}
+/**
+ * Postgres-backed storage adapter.
+ *
+ * This adapter is dependency-free by design and accepts a user-provided
+ * query function, allowing integration with pg, drizzle, prisma, etc.
+ */
+declare class PostgresAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly query;
+    private readonly tableName;
+    private readonly autoMigrate;
+    private watermark;
+    private dismissedIds;
+    private initialized;
+    constructor(options: PostgresAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+    private ensureReady;
+}
+
+interface RedisLikePipeline {
+    set(key: string, value: string): RedisLikePipeline;
+    del(key: string): RedisLikePipeline;
+    sadd(key: string, ...members: string[]): RedisLikePipeline;
+    exec(): Promise<unknown>;
+}
+interface RedisLikeClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<unknown>;
+    del(key: string): Promise<unknown>;
+    smembers(key: string): Promise<string[]>;
+    sadd(key: string, ...members: string[]): Promise<unknown>;
+    ping(): Promise<string>;
+    multi(): RedisLikePipeline;
+    quit?(): Promise<unknown>;
+    disconnect?(): void;
+}
+interface RedisAdapterOptions {
+    userId: string;
+    client: RedisLikeClient;
+    keyPrefix?: string;
+}
+/**
+ * Redis-backed storage adapter.
+ * Uses simple key + set structures to keep operations predictable.
+ */
+declare class RedisAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly client;
+    private readonly keyPrefix;
+    private watermark;
+    private dismissedIds;
+    constructor(options: RedisAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+    private watermarkKey;
+    private dismissedKey;
+    private lastSeenKey;
+}
+
+interface HybridAdapterOptions {
+    local: StorageAdapter;
+    remote: ServerStorageAdapter;
+    /** If true, sync from remote before writes. Default false */
+    syncBeforeWrite?: boolean;
+    /** Batch window for queued dismiss writes. Default: 500ms */
+    dismissBatchWindowMs?: number;
+    /** Optional periodic sync interval in ms. Default: disabled (0) */
+    syncIntervalMs?: number;
+    /** Sync on browser visibility return. Default: true */
+    syncOnVisibilityChange?: boolean;
+    /** Sync on browser online event. Default: true */
+    syncOnOnline?: boolean;
+}
+/**
+ * Hybrid adapter that combines local immediacy with remote persistence.
+ */
+declare class HybridAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly local;
+    private readonly remote;
+    private readonly syncBeforeWrite;
+    private readonly dismissBatchWindowMs;
+    private readonly syncIntervalMs;
+    private readonly syncOnVisibilityChange;
+    private readonly syncOnOnline;
+    private pendingDismissIds;
+    private dismissTimer;
+    private syncTimer;
+    private readonly boundVisibilityHandler;
+    private readonly boundOnlineHandler;
+    constructor(options: HybridAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+    /** Manually flush queued dismiss operations to the remote adapter. */
+    flushPendingDismisses(): Promise<void>;
+    private scheduleDismissFlush;
+}
+
+interface MySQLRow {
+    user_id?: string;
+    watermark?: string | null;
+    dismissed_ids?: string[] | string | null;
+    dismissedIds?: string[] | string | null;
+    last_seen?: string | null;
+    lastSeen?: string | null;
+}
+interface MySQLQueryResult<T = MySQLRow> {
+    rows: T[];
+}
+type MySQLQueryFn = <T = MySQLRow>(sql: string, params?: unknown[]) => Promise<MySQLQueryResult<T>>;
+interface MySQLAdapterOptions {
+    userId: string;
+    query: MySQLQueryFn;
+    tableName?: string;
+    autoMigrate?: boolean;
+}
+declare class MySQLAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly query;
+    private readonly tableName;
+    private readonly autoMigrate;
+    private watermark;
+    private dismissedIds;
+    private initialized;
+    constructor(options: MySQLAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+    private ensureReady;
+}
+
+interface MongoStateDoc {
+    userId: string;
+    watermark?: string | null;
+    dismissedIds?: string[];
+    lastSeen?: string;
+}
+interface MongoFindCursor<T> {
+    toArray: () => Promise<T[]>;
+}
+interface MongoLikeCollection {
+    findOne: (filter: Record<string, unknown>) => Promise<MongoStateDoc | null>;
+    updateOne: (filter: Record<string, unknown>, update: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
+    deleteOne: (filter: Record<string, unknown>) => Promise<unknown>;
+    find?: (filter: Record<string, unknown>) => MongoFindCursor<MongoStateDoc>;
+}
+interface MongoAdapterOptions {
+    userId: string;
+    collection: MongoLikeCollection;
+}
+declare class MongoAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly collection;
+    private watermark;
+    private dismissedIds;
+    constructor(options: MongoAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+}
+
+interface SQLiteRow {
+    user_id?: string;
+    watermark?: string | null;
+    dismissed_ids?: string[] | string | null;
+    dismissedIds?: string[] | string | null;
+    last_seen?: string | null;
+    lastSeen?: string | null;
+}
+interface SQLiteQueryResult<T = SQLiteRow> {
+    rows: T[];
+}
+type SQLiteQueryFn = <T = SQLiteRow>(sql: string, params?: unknown[]) => Promise<SQLiteQueryResult<T>>;
+interface SQLiteAdapterOptions {
+    userId: string;
+    query: SQLiteQueryFn;
+    tableName?: string;
+    autoMigrate?: boolean;
+}
+declare class SQLiteAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly query;
+    private readonly tableName;
+    private readonly autoMigrate;
+    private watermark;
+    private dismissedIds;
+    private initialized;
+    constructor(options: SQLiteAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+    private ensureReady;
+}
+
+interface SupabaseErrorLike {
+    message?: string;
+}
+interface SupabaseMaybeSingleResult<T> {
+    data: T | null;
+    error: SupabaseErrorLike | null;
+}
+interface SupabaseMutationResult {
+    error: SupabaseErrorLike | null;
+}
+interface SupabaseSelectQuery<T> {
+    eq: (column: string, value: unknown) => SupabaseSelectQuery<T>;
+    maybeSingle: () => Promise<SupabaseMaybeSingleResult<T>>;
+}
+interface SupabaseMutationQuery {
+    eq: (column: string, value: unknown) => Promise<SupabaseMutationResult>;
+}
+interface SupabaseTableClient<T> {
+    select: (columns: string) => SupabaseSelectQuery<T>;
+    upsert: (value: Record<string, unknown>) => Promise<SupabaseMutationResult>;
+    update: (value: Record<string, unknown>) => SupabaseMutationQuery;
+    delete: () => SupabaseMutationQuery;
+}
+interface SupabaseRealtimeChannelLike {
+    on: (event: "postgres_changes", filter: Record<string, unknown>, callback: () => void) => SupabaseRealtimeChannelLike;
+    subscribe: (callback?: (status: string) => void) => SupabaseRealtimeChannelLike;
+}
+interface SupabaseClientLike {
+    from: <T = SupabaseStateRow>(table: string) => SupabaseTableClient<T>;
+    channel?: (name: string) => SupabaseRealtimeChannelLike;
+    removeChannel?: (channel: SupabaseRealtimeChannelLike) => void | Promise<void>;
+}
+interface SupabaseStateRow {
+    [key: string]: unknown;
+    user_id: string;
+    watermark?: string | null;
+    dismissed_ids?: string[] | null;
+    last_seen?: string | null;
+}
+interface SupabaseAdapterOptions {
+    userId: string;
+    client: SupabaseClientLike;
+    tableName?: string;
+    realtime?: boolean;
+}
+declare class SupabaseAdapter implements ServerStorageAdapter {
+    readonly userId: string;
+    private readonly client;
+    private readonly tableName;
+    private readonly realtime;
+    private watermark;
+    private dismissedIds;
+    private realtimeChannel;
+    private syncing;
+    constructor(options: SupabaseAdapterOptions);
+    getWatermark(): string | null;
+    getDismissedIds(): ReadonlySet<string>;
+    dismiss(id: string): void;
+    dismissAll(now: Date): Promise<void>;
+    sync(): Promise<void>;
+    dismissBatch(ids: string[]): Promise<void>;
+    resetUser(userId: string): Promise<void>;
+    getBulkState(userIds: string[]): Promise<Map<string, DismissalState>>;
+    isHealthy(): Promise<boolean>;
+    destroy(): Promise<void>;
+    private fetchState;
+    private upsertState;
+    private setupRealtime;
+}
+
+export { type AdoptionEvent, type AdoptionEventInput, type AdoptionEventType, type AdoptionMetrics, AmplitudeAdapter, type AnalyticsAdapter, type AnalyticsCallbacks, AnalyticsCollector, type AnalyticsCollectorOptions, AudienceBuilder, type AudienceBuilderProps, type AudienceMatchFn, type AudienceRule, type CMSAdapter, type CMSFieldMapping, type ChangedFeature, type ChangelogDiffOptions, type ChangelogRenderer, type ChangelogRendererActions, type ChangelogRendererComputed, type ChangelogRendererOptions, type ChangelogRendererState, ContentfulAdapter, type CreateFlagBridgeOptions, CustomAdapter, DiscordBridge, type DiscordBridgeOptions, type DismissalState, EmailDigestGenerator, type EmailDigestGeneratorOptions, FEATUREDROP_ANIMATION_PRESETS, FEATUREDROP_THEMES, FEATUREDROP_TRANSLATIONS, type FeatureCTA, type FeatureDependencies, type FeatureDependencyState, type FeatureDropAnimationPreset, type FeatureDropTheme, type FeatureDropThemeInput, type FeatureDropThemeOverrides, type FeatureDropThemePreset, type FeatureDropTranslations, type FeatureEngagementMetrics, type FeatureEntry, type FeatureFlagBridge, type FeatureManifest, type FeaturePriority, type FeatureTrigger, type FeatureType, type FeatureVariant, HybridAdapter, type HybridAdapterOptions, IndexedDBAdapter, type IndexedDBAdapterOptions, LaunchDarklyBridge, type LaunchDarklyBridgeOptions, type LaunchDarklyClientLike, LocalStorageAdapter, type LocalStorageAdapterOptions, type ManifestDiff, ManifestEditor, type ManifestEditorProps, MarkdownAdapter, MemoryAdapter, MixpanelAdapter, MongoAdapter, type MongoAdapterOptions, type MongoLikeCollection, MySQLAdapter, type MySQLAdapterOptions, type MySQLQueryFn, type MySQLQueryResult, NotionAdapter, PostHogAdapter, PostHogBridge, type PostHogBridgeOptions, type PostHogClientLike, PostgresAdapter, type PostgresAdapterOptions, type PostgresQueryFn, type PostgresQueryResult, PreviewPanel, type PreviewPanelProps, RSSFeedGenerator, type RSSFeedGeneratorOptions, RedisAdapter, type RedisAdapterOptions, type RedisLikeClient, type RedisLikePipeline, RemoteAdapter, type RemoteAdapterOptions, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteQueryFn, type SQLiteQueryResult, SanityAdapter, ScheduleCalendar, type ScheduleCalendarProps, SegmentAdapter, type ServerStorageAdapter, SlackBridge, type SlackBridgeOptions, type StorageAdapter, StrapiAdapter, SupabaseAdapter, type SupabaseAdapterOptions, type SupabaseClientLike, type SupabaseRealtimeChannelLike, type ThrottleOptions, type ThrottleResult, type ThrottleRuntimeState, type TriggerContext, TriggerEngine, type UserContext, type ValidationIssue, type ValidationResult, WebhookBridge, type WebhookBridgeOptions, applyAnnouncementThrottle, applyFeatureVariant, applyFeatureVariants, computeManifestStats, createAdoptionMetrics, createChangelogRenderer, createFlagBridge, createManifest, createTheme, diffManifest, featureEntryJsonSchema, featureEntrySchema, featureManifestJsonSchema, featureManifestSchema, formatDateForLocale, formatRelativeTimeForLocale, generateChangelogDiff, generateMarkdownChangelog, generateRSS, getAnimationDurationMs, getEnterAnimation, getExitAnimation, getFeatureById, getFeatureVariantName, getLocaleDirection, getNewFeatureCount, getNewFeatures, getNewFeaturesByCategory, getNewFeaturesSorted, getOrCreateVariantKey, getPulseAnimation, hasDependencyCycle, hasNewFeature, isNew, isTriggerMatch, matchesAudience, parseDescription, resolveAnimationPreset, resolveDependencyOrder, resolveLocale, resolveTheme, resolveTranslations, runDoctor, sortFeaturesByDependencies, themeToCSSVariables, validateManifest, validateManifestForCI };