@guidelytech/shared 0.14.0 → 0.16.0

package/dist/runtime-CAtOOY7X.d.ts

@@ -0,0 +1,3047 @@
+import { z } from 'zod';
+
+/** FNV-1a 32-bit hash; deterministic across SDK and server for rollout bucketing. */
+declare function fnv1a(input: string): number;
+/** Deterministic 0-99 bucket for percentage rollouts. */
+declare function rolloutBucket(subject: string, salt: string): number;
+declare function slugify(input: string): string;
+/** URL-safe random id. Uses crypto when available, falls back to Math.random (ids are not secrets). */
+declare function randomId(size?: number): string;
+declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+/** Safe nested getter: get(obj, "account.plan") */
+declare function getPath(obj: unknown, path: string): unknown;
+declare function clamp(n: number, min: number, max: number): number;
+/** Glob-style URL pattern match: `*` matches any chars except `/`, `**` matches anything. */
+declare function matchUrlPattern(pattern: string, url: string): boolean;
+declare function stripOrigin(url: string): string;
+/** Safe regexp construction with a length cap to limit ReDoS exposure. */
+declare function safeRegExp(source: string, flags?: string): RegExp | null;
+
+/**
+ * Cross-platform helpers shared by the web SDK, the React Native SDK and (as a reference for) the
+ * native iOS/Android SDKs. Zod-free so it can ship in runtime bundles.
+ */
+/** Platforms a guide can be delivered to. */
+declare const PLATFORMS: readonly ["web", "ios", "android"];
+type Platform = (typeof PLATFORMS)[number];
+/** Guides published before platforms existed have no `platforms` field and are web-only. */
+declare const DEFAULT_PLATFORMS: Platform[];
+/** Platforms a guide config targets (missing field → web only). */
+declare function guidePlatforms(config: {
+    platforms?: readonly string[] | null;
+}): string[];
+declare function supportsPlatform(config: {
+    platforms?: readonly string[] | null;
+}, platform: string): boolean;
+/** Attribute web apps put on elements to share a target id with their mobile apps. */
+declare const GUIDELY_ID_ATTRIBUTE = "data-guidely-id";
+/**
+ * Extracts a Guidely target id from a trigger / advance / checklist value so the same guide works on
+ * web and mobile. Accepts a bare id (`new-deal`), `#new-deal`, or `[data-guidely-id="new-deal"]`
+ * (also `data-testid` / `data-tour`). Returns null for selectors that cannot name a single id.
+ */
+declare function guidelyIdFromSelector(value: string | null | undefined): string | null;
+/**
+ * Mobile SDKs have screens instead of URLs. URL-based features (URL patterns, `url_match` triggers,
+ * multi-page steps, `url_visited` checklist tasks) match against the screen path `/<ScreenName>`.
+ */
+declare function screenPath(screen: string | null | undefined): string;
+/**
+ * Compares dotted version strings numerically (`2.10.0` > `2.9.3`). Non-numeric parts compare as
+ * strings; a missing part counts as 0 (`2.1` == `2.1.0`). Returns -1, 0 or 1, or null when either
+ * side is empty.
+ */
+declare function compareVersions(a: unknown, b: unknown): -1 | 0 | 1 | null;
+
+/**
+ * Pure checklist / survey logic shared by every renderer (web runtime, React Native, and the
+ * reference for the native SDKs). Zod-free; uses structural types so it stays in the runtime entry.
+ */
+type SurveyAnswer = string | number | boolean | string[];
+type SurveyAnswers = Record<string, SurveyAnswer>;
+interface ShowWhen {
+    questionId: string;
+    op: "equals" | "lte" | "gte" | "in";
+    value: string | number | string[];
+}
+/** Evaluates a question's `showWhen` condition against current answers. */
+declare function isQuestionVisible(q: {
+    showWhen?: ShowWhen;
+}, answers: SurveyAnswers): boolean;
+/** Are all required tasks done? */
+declare function isChecklistComplete(config: {
+    tasks: Array<{
+        id: string;
+        required: boolean;
+    }>;
+}, progress: {
+    completedTaskIds: string[];
+}): boolean;
+
+declare const RULE_OPERATORS: readonly ["equals", "not_equals", "contains", "not_contains", "starts_with", "ends_with", "exists", "not_exists", "gt", "gte", "lt", "lte", "in", "not_in", "regex", "is_true", "is_false", "before", "after"];
+type RuleOperator = (typeof RULE_OPERATORS)[number];
+declare const RULE_FIELDS: readonly ["user.attribute", "account.attribute", "user.role", "user.plan", "user.identified", "url.path", "url.full", "url.query", "device.type", "device.browser", "device.os", "visitor.firstVisit", "visitor.returning", "event.seen", "guide.completed", "guide.dismissed", "guide.seen", "checklist.completed", "audience.member", "datetime.now", "datetime.dayOfWeek", "datetime.hour", "rollout.percentage", "experiment.bucket", "environment", "locale", "app.platform", "app.screen", "app.version", "page.views", "feature.clicks"];
+type RuleField = (typeof RULE_FIELDS)[number];
+interface Rule {
+    id: string;
+    field: RuleField;
+    /** For attribute/query/event fields: the attribute key, query param name, event name, guide id... */
+    key?: string;
+    op: RuleOperator;
+    value?: string | number | boolean | string[];
+    /** When true, the rule is negated (exclusion rule). */
+    negate?: boolean;
+}
+type RuleGroup = {
+    id: string;
+    op: "and" | "or";
+    rules: Array<Rule | RuleGroup>;
+    negate?: boolean;
+};
+declare function isRuleGroup(r: Rule | RuleGroup): r is RuleGroup;
+declare function emptyRuleGroup(id?: string): RuleGroup;
+/** Everything targeting evaluation can see. Built by the SDK (browser) or the server. */
+interface TargetingContext {
+    userId?: string | null;
+    anonymousId: string;
+    userAttributes: Record<string, unknown>;
+    accountAttributes: Record<string, unknown>;
+    url: string;
+    path: string;
+    query: Record<string, string>;
+    device: {
+        type: "desktop" | "tablet" | "mobile";
+        browser?: string;
+        os?: string;
+    };
+    firstVisit: boolean;
+    eventsSeen: Set<string> | string[];
+    completedGuides: Set<string> | string[];
+    dismissedGuides: Set<string> | string[];
+    seenGuides: Set<string> | string[];
+    completedChecklists: Set<string> | string[];
+    audienceIds: Set<string> | string[];
+    now: Date;
+    environment: string;
+    locale?: string;
+    /** `web`, `ios` or `android`. Missing means web. */
+    platform?: string;
+    /** Current screen name (mobile SDKs; set via `screen()`). */
+    screen?: string;
+    /** Host app version (mobile SDKs), e.g. `2.4.1`. */
+    appVersion?: string;
+    /** Salt for rollout (guide id). Set per guide before evaluating. */
+    rolloutSalt?: string;
+    /**
+     * Views of tagged pages / clicks on tagged features in the last 30 days, by tag id. Only the server
+     * fills it (audience evaluation); in the browser `page.views` / `feature.clicks` read 0.
+     */
+    tagUsage?: Record<string, number>;
+}
+declare function compare(op: RuleOperator, actual: unknown, expected: Rule["value"]): boolean;
+declare function evaluateRule(rule: Rule, ctx: TargetingContext): boolean;
+/** Evaluate a rule tree. An empty group matches everyone. */
+declare function evaluateRules(group: RuleGroup | null | undefined, ctx: TargetingContext): boolean;
+/** Fields whose evaluation requires server-held data. Used by docs/UI to annotate rules. */
+declare const SERVER_ASSISTED_FIELDS: RuleField[];
+/** Who a guide is shown to, before its targeting rules: everyone, only signed-in (identified) users, or only anonymous visitors. */
+declare const GUIDE_VISIBILITIES: readonly ["everyone", "identified", "anonymous"];
+type GuideVisibility = (typeof GUIDE_VISIBILITIES)[number];
+/**
+ * Targeting with the visibility folded in as a `user.identified` rule. The server sends guides to SDKs
+ * this way, so every SDK applies it through the rules it already evaluates (SDKs that predate the field
+ * resolve it as undefined and show the guide to nobody rather than to everyone).
+ */
+declare function withVisibility(targeting: RuleGroup, visibility: GuideVisibility | undefined): RuleGroup;
+declare function describeRule(rule: Rule): string;
+
+declare const GUIDE_KINDS: readonly ["flow", "modal", "tooltip", "banner", "checklist", "survey", "announcement"];
+type GuideKind = (typeof GUIDE_KINDS)[number];
+declare const GUIDE_STATUSES: readonly ["draft", "published", "paused", "archived"];
+type GuideStatus = (typeof GUIDE_STATUSES)[number];
+declare const STEP_TYPES: readonly ["modal", "tooltip", "popover", "spotlight", "hotspot", "banner", "slideout", "checklist", "custom", "survey"];
+type StepType = (typeof STEP_TYPES)[number];
+declare const PLACEMENTS: readonly ["top", "top-start", "top-end", "right", "right-start", "right-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end", "auto"];
+type Placement = (typeof PLACEMENTS)[number];
+/** `guidely-id` is cross-platform: `data-guidely-id` on web, `GuidelyTarget` / `guidelyTarget()` on mobile. */
+declare const SELECTOR_KINDS: readonly ["css", "id", "data-attr", "aria", "text", "xpath", "guidely-id"];
+declare const SelectorStrategySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        id: "id";
+        text: "text";
+        css: "css";
+        "data-attr": "data-attr";
+        aria: "aria";
+        xpath: "xpath";
+        "guidely-id": "guidely-id";
+    }>;
+    value: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SelectorStrategy = z.infer<typeof SelectorStrategySchema>;
+declare const TargetSchema: z.ZodObject<{
+    selectors: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            id: "id";
+            text: "text";
+            css: "css";
+            "data-attr": "data-attr";
+            aria: "aria";
+            xpath: "xpath";
+            "guidely-id": "guidely-id";
+        }>;
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    waitMs: z.ZodDefault<z.ZodNumber>;
+    fallback: z.ZodDefault<z.ZodEnum<{
+        skip: "skip";
+        show_as_modal: "show_as_modal";
+        end_guide: "end_guide";
+        wait: "wait";
+    }>>;
+    scrollIntoView: z.ZodDefault<z.ZodBoolean>;
+    textSnapshot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type StepTarget = z.infer<typeof TargetSchema>;
+declare const BUTTON_ACTIONS: readonly ["next", "back", "dismiss", "complete", "skip", "url", "start_guide", "event", "open_resource_center", "none"];
+declare const ButtonSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    action: z.ZodEnum<{
+        skip: "skip";
+        next: "next";
+        back: "back";
+        dismiss: "dismiss";
+        complete: "complete";
+        url: "url";
+        start_guide: "start_guide";
+        event: "event";
+        open_resource_center: "open_resource_center";
+        none: "none";
+    }>;
+    variant: z.ZodDefault<z.ZodEnum<{
+        link: "link";
+        primary: "primary";
+        secondary: "secondary";
+        ghost: "ghost";
+    }>>;
+    value: z.ZodOptional<z.ZodString>;
+    newTab: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type StepButton = z.infer<typeof ButtonSchema>;
+declare const StepBranchSchema: z.ZodObject<{
+    id: z.ZodString;
+    when: z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>;
+    goTo: z.ZodString;
+}, z.core.$strip>;
+declare const ADVANCE_ON: readonly ["button", "element_click", "element_visible", "event", "delay", "any"];
+declare const StepSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        custom: "custom";
+        modal: "modal";
+        tooltip: "tooltip";
+        banner: "banner";
+        checklist: "checklist";
+        survey: "survey";
+        popover: "popover";
+        spotlight: "spotlight";
+        hotspot: "hotspot";
+        slideout: "slideout";
+    }>;
+    title: z.ZodDefault<z.ZodString>;
+    body: z.ZodDefault<z.ZodString>;
+    imageUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    imageAlt: z.ZodOptional<z.ZodString>;
+    videoUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    buttons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        action: z.ZodEnum<{
+            skip: "skip";
+            next: "next";
+            back: "back";
+            dismiss: "dismiss";
+            complete: "complete";
+            url: "url";
+            start_guide: "start_guide";
+            event: "event";
+            open_resource_center: "open_resource_center";
+            none: "none";
+        }>;
+        variant: z.ZodDefault<z.ZodEnum<{
+            link: "link";
+            primary: "primary";
+            secondary: "secondary";
+            ghost: "ghost";
+        }>>;
+        value: z.ZodOptional<z.ZodString>;
+        newTab: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    target: z.ZodOptional<z.ZodObject<{
+        selectors: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                id: "id";
+                text: "text";
+                css: "css";
+                "data-attr": "data-attr";
+                aria: "aria";
+                xpath: "xpath";
+                "guidely-id": "guidely-id";
+            }>;
+            value: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        waitMs: z.ZodDefault<z.ZodNumber>;
+        fallback: z.ZodDefault<z.ZodEnum<{
+            skip: "skip";
+            show_as_modal: "show_as_modal";
+            end_guide: "end_guide";
+            wait: "wait";
+        }>>;
+        scrollIntoView: z.ZodDefault<z.ZodBoolean>;
+        textSnapshot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    placement: z.ZodDefault<z.ZodEnum<{
+        top: "top";
+        "top-start": "top-start";
+        "top-end": "top-end";
+        right: "right";
+        "right-start": "right-start";
+        "right-end": "right-end";
+        bottom: "bottom";
+        "bottom-start": "bottom-start";
+        "bottom-end": "bottom-end";
+        left: "left";
+        "left-start": "left-start";
+        "left-end": "left-end";
+        auto: "auto";
+    }>>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    showOverlay: z.ZodDefault<z.ZodBoolean>;
+    showProgress: z.ZodDefault<z.ZodBoolean>;
+    showClose: z.ZodDefault<z.ZodBoolean>;
+    dismissOnOutsideClick: z.ZodDefault<z.ZodBoolean>;
+    spotlightPadding: z.ZodDefault<z.ZodNumber>;
+    position: z.ZodDefault<z.ZodEnum<{
+        top: "top";
+        bottom: "bottom";
+        "top-left": "top-left";
+        "top-right": "top-right";
+        "bottom-left": "bottom-left";
+        "bottom-right": "bottom-right";
+        center: "center";
+    }>>;
+    url: z.ZodOptional<z.ZodString>;
+    advanceOn: z.ZodDefault<z.ZodEnum<{
+        any: "any";
+        button: "button";
+        event: "event";
+        element_click: "element_click";
+        element_visible: "element_visible";
+        delay: "delay";
+    }>>;
+    advanceValue: z.ZodOptional<z.ZodString>;
+    advanceDelayMs: z.ZodOptional<z.ZodNumber>;
+    branches: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        when: z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>;
+        goTo: z.ZodString;
+    }, z.core.$strip>>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    targeting: z.ZodOptional<z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>>;
+    hotspot: z.ZodOptional<z.ZodObject<{
+        size: z.ZodDefault<z.ZodNumber>;
+        pulse: z.ZodDefault<z.ZodBoolean>;
+        openOn: z.ZodDefault<z.ZodEnum<{
+            click: "click";
+            hover: "hover";
+        }>>;
+    }, z.core.$strip>>;
+    customHtml: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GuideStep = z.infer<typeof StepSchema>;
+type GuideStepInput = z.input<typeof StepSchema>;
+declare const TRIGGER_TYPES: readonly ["page_load", "url_match", "event", "element_click", "element_visible", "manual", "delay", "after_guide", "segment_enter"];
+declare const TriggerSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<{
+        event: "event";
+        element_click: "element_click";
+        element_visible: "element_visible";
+        delay: "delay";
+        page_load: "page_load";
+        url_match: "url_match";
+        manual: "manual";
+        after_guide: "after_guide";
+        segment_enter: "segment_enter";
+    }>>;
+    value: z.ZodOptional<z.ZodString>;
+    delayMs: z.ZodDefault<z.ZodNumber>;
+    urlPattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type TriggerConfig = z.infer<typeof TriggerSchema>;
+declare const FrequencySchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        once: "once";
+        once_per_session: "once_per_session";
+        every_time: "every_time";
+        interval: "interval";
+    }>>;
+    intervalHours: z.ZodOptional<z.ZodNumber>;
+    maxImpressions: z.ZodOptional<z.ZodNumber>;
+    cooldownHours: z.ZodDefault<z.ZodNumber>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    mutuallyExclusiveWith: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reshowAfterDismiss: z.ZodDefault<z.ZodBoolean>;
+    ignoreThrottling: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type FrequencyConfig = z.infer<typeof FrequencySchema>;
+declare const AppearanceSchema: z.ZodObject<{
+    theme: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        light: "light";
+        dark: "dark";
+    }>>;
+    primaryColor: z.ZodOptional<z.ZodString>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+    textColor: z.ZodOptional<z.ZodString>;
+    borderRadius: z.ZodOptional<z.ZodNumber>;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    overlayOpacity: z.ZodOptional<z.ZodNumber>;
+    zIndex: z.ZodOptional<z.ZodNumber>;
+    preset: z.ZodOptional<z.ZodString>;
+    animation: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        fade: "fade";
+        slide: "slide";
+    }>>;
+    customCss: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Appearance = z.infer<typeof AppearanceSchema>;
+declare const ChecklistTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    completion: z.ZodDefault<z.ZodEnum<{
+        event: "event";
+        click: "click";
+        manual: "manual";
+        guide_completed: "guide_completed";
+        url_visited: "url_visited";
+    }>>;
+    completionValue: z.ZodOptional<z.ZodString>;
+    action: z.ZodDefault<z.ZodEnum<{
+        url: "url";
+        start_guide: "start_guide";
+        event: "event";
+        none: "none";
+    }>>;
+    actionValue: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ChecklistTask = z.infer<typeof ChecklistTaskSchema>;
+declare const ChecklistConfigSchema: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        completion: z.ZodDefault<z.ZodEnum<{
+            event: "event";
+            click: "click";
+            manual: "manual";
+            guide_completed: "guide_completed";
+            url_visited: "url_visited";
+        }>>;
+        completionValue: z.ZodOptional<z.ZodString>;
+        action: z.ZodDefault<z.ZodEnum<{
+            url: "url";
+            start_guide: "start_guide";
+            event: "event";
+            none: "none";
+        }>>;
+        actionValue: z.ZodOptional<z.ZodString>;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    ordered: z.ZodDefault<z.ZodBoolean>;
+    launcherLabel: z.ZodDefault<z.ZodString>;
+    position: z.ZodDefault<z.ZodEnum<{
+        "bottom-left": "bottom-left";
+        "bottom-right": "bottom-right";
+    }>>;
+    completionTitle: z.ZodDefault<z.ZodString>;
+    completionBody: z.ZodDefault<z.ZodString>;
+    autoOpen: z.ZodDefault<z.ZodBoolean>;
+    dismissible: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ChecklistConfig = z.infer<typeof ChecklistConfigSchema>;
+declare const SURVEY_QUESTION_TYPES: readonly ["nps", "csat", "thumbs", "single_choice", "multiple_choice", "text", "rating"];
+declare const SurveyQuestionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        text: "text";
+        nps: "nps";
+        csat: "csat";
+        thumbs: "thumbs";
+        single_choice: "single_choice";
+        multiple_choice: "multiple_choice";
+        rating: "rating";
+    }>;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
+    scaleMax: z.ZodOptional<z.ZodNumber>;
+    lowLabel: z.ZodOptional<z.ZodString>;
+    highLabel: z.ZodOptional<z.ZodString>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    showWhen: z.ZodOptional<z.ZodObject<{
+        questionId: z.ZodString;
+        op: z.ZodEnum<{
+            equals: "equals";
+            lte: "lte";
+            gte: "gte";
+            in: "in";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SurveyQuestion = z.infer<typeof SurveyQuestionSchema>;
+declare const SurveyConfigSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            text: "text";
+            nps: "nps";
+            csat: "csat";
+            thumbs: "thumbs";
+            single_choice: "single_choice";
+            multiple_choice: "multiple_choice";
+            rating: "rating";
+        }>;
+        title: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        scaleMax: z.ZodOptional<z.ZodNumber>;
+        lowLabel: z.ZodOptional<z.ZodString>;
+        highLabel: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        showWhen: z.ZodOptional<z.ZodObject<{
+            questionId: z.ZodString;
+            op: z.ZodEnum<{
+                equals: "equals";
+                lte: "lte";
+                gte: "gte";
+                in: "in";
+            }>;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    thankYouTitle: z.ZodDefault<z.ZodString>;
+    thankYouBody: z.ZodDefault<z.ZodString>;
+    position: z.ZodDefault<z.ZodEnum<{
+        "bottom-left": "bottom-left";
+        "bottom-right": "bottom-right";
+        center: "center";
+    }>>;
+    startAt: z.ZodOptional<z.ZodString>;
+    endAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SurveyConfig = z.infer<typeof SurveyConfigSchema>;
+/**
+ * When any guide may show: `startAt` / `endAt` are UTC instants; `timezone` (IANA, e.g.
+ * `Europe/London`) is the zone they were entered in, kept for display only.
+ */
+declare const GuideScheduleSchema: z.ZodObject<{
+    startAt: z.ZodOptional<z.ZodString>;
+    endAt: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GuideSchedule = z.infer<typeof GuideScheduleSchema>;
+/** Locale codes: BCP 47 language tags such as `fr`, `pt-BR`, `zh-Hans`. */
+declare const LOCALE_PATTERN: RegExp;
+declare const LocaleSchema: z.ZodString;
+/**
+ * Translations of a guide's text: locale → translation key → text. Keys come from
+ * `guideTextEntries` (e.g. `steps.<stepId>.title`); missing keys fall back to the default language.
+ */
+declare const GuideLocalizationSchema: z.ZodObject<{
+    translations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, z.core.$strip>;
+type GuideLocalization = z.infer<typeof GuideLocalizationSchema>;
+/** Project.settings.localization: the language guides are written in and the languages offered for translation. */
+declare const LocalizationSettingsSchema: z.ZodObject<{
+    defaultLocale: z.ZodDefault<z.ZodString>;
+    locales: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    autoTranslate: z.ZodOptional<z.ZodBoolean>;
+    requireReview: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Project.settings.guideThrottling: limits automatically launched guides per visitor (guides
+ * started by a button, a link, Help or `startGuide()` are never throttled; nor are banners,
+ * checklists and hotspot-only guides, which don't interrupt).
+ */
+declare const GuideThrottlingSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxGuides: z.ZodDefault<z.ZodNumber>;
+    windowHours: z.ZodDefault<z.ZodNumber>;
+    minGapMinutes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const GuideConfigSchema: z.ZodObject<{
+    steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            custom: "custom";
+            modal: "modal";
+            tooltip: "tooltip";
+            banner: "banner";
+            checklist: "checklist";
+            survey: "survey";
+            popover: "popover";
+            spotlight: "spotlight";
+            hotspot: "hotspot";
+            slideout: "slideout";
+        }>;
+        title: z.ZodDefault<z.ZodString>;
+        body: z.ZodDefault<z.ZodString>;
+        imageUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+        imageAlt: z.ZodOptional<z.ZodString>;
+        videoUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+        buttons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            action: z.ZodEnum<{
+                skip: "skip";
+                next: "next";
+                back: "back";
+                dismiss: "dismiss";
+                complete: "complete";
+                url: "url";
+                start_guide: "start_guide";
+                event: "event";
+                open_resource_center: "open_resource_center";
+                none: "none";
+            }>;
+            variant: z.ZodDefault<z.ZodEnum<{
+                link: "link";
+                primary: "primary";
+                secondary: "secondary";
+                ghost: "ghost";
+            }>>;
+            value: z.ZodOptional<z.ZodString>;
+            newTab: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        target: z.ZodOptional<z.ZodObject<{
+            selectors: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    id: "id";
+                    text: "text";
+                    css: "css";
+                    "data-attr": "data-attr";
+                    aria: "aria";
+                    xpath: "xpath";
+                    "guidely-id": "guidely-id";
+                }>;
+                value: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            waitMs: z.ZodDefault<z.ZodNumber>;
+            fallback: z.ZodDefault<z.ZodEnum<{
+                skip: "skip";
+                show_as_modal: "show_as_modal";
+                end_guide: "end_guide";
+                wait: "wait";
+            }>>;
+            scrollIntoView: z.ZodDefault<z.ZodBoolean>;
+            textSnapshot: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        placement: z.ZodDefault<z.ZodEnum<{
+            top: "top";
+            "top-start": "top-start";
+            "top-end": "top-end";
+            right: "right";
+            "right-start": "right-start";
+            "right-end": "right-end";
+            bottom: "bottom";
+            "bottom-start": "bottom-start";
+            "bottom-end": "bottom-end";
+            left: "left";
+            "left-start": "left-start";
+            "left-end": "left-end";
+            auto: "auto";
+        }>>;
+        offset: z.ZodDefault<z.ZodNumber>;
+        showOverlay: z.ZodDefault<z.ZodBoolean>;
+        showProgress: z.ZodDefault<z.ZodBoolean>;
+        showClose: z.ZodDefault<z.ZodBoolean>;
+        dismissOnOutsideClick: z.ZodDefault<z.ZodBoolean>;
+        spotlightPadding: z.ZodDefault<z.ZodNumber>;
+        position: z.ZodDefault<z.ZodEnum<{
+            top: "top";
+            bottom: "bottom";
+            "top-left": "top-left";
+            "top-right": "top-right";
+            "bottom-left": "bottom-left";
+            "bottom-right": "bottom-right";
+            center: "center";
+        }>>;
+        url: z.ZodOptional<z.ZodString>;
+        advanceOn: z.ZodDefault<z.ZodEnum<{
+            any: "any";
+            button: "button";
+            event: "event";
+            element_click: "element_click";
+            element_visible: "element_visible";
+            delay: "delay";
+        }>>;
+        advanceValue: z.ZodOptional<z.ZodString>;
+        advanceDelayMs: z.ZodOptional<z.ZodNumber>;
+        branches: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            when: z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>;
+            goTo: z.ZodString;
+        }, z.core.$strip>>>;
+        width: z.ZodOptional<z.ZodNumber>;
+        targeting: z.ZodOptional<z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>>;
+        hotspot: z.ZodOptional<z.ZodObject<{
+            size: z.ZodDefault<z.ZodNumber>;
+            pulse: z.ZodDefault<z.ZodBoolean>;
+            openOn: z.ZodDefault<z.ZodEnum<{
+                click: "click";
+                hover: "hover";
+            }>>;
+        }, z.core.$strip>>;
+        customHtml: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        everyone: "everyone";
+        identified: "identified";
+        anonymous: "anonymous";
+    }>>;
+    targeting: z.ZodDefault<z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>>;
+    trigger: z.ZodPrefault<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<{
+            event: "event";
+            element_click: "element_click";
+            element_visible: "element_visible";
+            delay: "delay";
+            page_load: "page_load";
+            url_match: "url_match";
+            manual: "manual";
+            after_guide: "after_guide";
+            segment_enter: "segment_enter";
+        }>>;
+        value: z.ZodOptional<z.ZodString>;
+        delayMs: z.ZodDefault<z.ZodNumber>;
+        urlPattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    frequency: z.ZodPrefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            once: "once";
+            once_per_session: "once_per_session";
+            every_time: "every_time";
+            interval: "interval";
+        }>>;
+        intervalHours: z.ZodOptional<z.ZodNumber>;
+        maxImpressions: z.ZodOptional<z.ZodNumber>;
+        cooldownHours: z.ZodDefault<z.ZodNumber>;
+        priority: z.ZodDefault<z.ZodNumber>;
+        mutuallyExclusiveWith: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reshowAfterDismiss: z.ZodDefault<z.ZodBoolean>;
+        ignoreThrottling: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    appearance: z.ZodPrefault<z.ZodObject<{
+        theme: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            light: "light";
+            dark: "dark";
+        }>>;
+        primaryColor: z.ZodOptional<z.ZodString>;
+        backgroundColor: z.ZodOptional<z.ZodString>;
+        textColor: z.ZodOptional<z.ZodString>;
+        borderRadius: z.ZodOptional<z.ZodNumber>;
+        fontFamily: z.ZodOptional<z.ZodString>;
+        overlayOpacity: z.ZodOptional<z.ZodNumber>;
+        zIndex: z.ZodOptional<z.ZodNumber>;
+        preset: z.ZodOptional<z.ZodString>;
+        animation: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            fade: "fade";
+            slide: "slide";
+        }>>;
+        customCss: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    checklist: z.ZodOptional<z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodDefault<z.ZodString>;
+            completion: z.ZodDefault<z.ZodEnum<{
+                event: "event";
+                click: "click";
+                manual: "manual";
+                guide_completed: "guide_completed";
+                url_visited: "url_visited";
+            }>>;
+            completionValue: z.ZodOptional<z.ZodString>;
+            action: z.ZodDefault<z.ZodEnum<{
+                url: "url";
+                start_guide: "start_guide";
+                event: "event";
+                none: "none";
+            }>>;
+            actionValue: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        ordered: z.ZodDefault<z.ZodBoolean>;
+        launcherLabel: z.ZodDefault<z.ZodString>;
+        position: z.ZodDefault<z.ZodEnum<{
+            "bottom-left": "bottom-left";
+            "bottom-right": "bottom-right";
+        }>>;
+        completionTitle: z.ZodDefault<z.ZodString>;
+        completionBody: z.ZodDefault<z.ZodString>;
+        autoOpen: z.ZodDefault<z.ZodBoolean>;
+        dismissible: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    survey: z.ZodOptional<z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                text: "text";
+                nps: "nps";
+                csat: "csat";
+                thumbs: "thumbs";
+                single_choice: "single_choice";
+                multiple_choice: "multiple_choice";
+                rating: "rating";
+            }>;
+            title: z.ZodString;
+            description: z.ZodDefault<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>>;
+            scaleMax: z.ZodOptional<z.ZodNumber>;
+            lowLabel: z.ZodOptional<z.ZodString>;
+            highLabel: z.ZodOptional<z.ZodString>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            showWhen: z.ZodOptional<z.ZodObject<{
+                questionId: z.ZodString;
+                op: z.ZodEnum<{
+                    equals: "equals";
+                    lte: "lte";
+                    gte: "gte";
+                    in: "in";
+                }>;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        thankYouTitle: z.ZodDefault<z.ZodString>;
+        thankYouBody: z.ZodDefault<z.ZodString>;
+        position: z.ZodDefault<z.ZodEnum<{
+            "bottom-left": "bottom-left";
+            "bottom-right": "bottom-right";
+            center: "center";
+        }>>;
+        startAt: z.ZodOptional<z.ZodString>;
+        endAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    urlPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    platforms: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        web: "web";
+        ios: "ios";
+        android: "android";
+    }>>>;
+    schedule: z.ZodOptional<z.ZodObject<{
+        startAt: z.ZodOptional<z.ZodString>;
+        endAt: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    localization: z.ZodOptional<z.ZodObject<{
+        translations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type GuideConfig = z.infer<typeof GuideConfigSchema>;
+type GuideConfigInput = z.input<typeof GuideConfigSchema>;
+declare function defaultGuideConfig(kind: GuideKind): GuideConfig;
+declare function defaultStep(type: StepType, overrides?: Partial<GuideStepInput>): GuideStep;
+/** Buttons to show for a step; "back" buttons are hidden when there is no previous step to return to. */
+declare function visibleButtons(step: GuideStep, canGoBack: boolean): GuideStep["buttons"];
+/** Validation beyond Zod shape: returns human-readable problems that block publishing. */
+interface ValidationIssue {
+    level: "error" | "warning";
+    stepId?: string;
+    message: string;
+}
+declare function validateGuideConfig(kind: GuideKind, config: GuideConfig, theme?: Partial<Pick<ProjectTheme, "primaryColor" | "backgroundColor" | "textColor">>): ValidationIssue[];
+interface ProjectTheme {
+    primaryColor: string;
+    backgroundColor: string;
+    textColor: string;
+    borderRadius: number;
+    fontFamily: string;
+    logoUrl?: string;
+    brandName?: string;
+    customCss?: string;
+}
+declare const ProjectThemeSchema: z.ZodObject<{
+    primaryColor: z.ZodDefault<z.ZodString>;
+    backgroundColor: z.ZodDefault<z.ZodString>;
+    textColor: z.ZodDefault<z.ZodString>;
+    borderRadius: z.ZodDefault<z.ZodNumber>;
+    fontFamily: z.ZodDefault<z.ZodString>;
+    logoUrl: z.ZodOptional<z.ZodString>;
+    brandName: z.ZodOptional<z.ZodString>;
+    customCss: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/** Reserved property names that are stripped from `properties` to avoid collecting sensitive data. */
+declare const SENSITIVE_PROPERTY_PATTERN: RegExp;
+declare const MAX_PROPERTY_BYTES: number;
+declare function sanitizeProperties(props: Record<string, unknown> | undefined): Record<string, unknown>;
+
+/** One parsed stack frame. `file` is the script URL (or path) as the browser reported it. */
+interface StackFrame {
+    fn?: string;
+    file?: string;
+    line?: number;
+    col?: number;
+}
+/** Properties carried by an `exception` event (see `docs/product-analytics.md`). */
+interface ExceptionProperties {
+    type: string;
+    message: string;
+    frames: StackFrame[];
+    /** `onerror` | `unhandledrejection` | `manual` (captureException) | `console`. */
+    source?: string;
+    handled?: boolean;
+    /** App version or commit (SDK option `release`); selects the matching uploaded source maps. */
+    release?: string;
+    /** Set by the server at ingestion; groups occurrences into an issue. */
+    fingerprint?: string;
+}
+declare const MAX_STACK_FRAMES = 30;
+/** Parses `Error.stack` from V8, SpiderMonkey and JavaScriptCore into frames (innermost first). */
+declare function parseStack(stack: string | undefined | null, max?: number): StackFrame[];
+/** Replaces volatile parts of a message (numbers, ids, quoted values) so repeats group together. */
+declare function normalizeErrorMessage(message: string): string;
+/** Strips origin, query, hash and build hashes (`main.3f2a1b9c.js` → `main.js`) from a script URL. */
+declare function normalizeFrameFile(file: string | undefined): string;
+/** Source map upload limits (`POST /api/v1/sourcemaps/upload`). */
+/** Per map, uncompressed (the CLI uploads maps gzipped). */
+declare const SOURCEMAP_MAX_FILE_BYTES: number;
+declare const SOURCEMAP_MAX_FILES_PER_UPLOAD = 200;
+/**
+ * Stable issue key for an exception: error type + normalised message + the innermost frame that
+ * has a file (path without build hash + function name, or its original source + name when a source
+ * map resolved it). Line/column numbers are left out because they change with every deploy of a
+ * minified bundle.
+ */
+declare function fingerprintError(input: {
+    type?: string;
+    message?: string;
+    frames?: StackFrame[];
+    original?: {
+        source: string;
+        name?: string | null;
+    } | null;
+}): string;
+
+/**
+ * Resource center structure shared by every SDK: nested collections and audience targeting.
+ *
+ * Audience targeting decides what the help widget lists; it is not access control. The published
+ * config (and every article body) is the same for all visitors of an environment, and end-user
+ * identities are self-asserted, so never rely on it to keep an article private.
+ */
+/** Collections nest at most this deep (a collection, its sections, and their sub-sections). */
+declare const MAX_COLLECTION_DEPTH = 3;
+interface RcCollectionLike {
+    id: string;
+    name: string;
+    order: number;
+    /** Parent collection; null/absent for a top-level collection. */
+    parentId?: string | null;
+    /** Shown only to members of any of these audiences; empty/absent means everyone. */
+    audienceIds?: string[];
+}
+interface RcArticleLike {
+    id: string;
+    collectionId?: string | null;
+    audienceIds?: string[];
+}
+interface RcSection<C extends RcCollectionLike, A extends RcArticleLike> {
+    /** null for articles outside any (known) collection. */
+    collection: C | null;
+    /** Collection names from the top level down, e.g. ["Billing", "Invoices"]. */
+    path: string[];
+    /** 0 for a top-level collection. */
+    depth: number;
+    articles: A[];
+}
+type Membership = ReadonlySet<string> | readonly string[] | undefined | null;
+/** True when an item targeted at `required` audiences is shown to someone in `member`. */
+declare function matchesAudiences(required: readonly string[] | undefined | null, member: Membership): boolean;
+/**
+ * Article sections in display order: each collection (depth first, siblings by `order`) with the
+ * visible articles filed directly in it, then the uncategorized articles. A collection the viewer
+ * isn't targeted by hides its whole subtree, and sections without visible articles are left out
+ * (their sub-collections still appear). Unknown parents count as top level, so an old config or a
+ * dangling reference never hides content.
+ */
+declare function resourceCenterSections<C extends RcCollectionLike, A extends RcArticleLike>(collections: readonly C[], articles: readonly A[], member?: Membership): Array<RcSection<C, A>>;
+/**
+ * Whether one article is listed for a viewer: its own audiences and those of every collection above
+ * it must match. For articles outside a loaded list (e.g. server search results).
+ */
+declare function isArticleListed(collections: readonly RcCollectionLike[], article: RcArticleLike, member?: Membership): boolean;
+/** Who an article is listed for, besides its audiences: everyone, or logged-in (identified) visitors only. */
+declare const ARTICLE_VISIBILITIES: readonly ["everyone", "identified"];
+type ArticleVisibility = (typeof ARTICLE_VISIBILITIES)[number];
+/**
+ * Reserved audience every logged-in visitor belongs to. The server folds an article's visibility into
+ * the audiences it serves and adds this one to identified visitors' memberships, so every SDK (old ones
+ * too) applies "logged-in only" through the audience matching it already does. Anonymous visitors never
+ * identify, so their membership is empty and these articles stay hidden.
+ */
+declare const LOGGED_IN_AUDIENCE = "$identified";
+/**
+ * The audiences an article is served with. Logged-in only with no audiences becomes the reserved
+ * audience; with audiences it is already implied, since audience membership only comes from identify.
+ */
+declare function servedArticleAudiences(audienceIds: readonly string[], visibility: ArticleVisibility | string | null | undefined): string[];
+/** A visitor's memberships as matched against served articles: logged-in visitors are also in `LOGGED_IN_AUDIENCE`. */
+declare function visitorAudiences(audienceIds: readonly string[], identified: boolean): string[];
+/** Ids of the articles a viewer sees (for filtering server search results the same way). */
+declare function visibleArticleIds(collections: readonly RcCollectionLike[], articles: readonly RcArticleLike[], member?: Membership): Set<string>;
+/**
+ * A "Show me" prompt in an article body is a plain link, `<p class="gd-show-me"><a href="#guidely-show-me:<guide key>">Show me how</a></p>`,
+ * so it survives every sanitizer and reads as a harmless link anywhere else. The widgets turn it into a
+ * button that starts the walkthrough (a live flow guide), or hide it when that guide isn't available.
+ */
+declare const SHOW_ME_CLASS = "gd-show-me";
+declare const SHOW_ME_HREF_PREFIX = "#guidely-show-me:";
+declare function showMeHref(guideKey: string): string;
+/** The guide key of a Show me link's `href`, or null. */
+declare function showMeKeyFromHref(href: string | null | undefined): string | null;
+/** Guide keys of the Show me prompts in an article body, in order, without repeats (at most 10). */
+declare function showMeKeys(html: string | null | undefined): string[];
+/** The article body plays a video (uploaded, or embedded from YouTube, Vimeo, Loom or Wistia). */
+declare function hasVideoMedia(html: string | null | undefined): boolean;
+/**
+ * Help search on the device: every word of the query starts a word of the text, in any order, or the
+ * query appears as typed. "add user" finds "Add a new user" and "Users › Add".
+ */
+declare function matchesHelpQuery(text: string, query: string): boolean;
+declare const RC_MODULE_IDS: readonly ["announcements", "search", "checklists", "guides", "articles", "links", "faqs"];
+type ResourceCenterModuleId = (typeof RC_MODULE_IDS)[number];
+declare const RC_MODULE_LABELS: Record<ResourceCenterModuleId, string>;
+/**
+ * The resource center's sections in display order: the configured modules (unknown ids dropped,
+ * missing ones appended enabled, in the default order), so an old config shows every section.
+ */
+declare function orderedModules<M extends {
+    id: string;
+    enabled: boolean;
+}>(modules: readonly M[] | null | undefined): Array<M | {
+    id: ResourceCenterModuleId;
+    enabled: true;
+}>;
+/** Announcements a visitor sees: published (not in the future), audience-matched, newest first. */
+declare function visibleAnnouncements<A extends {
+    publishedAt: string;
+    audienceIds?: string[];
+}>(items: readonly A[] | null | undefined, member?: Membership, now?: number): A[];
+/** Unread count for the launcher badge: announcements published after the visitor last opened "What's new". */
+declare function unreadAnnouncements(items: readonly {
+    publishedAt: string;
+}[], lastSeenAt: string | null | undefined): number;
+/**
+ * A link to a help article from guide or article HTML: `<a href="#guidely-article:ID">`. A fragment
+ * survives every sanitizer (editor, server, SDK), and the SDKs open the article in the resource
+ * center (or Scout's Help tab) instead of following the link.
+ */
+declare const ARTICLE_HREF_PREFIX = "#guidely-article:";
+declare function articleHref(articleId: string): string;
+/** The article id of an article link's `href`, or null. */
+declare function articleIdFromHref(href: string | null | undefined): string | null;
+
+/** How-to capture constants the browser SDK needs without zod (also exported from `@guidelytech/shared/runtime`). */
+/** Query parameter that starts capture mode in the SDK (separate from `guidely_authoring`, so SDKs without capture ignore it). */
+declare const CAPTURE_PARAM = "guidely_capture";
+/** Largest screenshot the capture endpoint accepts. */
+declare const CAPTURE_SCREENSHOT_MAX_BYTES: number;
+
+/**
+ * How-tos: step-by-step guides with screenshots, recorded by clicking through the customer's app
+ * (SDK capture mode) and edited in the dashboard. Each step is either an action captured in the app
+ * (click, type, select, navigate) or a block the author added (text, heading, tip, alert).
+ */
+declare const HOWTO_STEP_KINDS: readonly ["action", "text", "heading", "tip", "alert"];
+type HowToStepKind = (typeof HOWTO_STEP_KINDS)[number];
+declare const HOWTO_ACTIONS: readonly ["click", "type", "select", "navigate"];
+type HowToAction = (typeof HOWTO_ACTIONS)[number];
+/** A rectangle as fractions (0–1) of its screenshot, so it survives any rendered size. */
+declare const NormalizedRectSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+type NormalizedRect = z.infer<typeof NormalizedRectSchema>;
+/** The element an action was performed on, described for people (not for selecting it). */
+declare const CapturedElementSchema: z.ZodObject<{
+    label: z.ZodDefault<z.ZodString>;
+    role: z.ZodDefault<z.ZodString>;
+    tag: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type CapturedElement = z.infer<typeof CapturedElementSchema>;
+/**
+ * One action the SDK recorded, sent with its screenshot as multipart form data
+ * (`step` = this JSON, `screenshot` = the image) to `POST /api/v1/sdk/capture/steps?token=`.
+ * Sensitive values never arrive here: the SDK drops typed text from password, payment, one-time-code
+ * and masked fields and redacts screenshots in the browser before uploading them.
+ */
+declare const CaptureStepSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    action: z.ZodEnum<{
+        type: "type";
+        click: "click";
+        select: "select";
+        navigate: "navigate";
+    }>;
+    url: z.ZodString;
+    pageTitle: z.ZodDefault<z.ZodString>;
+    element: z.ZodOptional<z.ZodObject<{
+        label: z.ZodDefault<z.ZodString>;
+        role: z.ZodDefault<z.ZodString>;
+        tag: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    value: z.ZodOptional<z.ZodString>;
+    valueRedacted: z.ZodDefault<z.ZodBoolean>;
+    selectors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            id: "id";
+            text: "text";
+            css: "css";
+            "data-attr": "data-attr";
+            aria: "aria";
+            xpath: "xpath";
+            "guidely-id": "guidely-id";
+        }>;
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    highlight: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    redactions: z.ZodDefault<z.ZodNumber>;
+    occurredAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CaptureStep = z.infer<typeof CaptureStepSchema>;
+type CaptureStepInput = z.input<typeof CaptureStepSchema>;
+/** `GET /api/v1/sdk/capture/session?token=`: what the SDK needs to start recording. */
+interface CaptureSessionInfo {
+    id: string;
+    projectId: string;
+    environment: string;
+    howToId: string;
+    howToTitle: string;
+    /** Origin of the dashboard window that opened the app (for `postMessage`). */
+    dashboardOrigin: string;
+    expiresAt: string;
+    /** Steps already recorded (a recording continues across full page loads). */
+    stepCount: number;
+    /** False when the server has no media storage: record steps without screenshots. */
+    screenshots: boolean;
+}
+
+/**
+ * A label as people would say it: icon glyphs and symbols at either end ("+ New contact", "Next →")
+ * and required-field markers ("Email *", "Name:") removed. Falls back to the raw label when nothing
+ * readable is left.
+ */
+declare function cleanLabel(label: string | undefined | null): string;
+/**
+ * Name of the page a navigate step opens. A title like "Contacts · Northwind CRM" gives "Contacts";
+ * a title that's just the app's name (no word of the path in it) gives the path instead, so
+ * "/contacts/new" reads "Contacts › New". Ids in the path are skipped.
+ */
+declare function pageName(url: string, pageTitle: string | undefined | null): string;
+/** Plain-language instruction for a captured action, e.g. `Click “Save”` or `Type “Acme” into “Company”`. */
+declare function describeCaptureStep(step: Pick<CaptureStepInput, "action" | "element" | "value" | "valueRedacted" | "pageTitle" | "url">): string;
+/** A point as fractions (0–1) of a screenshot. */
+declare const NormalizedPointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+declare const ANNOTATION_COLORS: readonly ["brand", "red", "amber", "green", "black", "white"];
+type AnnotationColor = (typeof ANNOTATION_COLORS)[number];
+/**
+ * A mark drawn over a step's screenshot, in fractions of the full image so it survives cropping and
+ * any rendered size: an arrow, a text label or a box. `brand` uses the project's primary colour.
+ */
+declare const HowToAnnotationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"arrow">;
+    from: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    to: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    color: z.ZodDefault<z.ZodEnum<{
+        brand: "brand";
+        red: "red";
+        amber: "amber";
+        green: "green";
+        black: "black";
+        white: "white";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"text">;
+    at: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>;
+    text: z.ZodString;
+    color: z.ZodDefault<z.ZodEnum<{
+        brand: "brand";
+        red: "red";
+        amber: "amber";
+        green: "green";
+        black: "black";
+        white: "white";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"box">;
+    rect: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+    color: z.ZodDefault<z.ZodEnum<{
+        brand: "brand";
+        red: "red";
+        amber: "amber";
+        green: "green";
+        black: "black";
+        white: "white";
+    }>>;
+}, z.core.$strip>], "type">;
+type HowToAnnotation = z.infer<typeof HowToAnnotationSchema>;
+declare const MAX_ANNOTATIONS = 30;
+
+/** Complaint types and limits shared by the server and the messenger runtime (zod-free). */
+/** Where a complaint is in its handling; the messenger shows it as Received → In review → Resolved. */
+declare const COMPLAINT_STATUSES: readonly ["open", "in_review", "resolved"];
+type ComplaintStatus = (typeof COMPLAINT_STATUSES)[number];
+/** Events a complaint webhook can fire on. */
+declare const COMPLAINT_EVENTS: readonly ["complaint.filed", "complaint.status_changed", "complaint.replied", "complaint.resolved"];
+type ComplaintEvent = (typeof COMPLAINT_EVENTS)[number];
+/** Extra questions a category asks for. */
+declare const COMPLAINT_FIELD_TYPES: readonly ["text", "choice"];
+type ComplaintFieldType = (typeof COMPLAINT_FIELD_TYPES)[number];
+declare const MAX_COMPLAINT_FIELDS = 8;
+declare const MAX_COMPLAINT_CHOICES = 12;
+declare const MAX_COMPLAINT_LENGTH = 4000;
+declare const MAX_COMPLAINT_ANSWER_LENGTH = 500;
+/** Largest screenshot the messenger may attach (after it scales the image down). */
+declare const MAX_COMPLAINT_ATTACHMENT_BYTES: number;
+interface ComplaintField {
+    /** Stable id (`invoice_number`), used as the answer's key in webhook payloads. */
+    id: string;
+    label: string;
+    type: ComplaintFieldType;
+    /** Choices for `choice` questions. */
+    options?: string[];
+    required: boolean;
+}
+/** "CMP-1042" for complaint number 1042. */
+declare const complaintReference: (number: number) => string;
+/** A category as the messenger offers it. */
+interface MessengerComplaintCategory {
+    id: string;
+    name: string;
+    description: string;
+    color: string;
+    fields: ComplaintField[];
+}
+/** Complaints block of `MessengerConfig`; absent when the project doesn't take complaints. */
+interface MessengerComplaintsConfig {
+    categories: MessengerComplaintCategory[];
+    /** Visitors the app hasn't identified may file one (with an email address). */
+    anonymous: boolean;
+}
+/** A complaint as the person who filed it sees it (on its conversation). */
+interface MessengerComplaint {
+    id: string;
+    reference: string;
+    status: ComplaintStatus;
+    categoryName: string;
+    createdAt: string;
+}
+/** Scout offered the complaint form in a reply, with this category picked. */
+interface MessengerComplaintOffer {
+    categoryId: string;
+    name: string;
+}
+
+/** Feedback (feature requests) types and limits shared by the server, the portal and the messenger runtime (zod-free). */
+/** Where a request is: shown to end users with FEEDBACK_STATUS_LABEL. */
+declare const FEEDBACK_STATUSES: readonly ["new", "under_review", "planned", "in_progress", "released", "declined"];
+type FeedbackStatus = (typeof FEEDBACK_STATUSES)[number];
+declare const FEEDBACK_STATUS_LABEL: Record<FeedbackStatus, string>;
+/** How much a voter needs it; weights 1 / 2 / 3 in the priority score. */
+declare const FEEDBACK_PRIORITIES: readonly ["nice_to_have", "important", "critical"];
+type FeedbackPriority = (typeof FEEDBACK_PRIORITIES)[number];
+declare const FEEDBACK_PRIORITY_LABEL: Record<FeedbackPriority, string>;
+declare const FEEDBACK_PRIORITY_WEIGHT: Record<FeedbackPriority, number>;
+/** Events feedback integrations (Slack, webhooks) can get. */
+declare const FEEDBACK_EVENTS: readonly ["request.created", "request.status_changed", "request.voted"];
+type FeedbackEvent = (typeof FEEDBACK_EVENTS)[number];
+declare const MAX_FEEDBACK_TITLE = 140;
+declare const MAX_FEEDBACK_DESCRIPTION = 4000;
+declare const MAX_FEEDBACK_COMMENT = 2000;
+declare const MAX_FEEDBACK_NOTE = 500;
+/** "#42" for request number 42. */
+declare const feedbackReference: (number: number) => string;
+/** A request as end users see it (messenger Ideas tab, portal). */
+interface PublicFeedbackRequest {
+    id: string;
+    number: number;
+    title: string;
+    description: string;
+    status: FeedbackStatus;
+    /** Public note shown with the status, when the team wrote one. */
+    statusNote: string;
+    productArea: string | null;
+    votes: number;
+    comments: number;
+    /** This visitor's vote, if any. */
+    myVote: {
+        priority: FeedbackPriority;
+    } | null;
+    following: boolean;
+    /** The visitor submitted it. */
+    mine: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PublicFeedbackComment {
+    id: string;
+    authorName: string;
+    /** "team" replies are shown with a badge. */
+    authorType: "user" | "team";
+    body: string;
+    createdAt: string;
+}
+interface PublicFeedbackRequestDetail extends PublicFeedbackRequest {
+    thread: PublicFeedbackComment[];
+}
+interface PublicFeedbackList {
+    requests: PublicFeedbackRequest[];
+    hasMore: boolean;
+}
+/** An update about a request the visitor follows (status changed, merged). */
+interface FeedbackUpdate {
+    id: string;
+    requestId: string | null;
+    kind: "status" | "merged" | "comment";
+    title: string;
+    body: string;
+    read: boolean;
+    createdAt: string;
+}
+interface FeedbackUpdatesResponse {
+    updates: FeedbackUpdate[];
+    unread: number;
+}
+/** Ideas block of `MessengerConfig`; absent when the project hasn't turned on the Ideas tab. */
+interface MessengerIdeasConfig {
+    /** Tab and heading title. */
+    title: string;
+    /** Visitors the app hasn't identified may vote and submit (otherwise they can only browse). */
+    anonymous: boolean;
+    /** Votes and new ideas need a signed identity: the messenger only browses and links to the portal. */
+    readOnly: boolean;
+    /** Product areas people may tag new ideas with. */
+    productAreas: string[];
+    /** The hosted portal is on (the messenger offers "Open the portal"). */
+    portal: boolean;
+}
+/** Scout offered to file or upvote a feature request in a reply. */
+interface MessengerIdeaOffer {
+    /** The matching request to upvote, or null to suggest a new one. */
+    requestId: string | null;
+    title: string;
+    /** Prefilled description for a new idea (the person's words, summarised). */
+    description: string;
+    votes?: number;
+}
+
+/** How quickly the team usually replies, shown on the messenger home screen. */
+declare const REPLY_TIMES: readonly ["minutes", "hour", "hours", "day"];
+type ReplyTime = (typeof REPLY_TIMES)[number];
+/** Levels of the status card on the messenger home screen. */
+declare const STATUS_LEVELS: readonly ["operational", "degraded", "outage", "maintenance"];
+type StatusLevel = (typeof STATUS_LEVELS)[number];
+/** A teammate shown on the messenger home screen (first name only). */
+interface MessengerTeammate {
+    name: string;
+    avatarUrl: string | null;
+}
+interface MessengerStatus {
+    level: StatusLevel;
+    message: string;
+    updatedAt: string;
+}
+/** Which personalised cards the messenger home screen shows. */
+interface MessengerHomeCards {
+    /** Guides, how-tos, articles and common questions for the page the user is on. */
+    suggestions: boolean;
+    /** A guide the user started and didn't finish, and checklist progress. */
+    progress: boolean;
+    /** Live announcements (also the News tab). */
+    news: boolean;
+}
+/** Messenger settings delivered to the SDK in `SdkConfigResponse.messenger`. */
+interface MessengerConfig {
+    enabled: boolean;
+    /** Display name of the AI agent ("Scout"). */
+    name: string;
+    greeting: string;
+    /** Scout answers with AI; when false every conversation goes to the team inbox. */
+    aiAvailable: boolean;
+    handoffEnabled: boolean;
+    launcher: {
+        position: "bottom-right" | "bottom-left";
+    };
+    /** Absent from servers before the personalised home screen; SDKs fall back to their defaults. */
+    replyTime?: ReplyTime | null;
+    team?: MessengerTeammate[];
+    status?: MessengerStatus | null;
+    home?: MessengerHomeCards;
+    /** Complaint categories when the project takes complaints in the messenger (absent from older servers). */
+    complaints?: MessengerComplaintsConfig | null;
+    /** The Ideas tab (feature requests) when the project turned it on (absent from older servers). */
+    ideas?: MessengerIdeasConfig | null;
+}
+/** Page-matched content for the messenger, from `POST /sdk/messenger/page`. */
+type MessengerPageSuggestion = {
+    type: "article";
+    articleId: string;
+    title: string;
+    summary: string;
+}
+/** A how-to recorded on this page, opened as its help article. */
+ | {
+    type: "howto";
+    articleId: string;
+    title: string;
+    steps: number;
+};
+interface MessengerPageContent {
+    /** The page as matched: its path with ids folded (`/invoices/:id`). */
+    path: string;
+    label: string | null;
+    suggestions: MessengerPageSuggestion[];
+    /** Questions people ask on this page (FAQs and learned answers); tapping one asks Scout. */
+    questions: string[];
+}
+declare const MessengerPageRequestSchema: z.ZodObject<{
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    path: z.ZodString;
+}, z.core.$strip>;
+type MessengerPageRequest = z.infer<typeof MessengerPageRequestSchema>;
+declare const MESSAGE_AUTHORS: readonly ["user", "scout", "agent", "system"];
+type MessageAuthor = (typeof MESSAGE_AUTHORS)[number];
+type ConversationStatus = "bot" | "open" | "closed";
+interface MessengerCitation {
+    articleId: string;
+    title: string;
+}
+interface MessengerSuggestedGuide {
+    key: string;
+    name: string;
+}
+/** A how-to Scout relied on; the messenger opens it in place (`GET /sdk/how-tos/:id`). */
+interface MessengerHowToCitation {
+    howToId: string;
+    title: string;
+}
+interface MessengerMessage {
+    id: string;
+    author: MessageAuthor;
+    /** Team member name for `agent` messages. */
+    authorName?: string | null;
+    body: string;
+    citations: MessengerCitation[];
+    suggestedGuides: MessengerSuggestedGuide[];
+    /** How-tos Scout cited (absent when none; SDKs before how-to support ignore it). */
+    howTos?: MessengerHowToCitation[];
+    /** Scout offered the complaint form (absent otherwise). */
+    complaintOffer?: MessengerComplaintOffer;
+    /** Scout offered to file or upvote a feature request (absent otherwise). */
+    ideaOffer?: MessengerIdeaOffer;
+    status: "pending" | "complete" | "failed";
+    createdAt: string;
+}
+interface MessengerConversation {
+    id: string;
+    status: ConversationStatus;
+    subject: string;
+    lastMessageAt: string;
+    lastMessagePreview: string;
+    unread: number;
+    rating: number | null;
+    /** The complaint filed in this conversation, latest first (absent when none). */
+    complaint?: MessengerComplaint;
+}
+declare const MAX_MESSAGE_LENGTH = 4000;
+declare const StartConversationSchema: z.ZodObject<{
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    message: z.ZodString;
+    pageUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type StartConversationRequest = z.infer<typeof StartConversationSchema>;
+interface StartConversationResponse {
+    conversation: MessengerConversation;
+    /** Secret that authorises this browser to read and post in the conversation. Store it; it is not shown again. */
+    token: string;
+    messages: MessengerMessage[];
+}
+declare const ConversationLookupSchema: z.ZodObject<{
+    tokens: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+interface ConversationLookupResponse {
+    conversations: Array<MessengerConversation & {
+        token: string;
+    }>;
+}
+declare const PostMessageSchema: z.ZodObject<{
+    message: z.ZodString;
+    pageUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ConversationRatingSchema: z.ZodObject<{
+    rating: z.ZodNumber;
+    comment: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+interface FileComplaintResponse {
+    complaint: MessengerComplaint;
+    conversation: MessengerConversation;
+    /** Token of the conversation started for it (absent when it was filed in an existing one). */
+    token?: string;
+}
+interface ConversationMessagesResponse {
+    conversation: MessengerConversation;
+    messages: MessengerMessage[];
+}
+/**
+ * Server-sent events streamed by `POST /sdk/conversations` and `POST /sdk/conversations/:id/messages`
+ * while Scout replies. `conversation` (start only) carries the new conversation and its token, `message`
+ * each stored message, `delta` reply text as it is generated, and `done` the final stored message.
+ */
+type ScoutStreamEvent = {
+    event: "conversation";
+    data: StartConversationResponse;
+} | {
+    event: "message";
+    data: MessengerMessage;
+} | {
+    event: "delta";
+    data: {
+        messageId: string;
+        text: string;
+    };
+} | {
+    event: "done";
+    data: {
+        message: MessengerMessage;
+        conversation: MessengerConversation;
+    };
+} | {
+    event: "error";
+    data: {
+        message: string;
+    };
+};
+/** Article list entry for the messenger Help tab (bodies are fetched on demand). */
+interface SdkArticleSummary {
+    id: string;
+    slug: string;
+    title: string;
+    summary: string;
+    collectionId: string | null;
+    externalUrl: string | null;
+    /** Listed only for members of these audiences (absent = everyone). */
+    audienceIds?: string[];
+    /** Guide keys of the article's "Show me" prompts (absent = none). */
+    walkthroughs?: string[];
+    hasVideo?: boolean;
+    updatedAt: string;
+}
+interface SdkArticlesResponse {
+    collections: ResourceCenterCollection[];
+    articles: SdkArticleSummary[];
+}
+/** A how-to the team made available in the app (`GET /sdk/how-tos`). */
+interface SdkHowToSummary {
+    id: string;
+    title: string;
+    description: string;
+    /** Numbered (recorded) steps. */
+    stepCount: number;
+    /** Key of the interactive tour made from it, when that tour is live in this environment ("Show me"). */
+    guideKey?: string;
+    /** The how-to has a video. */
+    hasVideo?: boolean;
+    updatedAt: string;
+}
+interface SdkHowTosResponse {
+    /** Every how-to available in the app, by title (at most 200). */
+    howTos: SdkHowToSummary[];
+    /** Ids of the ones recorded on the page in `?url=`, best match first (at most 5). */
+    forPage: string[];
+}
+/** One step as the messenger renders it: text only, plus a screenshot with the element's highlight. */
+interface SdkHowToStep {
+    id: string;
+    kind: HowToStepKind;
+    title: string;
+    body: string;
+    image?: {
+        url: string;
+        /** Show only this part of the screenshot (zoomed in on the element). */
+        crop?: NormalizedRect;
+        /** The element, in the coordinates of the (cropped) image. */
+        highlight?: NormalizedRect;
+    };
+}
+/** `GET /sdk/how-tos/:id`: an available how-to with its steps. */
+interface SdkHowTo {
+    id: string;
+    title: string;
+    description: string;
+    updatedAt: string;
+    steps: SdkHowToStep[];
+    /** Key of the interactive tour made from it, when that tour is live in this environment ("Show me"). */
+    guideKey?: string;
+    /** Video made from the how-to (WebM), played above the steps. */
+    video?: {
+        url: string;
+    };
+}
+
+/**
+ * Product-analytics capture settings. Stored on `Project.settings` (keys `autocapture`,
+ * `errorTracking`, `replay`) and delivered to the SDK in `SdkConfigResponse.settings`. The project
+ * setting turns a capability on; SDK options can only turn it off for one installation.
+ */
+interface AutocaptureSettings {
+    /** `page_view` on load and on every SPA navigation. */
+    pageviews: boolean;
+    /** `page_leave` with visible time on page and scroll depth. */
+    pageLeave: boolean;
+    /** `click` on buttons, links and other interactive elements. */
+    clicks: boolean;
+    /** `rage_click` when the same spot is clicked 3+ times within a second. */
+    rageClicks: boolean;
+    /** Batched click positions on every element (`heatmap` events) for click heatmaps. */
+    heatmaps: boolean;
+    /** Mouse-movement heatmaps: pointer position sampled while it moves, aggregated in the browser into `heatmap` events. */
+    mouseMovement: boolean;
+    /**
+     * Mobile SDKs: `app_install`, `app_update`, `app_open` and `app_background` events (ignored on the web).
+     * Optional in the type for older stored settings; `resolveCaptureSettings` always fills it.
+     */
+    appLifecycle?: boolean;
+}
+interface ErrorTrackingSettings {
+    /** Uncaught errors and unhandled promise rejections become `exception` events. */
+    enabled: boolean;
+}
+interface ReplaySettings {
+    enabled: boolean;
+    /** Percentage of sessions recorded (0–100), decided once per session. */
+    sampleRate: number;
+    /** Record console.log/warn/error output into the recording. */
+    recordConsole: boolean;
+    /** Record network requests (method, URL with sensitive query values redacted, status, timing, size). */
+    recordNetwork: boolean;
+    /** Also record request/response headers and text/JSON bodies (redacted, ≤10KB each). Off by default. */
+    recordNetworkPayloads: boolean;
+    /** Mask every text node (inputs are always masked). */
+    maskAllText: boolean;
+    /**
+     * Mask every image (mobile SDKs; the web SDK gets image block selectors instead). Not a project setting: the
+     * server sets it for HIPAA-mode workspaces, which also force `maskAllText` and turn console and payloads off.
+     */
+    maskAllImages?: boolean;
+    /** Elements replaced by a placeholder box in recordings (in addition to `[data-guidely-block]`). */
+    blockSelectors: string[];
+    /** Days recordings are kept before the worker deletes them. */
+    retentionDays: number;
+}
+interface CaptureSettings {
+    autocapture: AutocaptureSettings;
+    errorTracking: ErrorTrackingSettings;
+    replay: ReplaySettings;
+}
+declare const AutocaptureSettingsSchema: z.ZodObject<{
+    pageviews: z.ZodOptional<z.ZodBoolean>;
+    pageLeave: z.ZodOptional<z.ZodBoolean>;
+    clicks: z.ZodOptional<z.ZodBoolean>;
+    rageClicks: z.ZodOptional<z.ZodBoolean>;
+    heatmaps: z.ZodOptional<z.ZodBoolean>;
+    mouseMovement: z.ZodOptional<z.ZodBoolean>;
+    appLifecycle: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ErrorTrackingSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const ReplaySettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    sampleRate: z.ZodOptional<z.ZodNumber>;
+    recordConsole: z.ZodOptional<z.ZodBoolean>;
+    recordNetwork: z.ZodOptional<z.ZodBoolean>;
+    recordNetworkPayloads: z.ZodOptional<z.ZodBoolean>;
+    maskAllText: z.ZodOptional<z.ZodBoolean>;
+    blockSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    retentionDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const DEFAULT_CAPTURE_SETTINGS: CaptureSettings;
+/**
+ * A project's recording level: a preset over the replay toggles, picked per project in Settings →
+ * Workspace or Privacy & data. Sample rate, block selectors and retention are kept as they are.
+ */
+declare const RECORDING_LEVELS: readonly ["off", "privacy", "standard", "full"];
+type RecordingLevel = (typeof RECORDING_LEVELS)[number];
+/** The level a project's replay settings match, or "custom" when the toggles were set by hand. */
+declare function recordingLevel(replay: ReplaySettings): RecordingLevel | "custom";
+/** Replay settings set to a level. "off" stops recording and leaves the toggles for when it's turned back on. */
+declare function withRecordingLevel(replay: ReplaySettings, level: RecordingLevel): ReplaySettings;
+/** Fills defaults for whatever a project's stored settings leave out. */
+declare function resolveCaptureSettings(settings: unknown): CaptureSettings;
+/**
+ * One position in a `heatmap` event (`properties.points`). `x`/`y` are page coordinates in CSS
+ * pixels; `s` is a stable selector for the element and `rx`/`ry` the position inside it (0–1), which
+ * lets the dashboard place the point on the element even when layouts differ.
+ *
+ * Mouse movement (`k: "m"`) is sampled at most every 200ms while the pointer moves and binned in the
+ * browser (per element at 0.1 of `rx`/`ry`, else on a 16px page grid); `w` is the number of samples
+ * in the bin, so a minute of movement costs a few dozen points rather than thousands.
+ */
+interface HeatmapPoint {
+    /** `c` click, `r` part of a rage-click burst, `m` mouse movement. */
+    k: "c" | "r" | "m";
+    x: number;
+    y: number;
+    s?: string;
+    rx?: number;
+    ry?: number;
+    /** Weight: samples aggregated into this point (movement only; clicks are 1). */
+    w?: number;
+}
+/** Properties of a `heatmap` event: a batch of clicks on one page (flushed at ~40 points and on page leave). */
+interface HeatmapProperties {
+    path?: string;
+    viewportWidth: number;
+    viewportHeight: number;
+    /** Document scroll height when the batch was sent. */
+    pageHeight: number;
+    points: HeatmapPoint[];
+}
+/** Viewport buckets heatmaps are split by (CSS px of `viewportWidth`). */
+declare const HEATMAP_VIEWPORTS: {
+    readonly mobile: readonly [0, 767];
+    readonly tablet: readonly [768, 1279];
+    readonly desktop: readonly [1280, 100000];
+};
+type HeatmapViewport = keyof typeof HEATMAP_VIEWPORTS;
+/**
+ * One upload of rrweb events for a recording, `POST /api/v1/sdk/replay`. The SDK sends it as JSON,
+ * or gzip-compressed JSON with `?enc=gzip`. A recording is keyed by the SDK session id; every page
+ * load starts a new `windowId` whose uploads are numbered by `seq`.
+ */
+declare const ReplayChunkSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    windowId: z.ZodString;
+    seq: z.ZodNumber;
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    events: z.ZodArray<z.ZodObject<{
+        type: z.ZodNumber;
+        timestamp: z.ZodNumber;
+    }, z.core.$loose>>;
+    url: z.ZodOptional<z.ZodString>;
+    device: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        browser: z.ZodOptional<z.ZodString>;
+        os: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    sdk: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ReplayChunk = z.infer<typeof ReplayChunkSchema>;
+/** Max upload sizes for one replay chunk (bytes on the wire, and after decompression). */
+declare const REPLAY_MAX_COMPRESSED_BYTES: number;
+declare const REPLAY_MAX_RAW_BYTES: number;
+
+/**
+ * Tagged pages and features (named rules over the URLs and clicks the SDK captures), shared by the server (retroactive
+ * matching, SQL generation), the dashboard (previews) and the SDK (event properties). Pure and zod-free.
+ *
+ * - An `ElementSnapshot` is the compact description of a clicked element the SDK attaches to `click`
+ *   events (`properties.el`): tag, id, classes, a few safe attributes, nth-of-type, ~5 ancestors and
+ *   the shadow hosts above it. CSS selector rules are evaluated against it with {@link matchCssSelector},
+ *   so a rule written today also matches clicks stored before it existed.
+ * - Older clicks carry only a selector string; {@link snapshotFromSelector} turns that string into a
+ *   partial snapshot so CSS rules still match them where the string says enough.
+ */
+/** One element in a snapshot: tag, id, classes, safe attributes and its 1-based nth-of-type. */
+interface ElementNode {
+    t: string;
+    id?: string;
+    c?: string[];
+    a?: Record<string, string>;
+    n?: number;
+}
+/** A clicked element (`click.properties.el`): the element, its ancestors (`p`, parent first) and shadow hosts (`h`, nearest first). */
+interface ElementSnapshot extends ElementNode {
+    p?: ElementNode[];
+    h?: ElementNode[];
+}
+declare const SNAPSHOT_LIMITS: {
+    readonly classes: 8;
+    readonly className: 60;
+    readonly attrs: 6;
+    readonly attrValue: 100;
+    readonly ancestors: 5;
+    readonly hosts: 3;
+    readonly tag: 40;
+    readonly id: 80;
+};
+/** Attributes a snapshot may carry besides `data-*` ones. Never `value`, never event handlers. */
+declare const SNAPSHOT_ATTRS: readonly ["role", "name", "type", "aria-label", "title", "alt", "for", "href"];
+/** Framework and state `data-*` attributes that say nothing stable about an element. */
+declare const NOISY_DATA_ATTR: RegExp;
+/** The custom attribute that names a feature by default (`<button data-guidely-feature="Export CSV">`). */
+declare const DEFAULT_FEATURE_ATTRIBUTE = "data-guidely-feature";
+declare const FEATURE_ATTRIBUTE_PATTERN: RegExp;
+/** Validates and trims a snapshot sent by an SDK (server side); null when it is not one. */
+declare function normalizeSnapshot(raw: unknown): ElementSnapshot | null;
+/** JSON with sorted keys, so equal snapshots hash the same whatever order the SDK wrote them in. */
+declare function stableStringify(v: unknown): string;
+type AttrOp = "exists" | "=" | "^=" | "$=" | "*=" | "~=" | "|=";
+interface AttrTest {
+    name: string;
+    op: AttrOp;
+    value?: string;
+    /** `[attr="x" i]` */
+    insensitive?: boolean;
+}
+interface Compound {
+    tag?: string;
+    id?: string;
+    classes: string[];
+    attrs: AttrTest[];
+    /** `:nth-of-type(n)`; `odd`/`even` as `{ a: 2, b: 1|0 }`; `:first-of-type` is `{ a: 0, b: 1 }`. */
+    nth?: {
+        a: number;
+        b: number;
+    };
+}
+/** A complex selector: compounds left to right and the combinator before each (index 0 has none). */
+interface ComplexSelector {
+    compounds: Compound[];
+    combinators: Array<" " | ">" | ">>>">;
+}
+declare class SelectorSyntaxError extends Error {
+}
+/**
+ * Parses the supported subset: type and universal selectors, `#id`, `.class`, `[attr]`,
+ * `[attr=v]`, `^=`, `$=`, `*=`, `~=`, `|=` (optionally `i`), `:nth-of-type(n|odd|even)`,
+ * `:first-of-type`, descendant and child combinators, `>>>` (shadow host) and selector lists.
+ * Throws {@link SelectorSyntaxError} on anything else.
+ */
+declare function parseCssSelector(input: string): ComplexSelector[];
+/** Is the selector inside the supported subset? Returns the error message, or null when it parses. */
+declare function cssSelectorError(selector: string): string | null;
+/** Does one compound match one node? An unknown nth-of-type fails `:nth-of-type` tests. */
+declare function compoundMatches(c: Compound, node: ElementNode): boolean;
+/** Does a CSS selector (subset, see {@link parseCssSelector}) match the snapshot? Invalid selectors match nothing. */
+declare function matchCssSelector(selector: string | ComplexSelector[], snap: ElementSnapshot): boolean;
+/**
+ * A partial snapshot read from a stored selector string (clicks captured before snapshots existed):
+ * `#form > div:nth-of-type(2) > button[data-testid="save"]` becomes a `button` with that attribute,
+ * nth 1-unknown, and two ancestors. Shadow steps (`c-app >>> button`) become hosts. Null when the
+ * string is not a selector in the supported subset.
+ */
+declare function snapshotFromSelector(selector: string, tag?: string | null): ElementSnapshot | null;
+type QueryParamOp = "exists" | "absent" | "equals" | "contains";
+interface QueryParamCondition {
+    name: string;
+    op: QueryParamOp;
+    value?: string;
+}
+/**
+ * One way a URL belongs to a page. `url`: a pattern (`/accounts/:id/settings`, `/reports/*`,
+ * `/docs/**`, `//*\/billing`, `https://app.acme.com/x`) plus optional query conditions; `regex`: a
+ * regular expression over the path; `title`: the document title (`equals` / `contains`). With
+ * `exclude`, matching URLs are taken out of the page instead.
+ */
+interface PageRule {
+    id?: string;
+    type: "url" | "regex" | "title";
+    value: string;
+    op?: "equals" | "contains";
+    query?: QueryParamCondition[];
+    exclude?: boolean;
+}
+declare const PAGE_RULE_LIMITS: {
+    readonly rules: 20;
+    readonly value: 500;
+    readonly query: 5;
+};
+interface PagePattern {
+    /** Anchored regex source, valid both as a JS RegExp (flag `i`) and a Postgres ARE (`~*`). */
+    source: string;
+    /** What it runs against: the path (query removed) or the full URL without query and hash. */
+    target: "path" | "url";
+    /** Query conditions written into the pattern (`/search?tab=people`). */
+    query: QueryParamCondition[];
+}
+/** Turns a URL rule pattern into a regex. Query parameters in the pattern become conditions. */
+declare function pagePattern(raw: string): PagePattern;
+/** Regex (JS + Postgres) for a query condition over a raw URL. */
+declare function queryConditionRegex(c: QueryParamCondition): string;
+interface PageContext {
+    /** Full URL (with query) when known. */
+    url?: string | null;
+    /** Path as stored (`/a/b`, or `/a/b?section=x` with kept page parameters). */
+    path?: string | null;
+    title?: string | null;
+}
+/** JS twin of the SQL a page rule compiles to (server `pageRuleSql`). */
+declare function pageRuleMatches(rule: PageRule, ctx: PageContext): boolean;
+/** Included by any include rule and excluded by no exclude rule. */
+declare function pageRulesMatch(rules: PageRule[], ctx: PageContext): boolean;
+/** Validation message for a page rule, or null. */
+declare function pageRuleError(rule: PageRule): string | null;
+type SelectorOp = "exact" | "prefix" | "contains" | "glob" | "css";
+/**
+ * One way a click belongs to a feature. Every condition present must hold. `selector.op = "css"`
+ * evaluates a CSS selector against the element snapshot (or, for old clicks, the snapshot read from
+ * the stored selector string); the other selector operators compare the stored selector string —
+ * mobile taps store the accessibility id / `data-guidely-id` there, so `exact` works for them too.
+ */
+interface FeatureRule {
+    id?: string;
+    selector?: {
+        op: SelectorOp;
+        value: string;
+    };
+    text?: {
+        op: "equals" | "contains";
+        value: string;
+    };
+    tag?: string;
+    href?: {
+        op: "equals" | "prefix" | "contains";
+        value: string;
+    };
+    /** Only clicks on this tagged page / URL pattern. */
+    page?: {
+        pageId?: string;
+        pattern?: string;
+    };
+    /** `web`, `ios`, `android` (mobile autocapture sets `properties.platform`). */
+    platform?: string;
+    exclude?: boolean;
+}
+declare const FEATURE_RULE_LIMITS: {
+    readonly rules: 20;
+    readonly value: 1000;
+};
+interface ClickFacts {
+    selector?: string | null;
+    text?: string | null;
+    tag?: string | null;
+    href?: string | null;
+    platform?: string | null;
+}
+/** Does a click (facts + a CSS test) satisfy one rule's element conditions? Page scope is checked by the caller. */
+declare function featureRuleMatchesClick(rule: FeatureRule, click: ClickFacts, css: (selector: string) => boolean): boolean;
+/** Validation message for a feature rule, or null. */
+declare function featureRuleError(rule: FeatureRule): string | null;
+/** Selector to find a feature's elements on a page (dashboard overlays, SDK property capture), when the rules give one. */
+declare function featureCssSelectors(rules: FeatureRule[]): string[];
+interface TagPropertyDefinition {
+    id: string;
+    name: string;
+    /** Element to read: CSS selector (may use `>>>`); empty = the clicked element itself (features only). */
+    selector?: string;
+    source: "text" | "attribute";
+    /** Attribute name for `source: "attribute"`; `value` is never read. */
+    attribute?: string;
+}
+/** One tag's capture config in the SDK payload (`SdkConfigResponse.tagging.properties`). */
+interface TagPropertyConfig {
+    kind: "page" | "feature";
+    tagId: string;
+    /** Page rules (pages) or feature rules (features), evaluated in the browser. */
+    pageRules?: PageRule[];
+    featureRules?: FeatureRule[];
+    properties: TagPropertyDefinition[];
+}
+interface TaggingSdkConfig {
+    /** Attribute that names features automatically (null = off). */
+    featureAttribute: string | null;
+    properties: TagPropertyConfig[];
+}
+declare const TAG_PROPERTY_LIMITS: {
+    readonly perTag: 10;
+    readonly total: 50;
+    readonly value: 100;
+};
+/** Attribute names an event property may read. */
+declare function propertyAttributeAllowed(name: string): boolean;
+
+/** A published guide as delivered to the SDK. Draft-only data (author, notes) is never included. */
+interface PublishedGuide {
+    id: string;
+    key: string;
+    name: string;
+    kind: GuideKind;
+    version: number;
+    config: GuideConfig;
+    publishedAt: string;
+    /**
+     * Set while the guide is a variant of a running guide A/B test. Its targeting already carries the
+     * variant's `experiment.bucket` range; SDKs record an `experiment_viewed` exposure
+     * (`{ guideExperimentId, variantId, guideId }`) when it shows.
+     */
+    experiment?: {
+        id: string;
+        variantId: string;
+    };
+}
+/**
+ * The control group of a running guide A/B test: the base guide's targeting, trigger and frequency
+ * restricted to the control bucket. SDKs evaluate it like a guide but never render it; when it would
+ * show they record the `experiment_viewed` exposure (variant `control`) and its local impression.
+ * SDKs that don't know `guideHoldouts` ignore it (control visitors then simply see nothing).
+ */
+interface GuideHoldout {
+    experimentId: string;
+    variantId: string;
+    guide: PublishedGuide;
+}
+/** Project-wide limit on automatically shown guides (Project.settings.guideThrottling). */
+interface GuideThrottlingSettings {
+    enabled: boolean;
+    /** At most this many auto-launched guides per visitor within `windowHours`. */
+    maxGuides: number;
+    windowHours: number;
+    /** Minimum minutes between two auto-launched guides. */
+    minGapMinutes: number;
+}
+interface ResourceCenterArticle {
+    id: string;
+    slug: string;
+    title: string;
+    summary: string;
+    body: string;
+    /** True when `body` was left out of the config to keep it small; fetch it from `GET /sdk/articles/:id`. */
+    bodyOmitted?: boolean;
+    collectionId?: string | null;
+    externalUrl?: string | null;
+    /** Listed only for members of any of these audiences (absent = everyone). Not access control. */
+    audienceIds?: string[];
+    /** Guide keys of the article's "Show me" prompts (absent = none); the first one is offered in Help results. */
+    walkthroughs?: string[];
+    /** The article plays a video. */
+    hasVideo?: boolean;
+    updatedAt: string;
+    /** Translations by locale; a `bodyOmitted` translation is fetched with `GET /sdk/articles/:id?locale=`. */
+    translations?: Record<string, {
+        title?: string;
+        summary?: string;
+        body?: string;
+        bodyOmitted?: boolean;
+    }>;
+}
+/** A "What's new" entry in the resource center. */
+interface ResourceCenterAnnouncement {
+    id: string;
+    title: string;
+    /** Sanitized HTML. */
+    body: string;
+    publishedAt: string;
+    /** Guide id or key started by its "Show me" button. */
+    guideId?: string | null;
+    articleId?: string | null;
+    url?: string | null;
+    linkLabel?: string | null;
+    /** Listed only for members of any of these audiences (absent = everyone). */
+    audienceIds?: string[];
+    translations?: Record<string, {
+        title?: string;
+        body?: string;
+    }>;
+}
+/** A section of the resource center, in display order; hidden when disabled or its targeting doesn't match. */
+interface ResourceCenterModule {
+    id: ResourceCenterModuleId;
+    enabled: boolean;
+    /** Evaluated by the SDK like guide targeting (absent = everyone). */
+    targeting?: RuleGroup | null;
+}
+interface ResourceCenterCollection {
+    id: string;
+    name: string;
+    description: string;
+    order: number;
+    /** Parent collection for nested collections (absent/null = top level). */
+    parentId?: string | null;
+    /** Listed only for members of any of these audiences, with everything inside it (absent = everyone). */
+    audienceIds?: string[];
+}
+interface ResourceCenterConfig {
+    enabled: boolean;
+    title: string;
+    launcher: {
+        position: "bottom-right" | "bottom-left";
+        label: string;
+        showIcon: boolean;
+    };
+    collections: ResourceCenterCollection[];
+    articles: ResourceCenterArticle[];
+    recommendedGuideIds: string[];
+    checklistGuideIds: string[];
+    links: Array<{
+        id: string;
+        label: string;
+        url: string;
+    }>;
+    faqs: Array<{
+        id: string;
+        question: string;
+        answer: string;
+    }>;
+    /** "What's new" (newest first). Absent from servers that predate it. */
+    announcements?: ResourceCenterAnnouncement[];
+    /** Section order and targeting; absent = every section in the default order. */
+    modules?: ResourceCenterModule[];
+    /** Translations of the strings above (see `resourceCenterTextEntries`), by locale. */
+    translations?: Record<string, Record<string, string>>;
+}
+interface SdkConfigResponse {
+    projectId: string;
+    environment: string;
+    configVersion: number;
+    theme: z.infer<typeof ProjectThemeSchema>;
+    guides: PublishedGuide[];
+    /** Control groups of running guide A/B tests (see GuideHoldout); absent from older servers. */
+    guideHoldouts?: GuideHoldout[];
+    resourceCenter: ResourceCenterConfig | null;
+    /** Scout messenger; absent from servers that predate it. */
+    messenger?: MessengerConfig | null;
+    settings: {
+        analyticsEnabled: boolean;
+        collectUrls: boolean;
+        maskSelectors: string[];
+        sessionTimeoutMinutes: number;
+        /** Product analytics; absent from servers that predate it (the SDK then captures nothing extra). */
+        autocapture?: AutocaptureSettings;
+        errorTracking?: ErrorTrackingSettings;
+        /** `retentionDays` is server-side only and not sent. */
+        replay?: Omit<ReplaySettings, "retentionDays">;
+        /** Project-wide guide throttling; absent or disabled = no limit. */
+        throttling?: GuideThrottlingSettings;
+        /** The language guides are written in, and the languages they may be translated into. */
+        localization?: {
+            defaultLocale: string;
+            locales: string[];
+        };
+    };
+    /** Tagged pages and features: the feature attribute and DOM event properties; absent from servers that predate them. */
+    tagging?: TaggingSdkConfig;
+    generatedAt: string;
+}
+declare const IdentifyRequestSchema: z.ZodObject<{
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    account: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        traits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type IdentifyRequest = z.infer<typeof IdentifyRequestSchema>;
+/** Server-held state the SDK needs for targeting & frequency. */
+interface IdentifyResponse {
+    endUserId: string;
+    audienceIds: string[];
+    guideState: Record<string, {
+        impressions: number;
+        completedAt?: string | null;
+        dismissedAt?: string | null;
+        lastShownAt?: string | null;
+    }>;
+    /** `dismissResetAt` changes when a teammate resets the user's dismissal; SDKs then drop their cached `dismissedAt`. */
+    checklistProgress: Record<string, {
+        completedTaskIds: string[];
+        completedAt?: string | null;
+        dismissedAt?: string | null;
+        dismissResetAt?: string | null;
+    }>;
+    surveysSubmitted: string[];
+    firstSeenAt: string;
+}
+declare const ChecklistProgressRequestSchema: z.ZodObject<{
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    guideVersion: z.ZodOptional<z.ZodNumber>;
+    completedTaskIds: z.ZodArray<z.ZodString>;
+    dismissed: z.ZodOptional<z.ZodBoolean>;
+    completed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ChecklistProgressRequest = z.infer<typeof ChecklistProgressRequestSchema>;
+declare const SurveyResponseRequestSchema: z.ZodObject<{
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    accountId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    guideVersion: z.ZodNumber;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    responseId: z.ZodString;
+}, z.core.$strip>;
+type SurveyResponseRequest = z.infer<typeof SurveyResponseRequestSchema>;
+declare const GuideStateUpdateSchema: z.ZodObject<{
+    anonymousId: z.ZodString;
+    userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    updates: z.ZodArray<z.ZodObject<{
+        guideId: z.ZodString;
+        impression: z.ZodOptional<z.ZodBoolean>;
+        completed: z.ZodOptional<z.ZodBoolean>;
+        dismissed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const AuthoringPickSchema: z.ZodObject<{
+    stepId: z.ZodOptional<z.ZodString>;
+    selectors: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        value: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    textSnapshot: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    rect: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    elementSnapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type AuthoringPick = z.infer<typeof AuthoringPickSchema>;
+/**
+ * Static, script-free copy of the page an authoring session is connected to. The SDK posts it to
+ * the dashboard (never to the API) so the editor canvas can show the customer's real app.
+ */
+interface AppSnapshot {
+    /** Full HTML document (doctype included) with scripts and Guidely UI removed and a `<base>` pointing at `url`. */
+    html: string;
+    url: string;
+    title: string;
+    /** Viewport the snapshot was taken at, in CSS pixels. */
+    width: number;
+    height: number;
+    capturedAt: string;
+}
+interface AuthoringSessionInfo {
+    id: string;
+    projectId: string;
+    environment: string;
+    guideId: string | null;
+    dashboardOrigin: string;
+    expiresAt: string;
+    /** `tag`: the session tags pages and features (no guide); absent or `guide` for the guide editor. */
+    purpose?: "guide" | "tag";
+    /** Draft guide config to preview while authoring (not published). */
+    draft: {
+        id: string;
+        key: string;
+        name: string;
+        kind: GuideKind;
+        config: GuideConfig;
+    } | null;
+}
+declare const PublishedGuideSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodString;
+    version: z.ZodNumber;
+    config: z.ZodObject<{
+        steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                custom: "custom";
+                modal: "modal";
+                tooltip: "tooltip";
+                banner: "banner";
+                checklist: "checklist";
+                survey: "survey";
+                popover: "popover";
+                spotlight: "spotlight";
+                hotspot: "hotspot";
+                slideout: "slideout";
+            }>;
+            title: z.ZodDefault<z.ZodString>;
+            body: z.ZodDefault<z.ZodString>;
+            imageUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+            imageAlt: z.ZodOptional<z.ZodString>;
+            videoUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+            buttons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                action: z.ZodEnum<{
+                    skip: "skip";
+                    next: "next";
+                    back: "back";
+                    dismiss: "dismiss";
+                    complete: "complete";
+                    url: "url";
+                    start_guide: "start_guide";
+                    event: "event";
+                    open_resource_center: "open_resource_center";
+                    none: "none";
+                }>;
+                variant: z.ZodDefault<z.ZodEnum<{
+                    link: "link";
+                    primary: "primary";
+                    secondary: "secondary";
+                    ghost: "ghost";
+                }>>;
+                value: z.ZodOptional<z.ZodString>;
+                newTab: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            target: z.ZodOptional<z.ZodObject<{
+                selectors: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        id: "id";
+                        text: "text";
+                        css: "css";
+                        "data-attr": "data-attr";
+                        aria: "aria";
+                        xpath: "xpath";
+                        "guidely-id": "guidely-id";
+                    }>;
+                    value: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                waitMs: z.ZodDefault<z.ZodNumber>;
+                fallback: z.ZodDefault<z.ZodEnum<{
+                    skip: "skip";
+                    show_as_modal: "show_as_modal";
+                    end_guide: "end_guide";
+                    wait: "wait";
+                }>>;
+                scrollIntoView: z.ZodDefault<z.ZodBoolean>;
+                textSnapshot: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            placement: z.ZodDefault<z.ZodEnum<{
+                top: "top";
+                "top-start": "top-start";
+                "top-end": "top-end";
+                right: "right";
+                "right-start": "right-start";
+                "right-end": "right-end";
+                bottom: "bottom";
+                "bottom-start": "bottom-start";
+                "bottom-end": "bottom-end";
+                left: "left";
+                "left-start": "left-start";
+                "left-end": "left-end";
+                auto: "auto";
+            }>>;
+            offset: z.ZodDefault<z.ZodNumber>;
+            showOverlay: z.ZodDefault<z.ZodBoolean>;
+            showProgress: z.ZodDefault<z.ZodBoolean>;
+            showClose: z.ZodDefault<z.ZodBoolean>;
+            dismissOnOutsideClick: z.ZodDefault<z.ZodBoolean>;
+            spotlightPadding: z.ZodDefault<z.ZodNumber>;
+            position: z.ZodDefault<z.ZodEnum<{
+                top: "top";
+                bottom: "bottom";
+                "top-left": "top-left";
+                "top-right": "top-right";
+                "bottom-left": "bottom-left";
+                "bottom-right": "bottom-right";
+                center: "center";
+            }>>;
+            url: z.ZodOptional<z.ZodString>;
+            advanceOn: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                button: "button";
+                event: "event";
+                element_click: "element_click";
+                element_visible: "element_visible";
+                delay: "delay";
+            }>>;
+            advanceValue: z.ZodOptional<z.ZodString>;
+            advanceDelayMs: z.ZodOptional<z.ZodNumber>;
+            branches: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                when: z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>;
+                goTo: z.ZodString;
+            }, z.core.$strip>>>;
+            width: z.ZodOptional<z.ZodNumber>;
+            targeting: z.ZodOptional<z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>>;
+            hotspot: z.ZodOptional<z.ZodObject<{
+                size: z.ZodDefault<z.ZodNumber>;
+                pulse: z.ZodDefault<z.ZodBoolean>;
+                openOn: z.ZodDefault<z.ZodEnum<{
+                    click: "click";
+                    hover: "hover";
+                }>>;
+            }, z.core.$strip>>;
+            customHtml: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        visibility: z.ZodDefault<z.ZodEnum<{
+            everyone: "everyone";
+            identified: "identified";
+            anonymous: "anonymous";
+        }>>;
+        targeting: z.ZodDefault<z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>>;
+        trigger: z.ZodPrefault<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<{
+                event: "event";
+                element_click: "element_click";
+                element_visible: "element_visible";
+                delay: "delay";
+                page_load: "page_load";
+                url_match: "url_match";
+                manual: "manual";
+                after_guide: "after_guide";
+                segment_enter: "segment_enter";
+            }>>;
+            value: z.ZodOptional<z.ZodString>;
+            delayMs: z.ZodDefault<z.ZodNumber>;
+            urlPattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        frequency: z.ZodPrefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                once: "once";
+                once_per_session: "once_per_session";
+                every_time: "every_time";
+                interval: "interval";
+            }>>;
+            intervalHours: z.ZodOptional<z.ZodNumber>;
+            maxImpressions: z.ZodOptional<z.ZodNumber>;
+            cooldownHours: z.ZodDefault<z.ZodNumber>;
+            priority: z.ZodDefault<z.ZodNumber>;
+            mutuallyExclusiveWith: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            reshowAfterDismiss: z.ZodDefault<z.ZodBoolean>;
+            ignoreThrottling: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        appearance: z.ZodPrefault<z.ZodObject<{
+            theme: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                light: "light";
+                dark: "dark";
+            }>>;
+            primaryColor: z.ZodOptional<z.ZodString>;
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            textColor: z.ZodOptional<z.ZodString>;
+            borderRadius: z.ZodOptional<z.ZodNumber>;
+            fontFamily: z.ZodOptional<z.ZodString>;
+            overlayOpacity: z.ZodOptional<z.ZodNumber>;
+            zIndex: z.ZodOptional<z.ZodNumber>;
+            preset: z.ZodOptional<z.ZodString>;
+            animation: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                fade: "fade";
+                slide: "slide";
+            }>>;
+            customCss: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        checklist: z.ZodOptional<z.ZodObject<{
+            tasks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodDefault<z.ZodString>;
+                completion: z.ZodDefault<z.ZodEnum<{
+                    event: "event";
+                    click: "click";
+                    manual: "manual";
+                    guide_completed: "guide_completed";
+                    url_visited: "url_visited";
+                }>>;
+                completionValue: z.ZodOptional<z.ZodString>;
+                action: z.ZodDefault<z.ZodEnum<{
+                    url: "url";
+                    start_guide: "start_guide";
+                    event: "event";
+                    none: "none";
+                }>>;
+                actionValue: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            ordered: z.ZodDefault<z.ZodBoolean>;
+            launcherLabel: z.ZodDefault<z.ZodString>;
+            position: z.ZodDefault<z.ZodEnum<{
+                "bottom-left": "bottom-left";
+                "bottom-right": "bottom-right";
+            }>>;
+            completionTitle: z.ZodDefault<z.ZodString>;
+            completionBody: z.ZodDefault<z.ZodString>;
+            autoOpen: z.ZodDefault<z.ZodBoolean>;
+            dismissible: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        survey: z.ZodOptional<z.ZodObject<{
+            questions: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodEnum<{
+                    text: "text";
+                    nps: "nps";
+                    csat: "csat";
+                    thumbs: "thumbs";
+                    single_choice: "single_choice";
+                    multiple_choice: "multiple_choice";
+                    rating: "rating";
+                }>;
+                title: z.ZodString;
+                description: z.ZodDefault<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>>;
+                scaleMax: z.ZodOptional<z.ZodNumber>;
+                lowLabel: z.ZodOptional<z.ZodString>;
+                highLabel: z.ZodOptional<z.ZodString>;
+                placeholder: z.ZodOptional<z.ZodString>;
+                showWhen: z.ZodOptional<z.ZodObject<{
+                    questionId: z.ZodString;
+                    op: z.ZodEnum<{
+                        equals: "equals";
+                        lte: "lte";
+                        gte: "gte";
+                        in: "in";
+                    }>;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>]>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            thankYouTitle: z.ZodDefault<z.ZodString>;
+            thankYouBody: z.ZodDefault<z.ZodString>;
+            position: z.ZodDefault<z.ZodEnum<{
+                "bottom-left": "bottom-left";
+                "bottom-right": "bottom-right";
+                center: "center";
+            }>>;
+            startAt: z.ZodOptional<z.ZodString>;
+            endAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        urlPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        platforms: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            web: "web";
+            ios: "ios";
+            android: "android";
+        }>>>;
+        schedule: z.ZodOptional<z.ZodObject<{
+            startAt: z.ZodOptional<z.ZodString>;
+            endAt: z.ZodOptional<z.ZodString>;
+            timezone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        localization: z.ZodOptional<z.ZodObject<{
+            translations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    publishedAt: z.ZodString;
+}, z.core.$strip>;
+interface ApiError {
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+
+/**
+ * Agent Analytics: the `agent.conversation` turn the customer's own AI agents send (zod-free, so the
+ * browser SDK can use the types and limits without bundling the schema). The schema is in agents.ts.
+ */
+declare const AGENT_TURN_ROLES: readonly ["user", "assistant", "tool", "system"];
+type AgentTurnRole = (typeof AGENT_TURN_ROLES)[number];
+/** How a conversation ended, as the agent reports it. */
+declare const AGENT_OUTCOMES: readonly ["success", "failure", "escalated", "abandoned"];
+type AgentOutcome = (typeof AGENT_OUTCOMES)[number];
+declare const AGENT_TOOL_STATUSES: readonly ["ok", "error"];
+type AgentToolStatus = (typeof AGENT_TOOL_STATUSES)[number];
+/** Longest turn text accepted (characters). */
+declare const AGENT_TURN_MAX_TEXT = 20000;
+/** Most turns in one request. */
+declare const AGENT_TURNS_PER_BATCH = 100;
+/** Most tool calls on one turn. */
+declare const AGENT_TOOL_CALLS_PER_TURN = 50;
+/** Metadata: at most this many keys, string values up to 500 characters, 4 KB in all. */
+declare const AGENT_METADATA_MAX_KEYS = 30;
+declare const AGENT_METADATA_MAX_BYTES = 4096;
+/** The built-in Scout agent's id; customer agents can't use it. */
+declare const SCOUT_AGENT_ID = "scout";
+/** One tool the agent called in a turn. Arguments and results are never sent or stored. */
+interface AgentToolCallInput {
+    name: string;
+    status?: AgentToolStatus;
+    latencyMs?: number;
+}
+/** One `agent.conversation` turn. */
+interface AgentTurnInput {
+    type?: "agent.conversation";
+    /** Your conversation (thread) id. */
+    conversationId: string;
+    /** Your agent's id, e.g. "support-bot". The agent is created on its first turn. */
+    agentId: string;
+    /** Display name for a new agent (defaults to agentId). */
+    agentName?: string;
+    /** Idempotency key: a turn sent twice with the same id is stored once. */
+    turnId?: string;
+    role: AgentTurnRole;
+    text?: string;
+    toolCalls?: AgentToolCallInput[];
+    /** How long the agent took to produce this turn (assistant turns). */
+    latencyMs?: number;
+    /** How the conversation ended, when this turn ends it (the latest reported outcome wins). */
+    outcome?: AgentOutcome;
+    /** Whether the person got what they came for, when the agent knows. */
+    taskSuccess?: boolean;
+    /** ISO 8601 time of the turn (default: when Guidely receives it). */
+    occurredAt?: string;
+    userId?: string | null;
+    anonymousId?: string | null;
+    accountId?: string | null;
+    sessionId?: string | null;
+    /** Flat key/value pairs (strings, numbers, booleans), e.g. { model: "gpt-4.1" }. */
+    metadata?: Record<string, string | number | boolean | null>;
+}
+/** Response of both ingestion endpoints. */
+interface AgentEventsResponse {
+    accepted: number;
+    duplicates: number;
+    /** Turns refused (an agent past the per-project limit, or a conversation past its turn limit). */
+    rejected?: number;
+    /** Turns dropped because this month's product analytics allowance is used up. */
+    overLimit?: number;
+}
+
+/** rrweb plugin name for network events in recordings (event type 6, `data.plugin`). */
+declare const NETWORK_PLUGIN = "guidely/network@1";
+/** Request kinds, from `fetch`/`XMLHttpRequest` patching or `PerformanceResourceTiming.initiatorType`. */
+type NetworkRequestType = "fetch" | "xhr" | "websocket" | "document" | "script" | "stylesheet" | "image" | "font" | "media" | "beacon" | "other";
+/**
+ * One network request in a recording: the payload of an rrweb plugin event
+ * `{ type: 6, data: { plugin: NETWORK_PLUGIN, payload: NetworkPluginPayload } }`, batched.
+ * Times are epoch milliseconds (same clock as rrweb event timestamps).
+ *
+ * A WebSocket is a request with `type: "websocket"` and `method: "GET"`, emitted when it opens
+ * (`startTime`) and again, with the same `id`, when it closes (`endTime`, `closeCode`, `closeReason`,
+ * totals in `messages`). Its frames are `WebSocketMessage`s referencing that `id`.
+ */
+interface NetworkRequest {
+    /** Stable id within the recording. */
+    id: string;
+    type: NetworkRequestType;
+    method: string;
+    /** Absolute URL; values of sensitive-looking query parameters replaced with `[redacted]`. */
+    url: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    /** HTTP status; 0 for network errors / blocked / aborted. Absent when the browser doesn't expose it. */
+    status?: number;
+    /** Set for failed requests: network error, abort or timeout message. */
+    error?: string;
+    /** Encoded bytes transferred / decoded response size, when known. */
+    transferSize?: number;
+    responseSize?: number;
+    /** Only when `recordNetworkPayloads` is on; sensitive headers are `[redacted]`. */
+    requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    /** Text/JSON bodies, ≤10KB, sensitive JSON fields masked; `[binary]` / `[truncated]` markers otherwise. */
+    requestBody?: string;
+    responseBody?: string;
+    /** WebSocket only: negotiated subprotocol, close details, and frame totals (all frames, including ones not recorded). */
+    protocol?: string;
+    closeCode?: number;
+    closeReason?: string;
+    messages?: {
+        sent: number;
+        received: number;
+        sentBytes: number;
+        receivedBytes: number;
+        recorded: number;
+    };
+}
+/** One WebSocket frame. At most `WS_MAX_MESSAGES_PER_SOCKET` are recorded per connection per page load. */
+interface WebSocketMessage {
+    /** The `NetworkRequest.id` of the connection. */
+    socketId: string;
+    dir: "send" | "recv";
+    time: number;
+    /** Bytes (UTF-8 length for text frames). */
+    size: number;
+    binary?: boolean;
+    /** Only with `recordNetworkPayloads`: text ≤ 2KB (JSON with sensitive keys masked), else `[truncated]`; binary frames are `[binary <n> B]`. */
+    data?: string;
+}
+interface NetworkPluginPayload {
+    requests?: NetworkRequest[];
+    messages?: WebSocketMessage[];
+    /** Requests/frames dropped since the previous payload because a cap was reached. */
+    dropped?: {
+        requests?: number;
+        messages?: number;
+    };
+}
+declare const WS_MAX_MESSAGES_PER_SOCKET = 200;
+declare const WS_MAX_MESSAGE_BYTES = 2048;
+/** Header names always replaced with `[redacted]` when payload capture is on. */
+declare const SENSITIVE_HEADER_PATTERN: RegExp;
+/** Query parameter and JSON field names whose values are redacted. */
+declare const SENSITIVE_PARAM_PATTERN: RegExp;
+
+/**
+ * Media in article bodies: uploaded images, videos and PDFs, and video embeds from a fixed set of hosts.
+ * Sanitizers (server, browser runtime) only keep an `<iframe>` whose `src` is the canonical embed URL
+ * that `toEmbedUrl` produces, so authors can never point a frame anywhere else.
+ *
+ * An uploaded PDF reads inline, as its pages: the dashboard renders each page to an image when the
+ * PDF is uploaded, and the body holds plain HTML every renderer already understands:
+ *
+ *   <div class="gd-pdf">
+ *     <a class="gd-file" href="…/{id}.pdf" target="_blank">{file name}</a>
+ *     <div class="gd-pdf-pages"><img src="…/{page}.webp" alt="{file name}, page 1 of 12"> …</div>
+ *   </div>
+ *
+ * Renderers that know the classes draw a swipeable page viewer with the PDF one tap away; older ones
+ * show a link and the pages as images. A PDF whose pages couldn't be rendered (password-protected,
+ * damaged) is just the `gd-file` link, drawn as a file card.
+ */
+type EmbedProvider = "youtube" | "vimeo" | "loom" | "wistia";
+interface VideoEmbed {
+    provider: EmbedProvider;
+    /** Canonical player URL, safe to use as an iframe `src`. */
+    src: string;
+    /** Page a viewer can open instead (native SDKs show a link rather than a player). */
+    watchUrl: string;
+    /** Accessible iframe title. */
+    title: string;
+}
+declare const MEDIA_IMAGE_TYPES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
+declare const MEDIA_VIDEO_TYPES: readonly ["video/mp4", "video/webm"];
+declare const MEDIA_FILE_TYPES: readonly ["application/pdf"];
+type MediaContentType = (typeof MEDIA_IMAGE_TYPES)[number] | (typeof MEDIA_VIDEO_TYPES)[number] | (typeof MEDIA_FILE_TYPES)[number];
+type MediaKind = "image" | "video" | "file";
+declare const MEDIA_IMAGE_MAX_BYTES: number;
+declare const MEDIA_VIDEO_MAX_BYTES: number;
+declare const MEDIA_FILE_MAX_BYTES: number;
+/** The largest upload of any type. */
+declare const MEDIA_MAX_BYTES: number;
+declare function isMediaContentType(type: string): type is MediaContentType;
+declare function isVideoContentType(type: string): boolean;
+declare function mediaKind(type: string): MediaKind | null;
+declare function mediaMaxBytes(type: string): number;
+/** Class marking a link as an attached file (an uploaded PDF), drawn as a file card. */
+declare const FILE_LINK_CLASS = "gd-file";
+/** Class of the block holding a PDF's link and its rendered pages. */
+declare const PDF_BLOCK_CLASS = "gd-pdf";
+/** Class of the element wrapping a PDF's page images. */
+declare const PDF_PAGES_CLASS = "gd-pdf-pages";
+/** Pages rendered inline per PDF; readers open the PDF itself for the rest. */
+declare const PDF_MAX_PAGES = 40;
+/** True for an `<a>` with the file class and an absolute http(s) `href`: render it as a file card. */
+declare function isFileLink(className: string | null | undefined, href: string | null | undefined): boolean;
+/**
+ * Turns a pasted video page or player URL from YouTube, Vimeo, Loom or Wistia into its canonical
+ * embed. Returns null for anything else, including lookalike hosts.
+ */
+declare function toEmbedUrl(input: string): VideoEmbed | null;
+/** True only for a canonical embed URL (exactly what `toEmbedUrl` returns), so an iframe can't be pointed elsewhere. */
+declare function isAllowedEmbedSrc(src: string | null | undefined): boolean;
+/** Fixed iframe attributes for an embed; sanitizers overwrite whatever the author's HTML carried. */
+declare const EMBED_IFRAME_ATTRS: Readonly<Record<string, string>>;
+/** Fixed `<video>` attributes: player controls, no autoplay or loop. */
+declare const VIDEO_ATTRS: Readonly<Record<string, string>>;
+/** `<video src>` / `poster` must be plain http(s): no data:, blob: or relative URLs (bodies render on customer sites). */
+declare function isSafeMediaUrl(url: string | null | undefined): boolean;
+/**
+ * Still image for a guide step's video (`videoUrl`): YouTube serves one per video; other hosts don't
+ * without an API call, so those steps use their own image (`imageUrl`) as the poster, or a plain tile.
+ */
+declare function videoThumbnailUrl(url: string | null | undefined): string | null;
+/** A video file a `<video>` can load directly (shows its first frame when there's no poster). */
+declare function isVideoFileUrl(url: string | null | undefined): boolean;
+/**
+ * The video shown on a guide step: a poster with a play button that opens `url` in a new tab.
+ * `poster` is the step's image, else the provider's thumbnail; null means draw a plain tile.
+ */
+declare function stepVideo(step: {
+    videoUrl?: string | null;
+    imageUrl?: string | null;
+}): {
+    url: string;
+    poster: string | null;
+} | null;
+
+/**
+ * Page helpers shared by the SDK (page-aware messenger) and the server (page matching, analytics).
+ * Pure and zod-free.
+ */
+/**
+ * One path segment that looks like an identifier: digits, a UUID, or a long hex string (hashes,
+ * Mongo ids). Written so the same source works as a JS RegExp and a Postgres ARE (`regexp_replace`
+ * with flags `gi`), which keeps id folding identical in SQL and in code. A segment may be followed
+ * by the page query parameters a project keeps in its paths (`/contacts/42?tab=notes`).
+ */
+declare const PATH_ID_PATTERN = "/([0-9]+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{12,})(?=[/?]|$)";
+/** `/contacts/42/notes/9f8e…` → `/contacts/:id/notes/:id`; `/contacts/42?tab=notes` → `/contacts/:id?tab=notes`. */
+declare function foldPathIds(path: string): string;
+/** Words describing a page, from its path (`/settings/billing-plans/42` → `settings billing plans`). */
+declare function pageTerms(path: string): string[];
+/** A short human name for a page (`/app/invoices/42` → `Invoices`), or null for the root and unnamed pages. */
+declare function pageLabel(path: string): string | null;
+/** The first name in a user's traits (`firstName`, `first_name`, or the first word of `name`), or null. */
+declare function firstNameFromTraits(traits: Record<string, unknown> | null | undefined): string | null;
+
+/**
+ * Guide and resource-center localization (zod-free, so the browser SDK can import it).
+ *
+ * Every translatable text field has a stable key derived from ids, never from positions, so
+ * reordering steps keeps translations attached: `steps.<stepId>.title`,
+ * `steps.<stepId>.buttons.<buttonId>.label`, `checklist.tasks.<taskId>.title`,
+ * `survey.questions.<questionId>.options.<optionId>.label`, …
+ *
+ * A visitor's language comes from (in order) an explicit SDK locale, the `language` / `locale`
+ * trait, then the browser / device language. `resolveLocale` matches it against the languages a
+ * guide is translated into (exact tag first, then the base language) and falls back to the
+ * project's default language, in which the guide is written.
+ */
+
+type TextKind = "text" | "html";
+interface TextEntry {
+    key: string;
+    /** Default-language text. */
+    source: string;
+    kind: TextKind;
+    /** Human-readable location for translators ("Step 2 · Title"). */
+    label: string;
+}
+/** Project-level language settings (Project.settings.localization). */
+interface LocalizationSettings {
+    /** Language the content is written in. */
+    defaultLocale: string;
+    /** Additional languages offered for translation. */
+    locales: string[];
+    /** Machine-translate new and changed text into every language automatically. */
+    autoTranslate?: boolean;
+    /** Machine translations need a teammate's approval before visitors see them. */
+    requireReview?: boolean;
+}
+/**
+ * Review state of one translated text. `machine` texts were written by AI translation; `human`
+ * ones were typed or imported by a teammate (approved by doing so). `outdated` means the source
+ * text changed after the translation was written or approved.
+ */
+interface TranslationReviewState {
+    origin: "machine" | "human";
+    approved: boolean;
+    outdated: boolean;
+    reviewedBy?: string | null;
+    reviewedAt?: string | null;
+}
+/** locale → key → review state. Texts without a state are human translations from before review existed. */
+type TranslationReviewMap = Record<string, Record<string, TranslationReviewState>>;
+/** Does this translation still need a teammate to look at it? */
+declare function needsReview(state: TranslationReviewState | undefined): boolean;
+declare const DEFAULT_LOCALE = "en";
+/** Common languages offered in the dashboard's language picker (any BCP 47 tag is accepted). */
+declare const COMMON_LOCALES: Array<{
+    code: string;
+    name: string;
+}>;
+declare function localeName(code: string): string;
+/** `fr_FR` / `FR-fr` → `fr-FR`; script subtags keep title case (`zh-hans` → `zh-Hans`). Invalid input → "". */
+declare function normalizeLocale(input: unknown): string;
+declare function baseLanguage(locale: string): string;
+/**
+ * Picks the language to show: for each requested locale in order, an exact match among
+ * `available`, else one sharing its base language (`fr-CA` → `fr`, `fr` → `fr-FR`). Falls back to
+ * `defaultLocale`. Matching ignores case.
+ */
+declare function resolveLocale(requested: ReadonlyArray<string | null | undefined>, available: readonly string[], defaultLocale?: string): string;
+/** Locale candidates for a visitor: explicit option, traits (`language`, `locale`), then the platform's languages. */
+declare function visitorLocales(explicit: string | null | undefined, traits: Record<string, unknown> | null | undefined, platform?: ReadonlyArray<string | null | undefined>): string[];
+/** Every translatable text in a guide config, in display order. Empty texts are skipped. */
+declare function guideTextEntries(config: Pick<GuideConfig, "steps" | "checklist" | "survey">): TextEntry[];
+/** Locales a guide has any translation for. */
+declare function guideLocales(config: Pick<GuideConfig, "localization">): string[];
+/** The config with one language's translations applied (untranslated texts keep the default language). */
+declare function applyGuideTranslations<C extends Pick<GuideConfig, "steps" | "checklist" | "survey">>(config: C, map: Record<string, string> | undefined): C;
+/**
+ * The guide as a visitor speaking `requested` should see it, with `locale` set to the language
+ * chosen (the default language when none of the guide's translations match).
+ */
+declare function localizeGuide(guide: PublishedGuide, requested: readonly string[], defaultLocale?: string): PublishedGuide & {
+    locale: string;
+};
+interface TranslationCoverage {
+    locale: string;
+    total: number;
+    translated: number;
+    /** Keys with no translation. */
+    missing: string[];
+    /** Keys whose translation exists but whose key no longer matches any text (stale). */
+    stale: string[];
+}
+declare function translationCoverage(entries: readonly TextEntry[], map: Record<string, string> | undefined, locale: string): TranslationCoverage;
+/** Translations carried by the published resource center (texts other than articles and announcements). */
+type ResourceCenterTranslations = Record<string, Record<string, string>>;
+/** Translatable resource-center texts (title, launcher label, links, FAQs, collections). */
+declare function resourceCenterTextEntries(rc: Pick<ResourceCenterConfig, "title" | "launcher" | "links" | "faqs" | "collections">): TextEntry[];
+/** Article texts, keyed `title` / `summary` / `body`. */
+declare function articleTextEntries(a: {
+    title: string;
+    summary?: string | null;
+    body?: string | null;
+}): TextEntry[];
+/** Locales the resource center offers (its own strings, articles or announcements). */
+declare function resourceCenterLocales(rc: ResourceCenterConfig): string[];
+declare function localizeArticle(a: ResourceCenterArticle, locale: string): ResourceCenterArticle;
+declare function localizeAnnouncement(a: ResourceCenterAnnouncement, locale: string): ResourceCenterAnnouncement;
+/** The resource center in the visitor's language (with `locale` = the language chosen). */
+declare function localizeResourceCenter(rc: ResourceCenterConfig, requested: readonly string[], defaultLocale?: string): ResourceCenterConfig & {
+    locale: string;
+};
+
+/** The "no guide" variant: visitors in it see nothing, and are measured against the guide variants. */
+declare const CONTROL_VARIANT_ID = "control";
+declare const GUIDE_EXPERIMENT_STATUSES: readonly ["draft", "running", "completed"];
+type GuideExperimentStatus = (typeof GUIDE_EXPERIMENT_STATUSES)[number];
+declare const GUIDE_EXPERIMENT_GOALS: readonly ["guide_completed", "event", "page_visit", "click_text"];
+type GuideExperimentGoalKind = (typeof GUIDE_EXPERIMENT_GOALS)[number];
+declare const GUIDE_EXPERIMENT_GOAL_LABELS: Record<GuideExperimentGoalKind, string>;
+interface GuideExperimentGoal {
+    kind: GuideExperimentGoalKind;
+    /** Event name, page path pattern (`/billing/*`) or click text, depending on `kind`. */
+    value?: string;
+}
+interface GuideExperimentVariant {
+    id: string;
+    name: string;
+    /** The guide shown to this variant; null for the control group (no guide). */
+    guideId: string | null;
+    /** Share of visitors, a whole percentage; all weights sum to 100. */
+    weight: number;
+}
+declare function experimentSalt(experimentId: string): string;
+/** Bucket ranges `[from, to)` per variant, in order. */
+declare function variantRanges(variants: ReadonlyArray<Pick<GuideExperimentVariant, "id" | "weight">>): Array<{
+    id: string;
+    from: number;
+    to: number;
+}>;
+/** The variant a visitor is in, or null when weights leave their bucket unassigned. */
+declare function assignGuideVariant(variants: ReadonlyArray<Pick<GuideExperimentVariant, "id" | "weight">>, experimentId: string, subject: string): string | null;
+/** Rules restricting targeting to bucket range `[from, to)` of `salt`. */
+declare function experimentBucketRules(salt: string, from: number, to: number): Rule[];
+/** Targeting with a variant's bucket range folded in (an SDK without `experiment.bucket` shows the guide to nobody). */
+declare function withExperimentBucket(targeting: RuleGroup, salt: string, from: number, to: number): RuleGroup;
+/** Problems with a variant list; empty when it can run. */
+declare function variantProblems(variants: ReadonlyArray<GuideExperimentVariant>): string[];
+/** Splits 100% as evenly as possible across `n` variants (first ones get the remainder). */
+declare function evenWeights(n: number): number[];
+
+/**
+ * Custom CSS for guides and themes (zod-free; the server sanitizes on save, the web runtime
+ * sanitizes again and scopes before injecting).
+ *
+ * Guides render inside the SDK's Shadow DOM, so page styles and guide styles never mix. Within the
+ * shadow root, every rule is additionally prefixed with the guide's own container selector, so one
+ * guide's CSS can't restyle another guide, the resource center or the messenger. Sanitizing removes
+ * what could reach outside the container or load anything: `@import`, `:host` / `::slotted` rules,
+ * `url()`s other than https images and `data:image/…`, legacy script hooks (`expression()`,
+ * `behavior`, `-moz-binding`, `javascript:`) and any markup.
+ */
+declare const MAX_CUSTOM_CSS = 20000;
+/** Removes everything unsafe; keeps the rule structure. */
+declare function sanitizeCustomCss(input: string | null | undefined): string;
+/**
+ * Prefixes every selector with `scope` (e.g. `.g-scope[data-guide="abc"]`). `:root`, `html`,
+ * `body`, `:scope` and `&` at the start of a selector refer to the container itself.
+ */
+declare function scopeCustomCss(css: string, scope: string): string;
+
+/**
+ * WCAG 2.1 colour contrast (zod-free). The editor warns when a guide's colours fall below AA:
+ * 4.5:1 for body text, 3:1 for large text and UI components (button outlines, the close icon).
+ */
+declare const WCAG_AA_TEXT = 4.5;
+declare const WCAG_AA_LARGE = 3;
+/** `#rgb` / `#rrggbb` → [r, g, b]; null when not a hex colour. */
+declare function parseHexColor(hex: string | null | undefined): [number, number, number] | null;
+declare function relativeLuminance(hex: string): number | null;
+/** Contrast ratio 1–21 between two hex colours, or null when either is not a hex colour. */
+declare function contrastRatio(a: string, b: string): number | null;
+/** Text colour (black or white) with the better contrast on `background`. */
+declare function readableTextOn(background: string): "#ffffff" | "#111827";
+interface ContrastIssue {
+    /** What is hard to read. */
+    pair: "text" | "button" | "link";
+    ratio: number;
+    required: number;
+    message: string;
+}
+/**
+ * Contrast problems of a guide's effective colours (guide appearance over the project theme).
+ * Buttons use white or dark text, whichever reads better, so only a mid-tone primary colour fails.
+ */
+declare function contrastIssues(colors: {
+    primaryColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+}): ContrastIssue[];
+
+export { type ChecklistProgressRequest as $, ADVANCE_ON as A, type AttrTest as B, type AuthoringPick as C, AuthoringPickSchema as D, type AuthoringSessionInfo as E, type AutocaptureSettings as F, type GuideKind as G, AutocaptureSettingsSchema as H, BUTTON_ACTIONS as I, ButtonSchema as J, CAPTURE_PARAM as K, CAPTURE_SCREENSHOT_MAX_BYTES as L, COMMON_LOCALES as M, COMPLAINT_EVENTS as N, COMPLAINT_FIELD_TYPES as O, COMPLAINT_STATUSES as P, CONTROL_VARIANT_ID as Q, type RuleGroup as R, type CaptureSessionInfo as S, type CaptureSettings as T, type CaptureStep as U, type CaptureStepInput as V, CaptureStepSchema as W, type CapturedElement as X, CapturedElementSchema as Y, type ChecklistConfig as Z, ChecklistConfigSchema as _, type Rule as a, GuideStateUpdateSchema as a$, ChecklistProgressRequestSchema as a0, type ChecklistTask as a1, ChecklistTaskSchema as a2, type ClickFacts as a3, type ComplaintEvent as a4, type ComplaintField as a5, type ComplaintFieldType as a6, type ComplaintStatus as a7, type ComplexSelector as a8, type Compound as a9, type FeatureRule as aA, type FeedbackEvent as aB, type FeedbackPriority as aC, type FeedbackStatus as aD, type FeedbackUpdate as aE, type FeedbackUpdatesResponse as aF, type FileComplaintResponse as aG, type FrequencyConfig as aH, FrequencySchema as aI, GUIDELY_ID_ATTRIBUTE as aJ, GUIDE_EXPERIMENT_GOALS as aK, GUIDE_EXPERIMENT_GOAL_LABELS as aL, GUIDE_EXPERIMENT_STATUSES as aM, GUIDE_KINDS as aN, GUIDE_STATUSES as aO, GUIDE_VISIBILITIES as aP, type GuideConfig as aQ, GuideConfigSchema as aR, type GuideExperimentGoal as aS, type GuideExperimentGoalKind as aT, type GuideExperimentStatus as aU, type GuideExperimentVariant as aV, type GuideHoldout as aW, type GuideLocalization as aX, GuideLocalizationSchema as aY, type GuideSchedule as aZ, GuideScheduleSchema as a_, type ContrastIssue as aa, type ConversationLookupResponse as ab, ConversationLookupSchema as ac, type ConversationMessagesResponse as ad, ConversationRatingSchema as ae, type ConversationStatus as af, DEFAULT_CAPTURE_SETTINGS as ag, DEFAULT_FEATURE_ATTRIBUTE as ah, DEFAULT_LOCALE as ai, DEFAULT_PLATFORMS as aj, EMBED_IFRAME_ATTRS as ak, type ElementNode as al, type ElementSnapshot as am, type EmbedProvider as an, type ErrorTrackingSettings as ao, ErrorTrackingSettingsSchema as ap, type ExceptionProperties as aq, FEATURE_ATTRIBUTE_PATTERN as ar, FEATURE_RULE_LIMITS as as, FEEDBACK_EVENTS as at, FEEDBACK_PRIORITIES as au, FEEDBACK_PRIORITY_LABEL as av, FEEDBACK_PRIORITY_WEIGHT as aw, FEEDBACK_STATUSES as ax, FEEDBACK_STATUS_LABEL as ay, FILE_LINK_CLASS as az, type GuideConfigInput as b, type MessengerPageRequest as b$, type GuideStatus as b0, type GuideStep as b1, type GuideStepInput as b2, GuideThrottlingSchema as b3, type GuideThrottlingSettings as b4, type GuideVisibility as b5, HEATMAP_VIEWPORTS as b6, HOWTO_ACTIONS as b7, HOWTO_STEP_KINDS as b8, type HeatmapPoint as b9, MAX_MESSAGE_LENGTH as bA, MAX_PROPERTY_BYTES as bB, MAX_STACK_FRAMES as bC, MEDIA_FILE_MAX_BYTES as bD, MEDIA_FILE_TYPES as bE, MEDIA_IMAGE_MAX_BYTES as bF, MEDIA_IMAGE_TYPES as bG, MEDIA_MAX_BYTES as bH, MEDIA_VIDEO_MAX_BYTES as bI, MEDIA_VIDEO_TYPES as bJ, MESSAGE_AUTHORS as bK, type MediaContentType as bL, type MediaKind as bM, type MessageAuthor as bN, type MessengerCitation as bO, type MessengerComplaint as bP, type MessengerComplaintCategory as bQ, type MessengerComplaintOffer as bR, type MessengerComplaintsConfig as bS, type MessengerConfig as bT, type MessengerConversation as bU, type MessengerHomeCards as bV, type MessengerHowToCitation as bW, type MessengerIdeaOffer as bX, type MessengerIdeasConfig as bY, type MessengerMessage as bZ, type MessengerPageContent as b_, type HeatmapProperties as ba, type HeatmapViewport as bb, type HowToAction as bc, type HowToAnnotation as bd, HowToAnnotationSchema as be, type HowToStepKind as bf, type IdentifyRequest as bg, IdentifyRequestSchema as bh, type IdentifyResponse as bi, LOCALE_PATTERN as bj, LOGGED_IN_AUDIENCE as bk, LocaleSchema as bl, type LocalizationSettings as bm, LocalizationSettingsSchema as bn, MAX_ANNOTATIONS as bo, MAX_COLLECTION_DEPTH as bp, MAX_COMPLAINT_ANSWER_LENGTH as bq, MAX_COMPLAINT_ATTACHMENT_BYTES as br, MAX_COMPLAINT_CHOICES as bs, MAX_COMPLAINT_FIELDS as bt, MAX_COMPLAINT_LENGTH as bu, MAX_CUSTOM_CSS as bv, MAX_FEEDBACK_COMMENT as bw, MAX_FEEDBACK_DESCRIPTION as bx, MAX_FEEDBACK_NOTE as by, MAX_FEEDBACK_TITLE as bz, AGENT_METADATA_MAX_BYTES as c, SELECTOR_KINDS as c$, MessengerPageRequestSchema as c0, type MessengerPageSuggestion as c1, type MessengerStatus as c2, type MessengerSuggestedGuide as c3, type MessengerTeammate as c4, NETWORK_PLUGIN as c5, NOISY_DATA_ATTR as c6, type NetworkPluginPayload as c7, type NetworkRequest as c8, type NetworkRequestType as c9, RC_MODULE_IDS as cA, RC_MODULE_LABELS as cB, RECORDING_LEVELS as cC, REPLAY_MAX_COMPRESSED_BYTES as cD, REPLAY_MAX_RAW_BYTES as cE, REPLY_TIMES as cF, RULE_FIELDS as cG, RULE_OPERATORS as cH, type RcArticleLike as cI, type RcCollectionLike as cJ, type RcSection as cK, type RecordingLevel as cL, type ReplayChunk as cM, ReplayChunkSchema as cN, type ReplaySettings as cO, ReplaySettingsSchema as cP, type ReplyTime as cQ, type ResourceCenterAnnouncement as cR, type ResourceCenterArticle as cS, type ResourceCenterCollection as cT, type ResourceCenterConfig as cU, type ResourceCenterModule as cV, type ResourceCenterModuleId as cW, type ResourceCenterTranslations as cX, type RuleField as cY, type RuleOperator as cZ, SCOUT_AGENT_ID as c_, NormalizedPointSchema as ca, type NormalizedRect as cb, NormalizedRectSchema as cc, PAGE_RULE_LIMITS as cd, PATH_ID_PATTERN as ce, PDF_BLOCK_CLASS as cf, PDF_MAX_PAGES as cg, PDF_PAGES_CLASS as ch, PLACEMENTS as ci, PLATFORMS as cj, type PageContext as ck, type PagePattern as cl, type PageRule as cm, type Placement as cn, type Platform as co, PostMessageSchema as cp, type ProjectTheme as cq, ProjectThemeSchema as cr, type PublicFeedbackComment as cs, type PublicFeedbackList as ct, type PublicFeedbackRequest as cu, type PublicFeedbackRequestDetail as cv, type PublishedGuide as cw, PublishedGuideSchema as cx, type QueryParamCondition as cy, type QueryParamOp as cz, AGENT_METADATA_MAX_KEYS as d, WCAG_AA_TEXT as d$, SENSITIVE_HEADER_PATTERN as d0, SENSITIVE_PARAM_PATTERN as d1, SENSITIVE_PROPERTY_PATTERN as d2, SERVER_ASSISTED_FIELDS as d3, SHOW_ME_CLASS as d4, SHOW_ME_HREF_PREFIX as d5, SNAPSHOT_ATTRS as d6, SNAPSHOT_LIMITS as d7, SOURCEMAP_MAX_FILES_PER_UPLOAD as d8, SOURCEMAP_MAX_FILE_BYTES as d9, type StepType as dA, type SurveyAnswer as dB, type SurveyAnswers as dC, type SurveyConfig as dD, SurveyConfigSchema as dE, type SurveyQuestion as dF, SurveyQuestionSchema as dG, type SurveyResponseRequest as dH, SurveyResponseRequestSchema as dI, TAG_PROPERTY_LIMITS as dJ, TRIGGER_TYPES as dK, type TagPropertyConfig as dL, type TagPropertyDefinition as dM, type TaggingSdkConfig as dN, TargetSchema as dO, type TargetingContext as dP, type TextEntry as dQ, type TextKind as dR, type TranslationCoverage as dS, type TranslationReviewMap as dT, type TranslationReviewState as dU, type TriggerConfig as dV, TriggerSchema as dW, VIDEO_ATTRS as dX, type ValidationIssue as dY, type VideoEmbed as dZ, WCAG_AA_LARGE as d_, STATUS_LEVELS as da, STEP_TYPES as db, SURVEY_QUESTION_TYPES as dc, type ScoutStreamEvent as dd, type SdkArticleSummary as de, type SdkArticlesResponse as df, type SdkConfigResponse as dg, type SdkHowTo as dh, type SdkHowToStep as di, type SdkHowToSummary as dj, type SdkHowTosResponse as dk, type SelectorOp as dl, type SelectorStrategy as dm, SelectorStrategySchema as dn, SelectorSyntaxError as dp, type ShowWhen as dq, type StackFrame as dr, type StartConversationRequest as ds, type StartConversationResponse as dt, StartConversationSchema as du, type StatusLevel as dv, StepBranchSchema as dw, type StepButton as dx, StepSchema as dy, type StepTarget as dz, AGENT_OUTCOMES as e, mediaMaxBytes as e$, WS_MAX_MESSAGES_PER_SOCKET as e0, WS_MAX_MESSAGE_BYTES as e1, type WebSocketMessage as e2, applyGuideTranslations as e3, articleHref as e4, articleIdFromHref as e5, articleTextEntries as e6, assignGuideVariant as e7, baseLanguage as e8, clamp as e9, getPath as eA, guideLocales as eB, guidePlatforms as eC, guideTextEntries as eD, guidelyIdFromSelector as eE, hasVideoMedia as eF, isAllowedEmbedSrc as eG, isArticleListed as eH, isChecklistComplete as eI, isFileLink as eJ, isMediaContentType as eK, isPlainObject as eL, isQuestionVisible as eM, isRuleGroup as eN, isSafeMediaUrl as eO, isVideoContentType as eP, isVideoFileUrl as eQ, localeName as eR, localizeAnnouncement as eS, localizeArticle as eT, localizeGuide as eU, localizeResourceCenter as eV, matchCssSelector as eW, matchUrlPattern as eX, matchesAudiences as eY, matchesHelpQuery as eZ, mediaKind as e_, cleanLabel as ea, compare as eb, compareVersions as ec, complaintReference as ed, compoundMatches as ee, contrastIssues as ef, contrastRatio as eg, cssSelectorError as eh, defaultGuideConfig as ei, defaultStep as ej, describeCaptureStep as ek, describeRule as el, emptyRuleGroup as em, evaluateRule as en, evaluateRules as eo, evenWeights as ep, experimentBucketRules as eq, experimentSalt as er, featureCssSelectors as es, featureRuleError as et, featureRuleMatchesClick as eu, feedbackReference as ev, fingerprintError as ew, firstNameFromTraits as ex, fnv1a as ey, foldPathIds as ez, AGENT_TOOL_CALLS_PER_TURN as f, needsReview as f0, normalizeErrorMessage as f1, normalizeFrameFile as f2, normalizeLocale as f3, normalizeSnapshot as f4, orderedModules as f5, pageLabel as f6, pageName as f7, pagePattern as f8, pageRuleError as f9, showMeKeys as fA, slugify as fB, snapshotFromSelector as fC, stableStringify as fD, stepVideo as fE, stripOrigin as fF, supportsPlatform as fG, toEmbedUrl as fH, translationCoverage as fI, unreadAnnouncements as fJ, validateGuideConfig as fK, variantProblems as fL, variantRanges as fM, videoThumbnailUrl as fN, visibleAnnouncements as fO, visibleArticleIds as fP, visibleButtons as fQ, visitorAudiences as fR, visitorLocales as fS, withExperimentBucket as fT, withRecordingLevel as fU, withVisibility as fV, pageRuleMatches as fa, pageRulesMatch as fb, pageTerms as fc, parseCssSelector as fd, parseHexColor as fe, parseStack as ff, propertyAttributeAllowed as fg, queryConditionRegex as fh, randomId as fi, readableTextOn as fj, recordingLevel as fk, relativeLuminance as fl, resolveCaptureSettings as fm, resolveLocale as fn, resourceCenterLocales as fo, resourceCenterSections as fp, resourceCenterTextEntries as fq, rolloutBucket as fr, safeRegExp as fs, sanitizeCustomCss as ft, sanitizeProperties as fu, scopeCustomCss as fv, screenPath as fw, servedArticleAudiences as fx, showMeHref as fy, showMeKeyFromHref as fz, AGENT_TOOL_STATUSES as g, AGENT_TURNS_PER_BATCH as h, AGENT_TURN_MAX_TEXT as i, AGENT_TURN_ROLES as j, ANNOTATION_COLORS as k, ARTICLE_HREF_PREFIX as l, ARTICLE_VISIBILITIES as m, type AgentEventsResponse as n, type AgentOutcome as o, type AgentToolCallInput as p, type AgentToolStatus as q, type AgentTurnInput as r, type AgentTurnRole as s, type AnnotationColor as t, type ApiError as u, type AppSnapshot as v, type Appearance as w, AppearanceSchema as x, type ArticleVisibility as y, type AttrOp as z };