/**
 * Public types for `featurebase-js`.
 *
 * The runtime (sdk.js) consumes camelCase fields. This SDK accepts both
 * camelCase (preferred) and snake_case aliases for ergonomics in apps that
 * use snake_case keys throughout, and normalizes everything to camelCase
 * before dispatching.
 */
type ThemeMode = 'light' | 'dark';
/**
 * Pages the messenger can be opened to via `show()`.
 *
 * Unknown values are forwarded to the runtime as-is for forward
 * compatibility with future spaces.
 */
type Space = 'home' | 'messages' | 'help' | 'changelog' | (string & {});
/**
 * Optional company association for the identified user.
 */
interface FeaturebaseCompany {
    /** Stable company identifier in your system. */
    companyId?: string;
    /** Snake_case alias for {@link FeaturebaseCompany.companyId}. */
    company_id?: string;
    name?: string;
    createdAt?: number | string;
    /** Snake_case alias for {@link FeaturebaseCompany.createdAt}. */
    created_at?: number | string;
    monthlySpend?: number;
    /** Snake_case alias for {@link FeaturebaseCompany.monthlySpend}. */
    monthly_spend?: number;
    plan?: string;
    size?: number;
    website?: string;
    industry?: string;
    /** Arbitrary additional company attributes. */
    [key: string]: unknown;
}
/**
 * Settings accepted by `Featurebase()` / `boot()` / `update()`.
 *
 * Both camelCase (preferred) and snake_case aliases are accepted for every
 * field. The wrapper normalizes to camelCase before dispatching to the
 * runtime.
 */
interface FeaturebaseSettings {
    /**
     * Your Featurebase organization id (the value the dashboard's
     * **Settings → Support → Installation** copy labels as `appId`). The
     * single field that drives both the messenger and the standalone
     * widgets — the SDK resolves it once to `{ slug, modules }` via
     * `https://do.featurebase.app/v1/organization/by-id/:appId` and uses
     * the workspace's **General → Manage modules** toggles to decide which
     * surfaces auto-boot.
     */
    appId?: string;
    /** Snake_case alias for {@link FeaturebaseSettings.appId}. */
    app_id?: string;
    /**
     * Opt out of the support messenger even when **Manage modules** has
     * Support enabled. Most apps don't need this — leave it unset and the
     * SDK boots the messenger only when the workspace has Support on.
     *
     * Set to `false` when you want to manage the messenger yourself
     * (different page, different timing, etc.) without touching the
     * dashboard module flags. Default `true`.
     */
    messenger?: boolean;
    /** Stable user id in your system. */
    userId?: string | number;
    /** Snake_case alias for {@link FeaturebaseSettings.userId}. */
    user_id?: string | number;
    email?: string;
    name?: string;
    /**
     * Server-signed JWT carrying the user's identity and custom attributes.
     * **Recommended** auth method — see
     * https://help.featurebase.app/en/articles/5257986-creating-and-signing-a-jwt
     *
     * @example
     * Featurebase({ appId, featurebaseJwt: serverSignedJwt });
     */
    featurebaseJwt?: string;
    /**
     * @deprecated Use {@link FeaturebaseSettings.featurebaseJwt} instead.
     * `userHash` (HMAC) is the legacy auth method and is being phased out.
     * See https://help.featurebase.app/en/help/articles/5402549-secure-your-installation-required-by-default
     */
    userHash?: string;
    /**
     * @deprecated Use {@link FeaturebaseSettings.featurebaseJwt} instead.
     * Snake_case alias for the legacy {@link FeaturebaseSettings.userHash}.
     */
    user_hash?: string;
    createdAt?: number | string;
    /** Snake_case alias for {@link FeaturebaseSettings.createdAt}. */
    created_at?: number | string;
    company?: FeaturebaseCompany;
    companies?: FeaturebaseCompany[];
    /** Optional brand id when running multi-brand. */
    $brandId?: string;
    theme?: ThemeMode;
    /** Alternate spelling of {@link FeaturebaseSettings.theme}. */
    themeMode?: ThemeMode;
    /** Snake_case alias for {@link FeaturebaseSettings.themeMode}. */
    theme_mode?: ThemeMode;
    language?: string;
    /** Alternate spelling of {@link FeaturebaseSettings.language}. */
    languageOverride?: string;
    /** Snake_case alias for {@link FeaturebaseSettings.languageOverride}. */
    language_override?: string;
    hideDefaultLauncher?: boolean;
    /** Snake_case alias for {@link FeaturebaseSettings.hideDefaultLauncher}. */
    hide_default_launcher?: boolean;
    alignment?: 'left' | 'right';
    horizontalPadding?: number;
    /** Snake_case alias for {@link FeaturebaseSettings.horizontalPadding}. */
    horizontal_padding?: number;
    verticalPadding?: number;
    /** Snake_case alias for {@link FeaturebaseSettings.verticalPadding}. */
    vertical_padding?: number;
    actionColor?: string;
    /** Snake_case alias for {@link FeaturebaseSettings.actionColor}. */
    action_color?: string;
    backgroundColor?: string;
    /** Snake_case alias for {@link FeaturebaseSettings.backgroundColor}. */
    background_color?: string;
    customData?: Record<string, unknown>;
    /** Snake_case alias for {@link FeaturebaseSettings.customData}. */
    custom_data?: Record<string, unknown>;
    /**
     * Any additional attributes are passed through to the runtime untouched
     * and end up on the contact's profile (Featurebase's catchall).
     */
    [key: string]: unknown;
}
/** Internal: shape after `normalizeSettings()` resolves all aliases. */
interface NormalizedFeaturebaseSettings {
    appId: string;
    [key: string]: unknown;
}
/**
 * BCP-47 short codes accepted by every Featurebase widget. Mirrors the
 * runtime's `localeShortCodeSchema`. Unknown codes are forwarded verbatim
 * to the runtime for forward compatibility.
 */
