featuredrop 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -1,9 +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 */
@@ -48,6 +52,10 @@ interface UserContext {
 }
 /** 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 */
@@ -137,8 +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 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 */
@@ -243,24 +255,26 @@ declare function matchesAudience(audience: AudienceRule, userContext: UserContex
  * 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, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext): 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, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext): 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, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext): 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, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext): 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, userContext?: UserContext, matchAudience?: AudienceMatchFn, appVersion?: string, dependencyState?: FeatureDependencyState, triggerContext?: TriggerContext): 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.
@@ -285,6 +299,603 @@ declare function getNewFeaturesByCategory(manifest: FeatureManifest, category: s
  */
 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;
@@ -357,6 +968,7 @@ interface FeatureDropTranslations {
     loadMore: string;
     share: string;
     skipToEntries: string;
+    newFeatureCount: (count: number) => string;
     stepOf: (current: number, total: number) => string;
     back: string;
     next: string;
@@ -371,11 +983,31 @@ interface FeatureDropTranslations {
     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`.
@@ -547,206 +1179,6 @@ interface DoctorReport {
 }
 declare function runDoctor(entries: FeatureEntry[], now?: Date): DoctorReport;
 
-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 type: {
-            readonly enum: readonly ["feature", "improvement", "fix", "breaking"];
-        };
-        readonly priority: {
-            readonly enum: readonly ["critical", "normal", "low"];
-        };
-    };
-};
-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 type: {
-                readonly enum: readonly ["feature", "improvement", "fix", "breaking"];
-            };
-            readonly priority: {
-                readonly enum: readonly ["critical", "normal", "low"];
-            };
-        };
-    };
-};
-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>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
-    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>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
-    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>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
-    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>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
-    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>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
-    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>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "improvement", "fix", "breaking"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["critical", "normal", "low"]>>;
-    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 LocalStorageAdapterOptions {
     /** Key prefix for localStorage entries. Default: "featuredrop" */
     prefix?: string;
@@ -777,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.
  *
@@ -808,6 +1299,18 @@ interface RemoteAdapterOptions {
     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;
@@ -818,6 +1321,14 @@ declare class RemoteAdapter implements StorageAdapter {
     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>;
@@ -827,8 +1338,14 @@ declare class RemoteAdapter implements StorageAdapter {
     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 {
@@ -930,6 +1447,14 @@ interface HybridAdapterOptions {
     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.
@@ -939,6 +1464,15 @@ declare class HybridAdapter implements ServerStorageAdapter {
     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>;
@@ -950,6 +1484,9 @@ declare class HybridAdapter implements ServerStorageAdapter {
     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 {
@@ -1139,4 +1676,4 @@ declare class SupabaseAdapter implements ServerStorageAdapter {
     private setupRealtime;
 }
 
-export { type AdoptionEvent, type AdoptionEventInput, type AdoptionEventType, type AdoptionMetrics, AmplitudeAdapter, type AnalyticsAdapter, type AnalyticsCallbacks, AnalyticsCollector, type AnalyticsCollectorOptions, type AudienceMatchFn, type AudienceRule, CustomAdapter, type DismissalState, FEATUREDROP_THEMES, FEATUREDROP_TRANSLATIONS, type FeatureCTA, type FeatureDependencies, type FeatureDependencyState, type FeatureDropTheme, type FeatureDropThemeInput, type FeatureDropThemeOverrides, type FeatureDropThemePreset, type FeatureDropTranslations, type FeatureEngagementMetrics, type FeatureEntry, type FeatureManifest, type FeaturePriority, type FeatureTrigger, type FeatureType, type FeatureVariant, HybridAdapter, type HybridAdapterOptions, LocalStorageAdapter, type LocalStorageAdapterOptions, MemoryAdapter, MixpanelAdapter, MongoAdapter, type MongoAdapterOptions, type MongoLikeCollection, MySQLAdapter, type MySQLAdapterOptions, type MySQLQueryFn, type MySQLQueryResult, PostHogAdapter, PostgresAdapter, type PostgresAdapterOptions, type PostgresQueryFn, type PostgresQueryResult, RedisAdapter, type RedisAdapterOptions, type RedisLikeClient, type RedisLikePipeline, RemoteAdapter, type RemoteAdapterOptions, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteQueryFn, type SQLiteQueryResult, SegmentAdapter, type ServerStorageAdapter, type StorageAdapter, SupabaseAdapter, type SupabaseAdapterOptions, type SupabaseClientLike, type SupabaseRealtimeChannelLike, type ThrottleOptions, type ThrottleResult, type ThrottleRuntimeState, type TriggerContext, TriggerEngine, type UserContext, type ValidationIssue, type ValidationResult, applyAnnouncementThrottle, applyFeatureVariant, applyFeatureVariants, computeManifestStats, createAdoptionMetrics, createManifest, createTheme, featureEntryJsonSchema, featureEntrySchema, featureManifestJsonSchema, featureManifestSchema, generateMarkdownChangelog, generateRSS, getFeatureById, getFeatureVariantName, getNewFeatureCount, getNewFeatures, getNewFeaturesByCategory, getNewFeaturesSorted, getOrCreateVariantKey, hasDependencyCycle, hasNewFeature, isNew, isTriggerMatch, matchesAudience, parseDescription, resolveDependencyOrder, resolveTheme, resolveTranslations, runDoctor, sortFeaturesByDependencies, themeToCSSVariables, validateManifest };
+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 };