type FeaturebaseLocale = 'bn' | 'bs' | 'pt-BR' | 'bg' | 'ca' | 'hr' | 'cs' | 'da' | 'nl' | 'en' | 'et' | 'fi' | 'fr' | 'de' | 'el' | 'hi' | 'hu' | 'id' | 'it' | 'ja' | 'ko' | 'lv' | 'lt' | 'ms' | 'mn' | 'nb' | 'pl' | 'pt' | 'ro' | 'ru' | 'sr' | 'zh-CN' | 'sl' | 'es' | 'sw' | 'sv' | 'th' | 'zh-TW' | 'tr' | 'uk' | 'vi' | 'sk' | (string & {});
/**
 * Identity fields every widget accepts. Pass `featurebaseJwt` (a
 * server-signed JWT carrying the user's identity and custom attributes)
 * — this is the recommended auth method.
 *
 * See https://help.featurebase.app/en/articles/5257986-creating-and-signing-a-jwt
 */
interface FeaturebaseWidgetIdentity {
    /**
     * Server-signed JWT carrying the user's identity. **Recommended.**
     */
    featurebaseJwt?: string;
    /**
     * Pre-minted JWT (advanced — most apps should use `featurebaseJwt`).
     */
    jwtToken?: string;
    /**
     * Plain-text email. Only safe when the attribute is explicitly
     * configured as non-secured in the dashboard. Prefer the JWT.
     */
    email?: string;
    /**
     * Plain-text user id. Only safe when the attribute is explicitly
     * configured as non-secured in the dashboard. Prefer the JWT.
     */
    userId?: string;
    /**
     * @deprecated Use {@link FeaturebaseWidgetIdentity.featurebaseJwt} instead.
     * `userHash` (HMAC) is the legacy auth method and is being phased out.
     */
    userHash?: string;
}
/**
 * Shared base for every standalone widget config (caller-facing). The
 * workspace slug is resolved from the appId set on
 * `Featurebase({ appId })` / `<FeaturebaseProvider appId>` and is never a
 * per-widget input.
 */
interface FeaturebaseWidgetBase extends FeaturebaseWidgetIdentity {
    /** Widget locale. Defaults to `'en'` when omitted. */
    locale?: FeaturebaseLocale;
}
/**
 * Modern changelog widget config (uses `dropdown` / `popup` / `changelogCard`
 * sub-objects). At least one of the three must be enabled.
 *
 * Use {@link initChangelog} to dispatch.
 */
interface ChangelogWidgetConfig extends FeaturebaseWidgetBase {
    /** Optional category slugs to filter the widget contents by. */
    category?: string[];
    /** Theme for the widget shell. */
    theme: 'dark' | 'light';
    /** Bind to a target selector and render a dropdown panel of updates. */
    dropdown?: {
        enabled: boolean;
        placement?: 'bottom' | 'top' | 'left' | 'right' | 'auto';
        /** Lazy-load the dropdown contents on first open. */
        lazyLoad?: boolean;
    };
    /** Auto-display a fullscreen popup of the latest unread update. */
    popup?: {
        enabled: boolean;
        /** Used to personalize the popup greeting. */
        usersName?: string;
        /** If true, the popup re-opens whenever a new update is published. */
        autoOpenForNewUpdates?: boolean;
    };
    /** Floating bottom-corner card that announces the latest update. */
    changelogCard?: {
        enabled: boolean;
        /** Open the linked update in a new tab when the card is clicked. */
        openInNewTab?: boolean;
        layout?: {
            position?: 'bottom-left' | 'bottom-right';
            marginBottom?: number;
            marginSide?: number;
            maxWidth?: number;
        };
        /** Override the card's default styling. */
        theme?: {
            borderRadius?: number;
            backgroundColor?: string;
            titleColor?: string;
            descriptionColor?: string;
            borderColor?: string;
        };
    };
}
/**
 * Legacy changelog widget config (single `placement`). Kept for
 * backward-compatibility with installations that booted before the new
 * dropdown/popup/card split. Prefer {@link ChangelogWidgetConfig} for new
 * code.
 */
interface LegacyChangelogWidgetConfig extends FeaturebaseWidgetBase {
    /** Theme for the widget shell. */
    theme: string;
    placement?: 'bottom' | 'top' | 'left' | 'right' | 'auto';
    fullscreenPopup?: boolean;
    /** Personalizes the popup greeting. */
    usersName?: string;
    /** If true, popup opens regardless of unread state. */
    alwaysShow?: boolean;
    /** Lazy-load the dropdown contents on first open. */
    lazyLoadDropdown?: boolean;
}
/**
 * Floating feedback button. Pops out a panel where users can browse and
 * submit posts to your Featurebase boards.
 *
 * Use {@link initFeedbackWidget} to dispatch.
 */
interface FeedbackWidgetConfig extends FeaturebaseWidgetBase {
    /** Theme for the widget shell. */
    theme: string;
    placement?: 'bottom-right' | 'bottom-left' | 'left' | 'right';
    /** Slug of the board to open by default. */
    defaultBoard?: string;
    /** Arbitrary string-valued attributes attached to submitted posts. */
    metadata?: Record<string, string> | null;
}
/**
 * Survey runtime config. The widget fetches the active surveys for your
 * organization and auto-displays them based on the targeting rules
 * configured in your dashboard (URL match, CSS selector, segment).
 *
 * Use {@link initSurveys} to dispatch.
 */
interface SurveyWidgetConfig extends FeaturebaseWidgetBase {
    placement?: 'bottom-left' | 'bottom-right' | null;
    /** Theme override. Defaults to the survey's own configured theme. */
    theme?: string;
}
/**
 * Surface returned to the embed callback by the runtime. Forward-compat:
 * unknown `action` strings are surfaced verbatim.
 */
type FeaturebaseEmbedAction = 'loaded' | 'widgetReady' | 'routeChange' | (string & {});
/**
 * Callback signature shared by both embed APIs. The runtime invokes this
 * for lifecycle events (`loaded`, `widgetReady`, …) and route changes from
 * inside the iframe.
 */
type FeaturebaseEmbedCallback = (error: Error | null, data: ({
    action?: FeaturebaseEmbedAction;
} & Record<string, unknown>) | null) => void;
/**
 * Modern embeddable board config. Mounts the Featurebase board into a
 * `[data-featurebase-embed]` element on the host page.
 *
 * Use {@link initEmbedWidget} to dispatch.
 */
interface FeaturebaseEmbedWidgetConfig extends FeaturebaseWidgetBase {
    /**
     * Per-mount overrides forwarded to the iframe.
     *
     * **Identity (`appId`, `userId`, `email`, `featurebaseJwt`) is wrapper-
     * managed** — pass it once to {@link configure}, the unified
     * `Featurebase({ appId, featurebaseJwt })` entry point, or the React
     * `<FeaturebaseProvider>`. The wrapper auto-forwards it to every
     * embed mount; you should not pass identity here.
     *
     * The `metadata` field is the only thing you'd typically set per
     * mount — it attaches arbitrary string attributes to posts / votes
     * submitted from inside the iframe (e.g. plan, app version).
     *
     * @internal `user.jwt` is kept on the type only to match the
     * underlying runtime contract for advanced power-users; new code
     * should rely on the universal install above instead.
     */
    user?: {
        /** @deprecated Use the universal `featurebaseJwt` from setup instead. */
        jwt?: string | null;
        /** Arbitrary string attributes attached to posts / votes submitted from the iframe. */
        metadata?: Record<string, string>;
    };
    /** Cosmetic overrides for the embedded portal. */
    stylingOptions?: {
        /**
         * Hide the top navigation bar inside the iframe (the Boards / Roadmap /
         * Changelog tabs). Useful when you're embedding a single surface
         * (e.g. just `/roadmap`) and the host page already has its own
         * navigation. Defaults to `false`.
         */
        hideMenu?: boolean;
        /** Hide the Featurebase logo in the navigation bar. Defaults to `false`. */
        hideLogo?: boolean;
        /**
         * Force a theme inside the iframe.
         * - `'light'` / `'dark'` — explicit theme.
         * - `''` — auto-detect from the visitor's `prefers-color-scheme`.
         * - omitted / `null` — fall back to the workspace default theme.
         */
        theme?: 'light' | 'dark' | '' | null;
    };
    /**
     * Where to mount inside the embedded portal. Required by the runtime
     * (defaults to `'/'` — the boards index — when omitted at the field
     * level).
     */
    embedOptions: {
        /**
         * Path inside the portal to load on mount.
         * - `'/'` — feedback boards index (default).
         * - `'/roadmap'` — roadmap.
         * - `'/changelog'` — changelog.
         * - `'/p/<post-slug>'` — a specific post.
         */
        path?: string | null;
        /**
         * Query-string filters applied to the mounted page (without the
         * leading `?`). Example: `'b=63f827df2d62cb301468aac4&sortBy=upvotes:desc'`
         * pre-filters the boards index to a specific board, sorted by upvotes.
         */
        filters?: string | null;
        /**
         * **Advanced.** Reflect iframe route changes onto the host URL under
         * this prefix so users can deep-link / use the browser back button.
         * Example: `'/feedback'` makes the host URL become `'/feedback/p/abc123'`
         * when the visitor opens a post inside the iframe. Defaults to no
         * syncing.
         */
        routeSyncingBasePath?: string | null;
    };
}
/** Widget identity fields that are inheritable from the Provider. */
type InheritableIdentity = Partial<FeaturebaseWidgetIdentity>;
/** Loose changelog config: identity inheritable from context. */
type ChangelogWidgetConfigInput = Omit<ChangelogWidgetConfig, keyof FeaturebaseWidgetBase> & {
    locale?: FeaturebaseLocale;
} & InheritableIdentity;
/** Loose legacy-changelog config: identity inheritable. */
type LegacyChangelogWidgetConfigInput = Omit<LegacyChangelogWidgetConfig, keyof FeaturebaseWidgetBase> & {
    locale?: FeaturebaseLocale;
} & InheritableIdentity;
/** Loose feedback config: identity inheritable. */
type FeedbackWidgetConfigInput = Omit<FeedbackWidgetConfig, keyof FeaturebaseWidgetBase> & {
    locale?: FeaturebaseLocale;
} & InheritableIdentity;
/** Loose survey config: identity inheritable. */
type SurveyWidgetConfigInput = Omit<SurveyWidgetConfig, keyof FeaturebaseWidgetBase> & {
    locale?: FeaturebaseLocale;
} & InheritableIdentity;
/** Loose modern embed widget config: identity inheritable. */
type FeaturebaseEmbedWidgetConfigInput = Omit<FeaturebaseEmbedWidgetConfig, keyof FeaturebaseWidgetBase> & {
    locale?: FeaturebaseLocale;
} & InheritableIdentity;
/** Window augmentation for the global command queue. */
declare global {
    interface Window {
        Featurebase?: FeaturebaseGlobal;
    }
}
/**
 * The global `window.Featurebase` function. While the runtime is loading it
 * is a queue stub; once `sdk.js` is ready the runtime replaces it with a
 * real dispatcher and drains `q`.
 */
interface FeaturebaseGlobal {
    (action: string, data?: unknown, callback?: (...args: unknown[]) => void): unknown;
    q?: unknown[][];
}

/**
 * `featurebase-js` — typed wrapper around the Featurebase Messenger runtime.
 *
 * The runtime (`sdk.js`) is a global command queue: every method call below
 * is dispatched as `window.Featurebase(action, data, callback?)`. While the
 * runtime is still loading, calls are buffered in `window.Featurebase.q`
 * and drained once the script tag executes.
 *
 * This wrapper:
 *   - is SSR-safe (every export is a no-op when `window` is undefined),
 *   - auto-injects the runtime `<script>` tag on first use,
 *   - normalizes snake_case aliases to the runtime's camelCase contract,
 *   - and routes the default `Featurebase()` call to either `boot` (first
 *     call) or `identify` (subsequent calls), so it is safe to call inside
 *     React effects or other re-running lifecycle hooks.
 */

/**
 * Resolves snake_case aliases into the runtime's camelCase shape. Unknown
 * keys are forwarded verbatim (the runtime schema uses `.catchall(z.any())`).
 *
 * Throws if neither `appId` nor `app_id` is provided.
 */
declare function normalizeSettings(settings: FeaturebaseSettings): NormalizedFeaturebaseSettings;
/**
 * The single entry point for the SDK.
 *
 * Pass `appId` and the SDK does the right thing:
 *
 *   1. Resolves `appId → { slug, modules }` via the public resolver
 *      endpoint (cached aggressively — paid once per browser per hour).
 *   2. Stores `slug` + identity (`featurebaseJwt`, etc.) as defaults for
 *      every standalone widget call below.
 *   3. Boots the support messenger automatically when **General →
 *      Manage modules** has Support enabled. Set `messenger: false` to
 *      opt out even when Support is on.
 *
 * Safe to re-call: subsequent calls with the same `appId` re-identify
 * the visitor (no iframe re-mount), so it's fine to invoke from any
 * re-running lifecycle hook.
 *
 * @example Most common — let the dashboard's module flags decide
 * ```ts
 * Featurebase({ appId: 'abc123', featurebaseJwt: user?.featurebaseJwt });
 * ```
 *
 * @example Force-skip the messenger
 * ```ts
 * Featurebase({ appId: 'abc123', featurebaseJwt: jwt, messenger: false });
 * ```
 */
declare function Featurebase(settings: FeaturebaseSettings): void;
/**
 * Strict messenger-only boot. Requires `appId` and skips the resolver
 * entirely (no module-flag check). Lower-level than {@link Featurebase}
 * — use this when you want to boot the messenger without touching the
 * global widget defaults state. The React Provider uses this internally
 * for cleaner isolation.
 */
declare function boot(settings: FeaturebaseSettings): void;
/** Update the current visitor's attributes without re-booting. */
declare function update(settings?: Partial<FeaturebaseSettings>): void;
/**
 * Tear down the messenger and clear the cached app id.
 *
 * Debounced: the runtime dispatch is deferred for {@link SHUTDOWN_GRACE_MS}.
 * If a `boot()` for the same appId arrives in that window the teardown is
 * cancelled and the existing iframe is reused — refreshing identity but
 * never re-fetching `/config`. This is the primary defense against
 * `<FeaturebaseProvider>`-remount loops.
 *
 * Calling `shutdown()` more than once during the grace window is a no-op
 * (one teardown is enough).
 */
declare function shutdown(): void;
/**
 * Invoke `callback` once the messenger has finished booting (DOM iframe is
 * mounted and the runtime API is available). If boot has already completed,
 * the callback runs on the next microtask. Safe to call before `boot()` —
 * the callback queues until boot fires.
 *
 * Use this to register subscriptions like {@link onUnreadCountChange} from
 * code that runs in the same tick as boot, where you'd otherwise race the
 * runtime's async initialization.
 */
declare function whenReady(callback: () => void): void;
/** Open the messenger to the default landing page. */
declare function show(): void;
/** Hide the messenger. */
declare function hide(): void;
/** Open the messenger to a specific space (`'home' | 'messages' | 'help' | 'changelog'`). */
declare function showSpace(space: Space): void;
/** Open the messenger directly to the messages list. */
declare function showMessages(): void;
/** Open a specific help-center article. */
declare function showArticle(id: string | number): void;
/** Open a specific changelog entry, or the changelog index when omitted. */
declare function showChangelog(id?: string | number): void;
/** Alias for {@link showChangelog}. */
declare function showNews(id: string | number): void;
/** Open a specific conversation. */
declare function showConversation(id: string | number): void;
/** Open the new-message composer with optional pre-filled text. */
declare function showNewMessage(text?: string): void;
/** Switch the messenger between `'light'` and `'dark'` themes at runtime. */
declare function setTheme(theme: ThemeMode): void;
/** Switch the messenger language at runtime (BCP-47 short code, e.g. `'en'`). */
declare function setLanguage(lang: string): void;
/** Fired when the messenger becomes visible. */
declare function onShow(callback: () => void): void;
/** Fired when the messenger is dismissed. */
declare function onHide(callback: () => void): void;
/** Fired with the current unread-conversation count whenever it changes. */
declare function onUnreadCountChange(callback: (count: number) => void): void;
/** Fired when the user clicks an external link inside the messenger. */
declare function onExternalLinkOpen(callback: (url: string) => void): void;
/** Module flags returned by the org-resolver. */
interface OrganizationModules {
    support: boolean;
}
/** Public org metadata returned by the resolver endpoint. */
interface OrganizationInfo {
    slug: string;
    modules: OrganizationModules;
}
/**
 * Synchronous read of a resolved (or pre-cached) `OrganizationInfo`.
 * Returns `null` when the appId hasn't been seen yet. Used internally
 * by {@link Featurebase} to fast-path warm caches and externally by the
 * React Provider to seed initial state without going through a
 * microtask (which would trigger React's "state update outside act"
 * warning under tests).
 */
declare function peekResolverCache(appId: string): OrganizationInfo | null;
/**
 * Translate a Featurebase `appId` (Mongo `_id`) into the org slug + the
 * workspace's enabled-module flags. Cached aggressively in-memory and
 * via `localStorage`. SSR rejects.
 *
 * Most callers don't need to invoke this directly — {@link Featurebase}
 * does it for you. Exposed for advanced cases (e.g. you want to inspect
 * `modules` before mounting your own UI).
 */
declare function resolveOrganization(appId: string): Promise<OrganizationInfo>;
/**
 * Identity defaults that every widget init function inherits. Distinct
 * from messenger settings (those go through `Featurebase()` / `boot()`).
 * The workspace slug is wrapper-owned and not part of this shape.
 */
interface WidgetDefaults extends FeaturebaseWidgetIdentity {
    /** Default UI locale. Individual widgets can still override. */
    locale?: FeaturebaseLocale;
}
/**
 * Set identity defaults for every standalone widget call. Subsequent
 * {@link initChangelog} / {@link initFeedback} / {@link initSurveys}
 * calls inherit identity from here, so you don't have to repeat it on
 * every call. Explicit identity fields on the call always win.
 *
 * Call this once at app startup (after you know who the user is), and
 * again on login / logout to refresh identity. Each call merges with the
 * previous defaults — pass `undefined` to leave a field unchanged.
 *
 * The workspace identifier is NOT settable here — call
 * `Featurebase({ appId })` once at startup so the resolver populates it.
 *
 * @example
 * ```ts
 * import Featurebase, { configure, initChangelog, initFeedback, initSurveys } from 'featurebase-js';
 *
 * Featurebase({ appId: 'abc123' });
 *
 * configure({
 *   featurebaseJwt: user.featurebaseJwt,   // server-signed JWT
 * });
 *
 * initChangelog({ theme: 'light', dropdown: { enabled: true } });
 * initFeedback({ theme: 'light', placement: 'bottom-right' });
 * initSurveys();
 * ```
 */
declare function configure(defaults: WidgetDefaults): void;
/**
 * Drop every default set via {@link configure}. Also clears the
 * resolver-derived workspace slug so a subsequent `Featurebase({ appId })`
 * has to re-resolve. Useful on logout / appId switches.
 */
declare function clearConfig(): void;
/** Test/inspection helper — read the current defaults. */
declare function getWidgetDefaults(): Readonly<WidgetDefaults>;
/**
 * Initialize the standalone changelog widget. Pass at least one of
 * `dropdown`, `popup`, or `changelogCard` in the config.
 *
 * Identity (`featurebaseJwt`, etc.) is inherited from {@link configure}
 * when set; pass it explicitly to override. The workspace slug is
 * resolved once from the appId set via `Featurebase({ appId })` /
 * `<FeaturebaseProvider appId>` and is never a per-widget input.
 *
 * Safe to call repeatedly — the runtime no-ops when the data hasn't
 * changed and only re-applies the theme / card overrides when it has.
 *
 * @example
 * ```ts
 * initChangelog({
 *   theme: 'light',
 *   dropdown: { enabled: true, placement: 'bottom' },
 * });
 * ```
 */
declare function initChangelog(config: ChangelogWidgetConfigInput): void;
/**
 * Initialize the changelog widget using the legacy `placement` shape.
 * Prefer {@link initChangelog} for new installations.
 */
declare function initLegacyChangelog(config: LegacyChangelogWidgetConfigInput): void;
/**
 * Open the changelog popup imperatively. Requires {@link initChangelog} to
 * have been called previously.
 */
declare function openChangelogPopup(data?: unknown): void;
/** Mark every published update as read for the current visitor. */
declare function markAllChangelogsAsViewed(): void;
/**
 * Synchronously read the number of changelog entries the current visitor
 * hasn't seen yet. Returns `undefined` when SSR or when the widget has not
 * been initialized.
 */
declare function getUnviewedChangelogCount(): number | undefined;
/**
 * Tear down the changelog widget — removes its DOM, listeners, and
 * cached state. Useful for SPA route changes that should reset the widget.
 *
 * Requires runtime ≥ the build that exposes `destroy_changelog_widget`.
 */
declare function destroyChangelog(): void;
/**
 * Initialize the floating feedback button. Re-calling is a no-op apart
 * from theme updates.
 *
 * Identity inherited from {@link configure} when set. Workspace slug is
 * resolved from the appId set via `Featurebase({ appId })`.
 *
 * @example
 * ```ts
 * initFeedback({
 *   theme: 'light',
 *   placement: 'bottom-right',
 *   defaultBoard: 'feature-requests',
 * });
 * ```
 */
declare function initFeedback(config: FeedbackWidgetConfigInput): void;
/**
 * Tear down the feedback widget — removes its button, panel, and cached
 * state.
 *
 * Requires runtime ≥ the build that exposes `destroy_feedback_widget`.
 */
declare function destroyFeedback(): void;
/**
 * Boot the survey runtime. The widget then auto-fetches active surveys
 * and displays them based on the targeting rules (URL match, CSS
 * selector, segment) configured in the dashboard.
 *
 * Identity inherited from {@link configure} when set; workspace slug
 * resolved from the appId set via `Featurebase({ appId })`. Pass no
 * arguments at all once the workspace is initialized.
 *
 * Calling this more than once is a no-op while the survey runtime is
 * already initialized or displaying a survey.
 *
 * @example
 * ```ts
 * initSurveys({ placement: 'bottom-right' });
 * ```
 */
declare function initSurveys(config?: SurveyWidgetConfigInput): void;
/**
 * Mount the modern embeddable board (`'init_embed_widget'`).
 *
 * Place a `<div data-featurebase-embed></div>` somewhere on the page and
 * call this once after `Featurebase({ appId })`. Calling it again with a
 * different config updates the existing iframe in place — no remount.
 *
 * Identity inherited from {@link configure} when set; workspace slug
 * resolved from the appId. The `callback` is invoked by the runtime on
 * lifecycle events (`loaded`, `widgetReady`) and route changes from
 * inside the iframe.
 *
 * @example
 * ```ts
 * Featurebase({ appId: 'abc123' });
 * initEmbedWidget(
 *   { theme: 'light', embedOptions: { path: '/' } },
 *   (err, evt) => { if (evt?.action === 'widgetReady') console.log('ready'); },
 * );
 * ```
 */
declare function initEmbedWidget(config: FeaturebaseEmbedWidgetConfigInput, callback?: FeaturebaseEmbedCallback): void;
/**
 * Names of every messenger action this SDK exports. Used by the action
 * coverage test to catch accidental removals.
 */
declare const SUPPORTED_ACTIONS: readonly ["boot", "update", "shutdown", "show", "hide", "showSpace", "showMessages", "showArticle", "showChangelog", "showNews", "showConversation", "showNewMessage", "setTheme", "setLanguage", "onShow", "onHide", "onUnreadCountChange", "onExternalLinkOpen", "configure", "clearConfig", "resolveOrganization", "initChangelog", "initLegacyChangelog", "openChangelogPopup", "markAllChangelogsAsViewed", "getUnviewedChangelogCount", "destroyChangelog", "initFeedback", "destroyFeedback", "initSurveys", "initEmbedWidget"];
/** Test/inspection helper — resets internal state between tests. */
declare function __resetForTests(): void;
/**
 * Test helper — pre-populate the in-memory resolver cache so
 * {@link Featurebase} dispatches synchronously without hitting `fetch`.
 * Pair with `__resetForTests()` between tests.
 */
declare function __primeResolverForTests(appId: string, info?: Partial<OrganizationInfo>): void;

export { type ChangelogWidgetConfig, type ChangelogWidgetConfigInput, type FeaturebaseCompany, type FeaturebaseEmbedAction, type FeaturebaseEmbedCallback, type FeaturebaseEmbedWidgetConfig, type FeaturebaseEmbedWidgetConfigInput, type FeaturebaseGlobal, type FeaturebaseLocale, type FeaturebaseSettings, type FeaturebaseWidgetBase, type FeaturebaseWidgetIdentity, type FeedbackWidgetConfig, type FeedbackWidgetConfigInput, type LegacyChangelogWidgetConfig, type LegacyChangelogWidgetConfigInput, type NormalizedFeaturebaseSettings, type OrganizationInfo, type OrganizationModules, SUPPORTED_ACTIONS, type Space, type SurveyWidgetConfig, type SurveyWidgetConfigInput, type ThemeMode, type WidgetDefaults, __primeResolverForTests, __resetForTests, boot, clearConfig, configure, Featurebase as default, destroyChangelog, destroyFeedback, getUnviewedChangelogCount, getWidgetDefaults, hide, initChangelog, initEmbedWidget, initFeedback, initLegacyChangelog, initSurveys, markAllChangelogsAsViewed, normalizeSettings, onExternalLinkOpen, onHide, onShow, onUnreadCountChange, openChangelogPopup, peekResolverCache, resolveOrganization, setLanguage, setTheme, show, showArticle, showChangelog, showConversation, showMessages, showNewMessage, showNews, showSpace, shutdown, update, whenReady };