@guidelytech/shared 0.15.0 → 0.17.0

package/dist/runtime-x-0GT7HM.d.ts

@@ -0,0 +1,3260 @@
+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;
+/** Longest app version kept (longer values are cut). */
+declare const MAX_APP_VERSION_LENGTH = 64;
+/**
+ * An app version as stored and reported: trimmed, control characters removed, at most 64 characters,
+ * or null when empty. Kept verbatim otherwise (`2.4.1`, `v2.4.1`, `2026.10.26-beta+512`), so reports
+ * show what the app sent; ordering uses `compareVersions`.
+ */
+declare function normalizeAppVersion(input: unknown): string | null;
+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;
+    /** False for library / framework frames (Sentry `in_app`); grouping skips them when an app frame exists. Unset = unknown. */
+    inApp?: boolean;
+    /** Module or package (Sentry `module`: `myapp.views`, `com.acme.Foo`), for platforms without file paths. */
+    module?: string;
+    /** JavaScript debug id of the frame's file (Sentry `debug_meta.images`); selects its source map before release + path. */
+    debugId?: string;
+}
+/** 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;
+/**
+ * `app:///<bundle>` for a React Native bundle path (`/data/…/index.android.bundle`,
+ * `main.jsbundle`), so source maps uploaded with `--url-prefix /` match on any device.
+ */
+declare function reactNativeBundleUrl(file: string): string;
+/** Parses `Error.stack` from V8, SpiderMonkey, JavaScriptCore and Hermes 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;
+/**
+ * Applies an SDK-supplied fingerprint (Sentry `fingerprint`: `["{{ default }}", "checkout"]`) to the
+ * computed one. `{{ default }}` stands for the computed fingerprint; without it the parts replace it.
+ */
+declare function customFingerprint(parts: unknown, computed: string): string;
+
+/**
+ * The `detail` of an `exception` event (docs/error-monitoring/sdks.md): everything about an error
+ * beyond the indexed properties (breadcrumbs, contexts, tags, extra, the exception chain, threads,
+ * debug images…), in the Sentry event shape so the issue page renders Guidely and Sentry SDK events
+ * alike. Zod-free: SDKs use these helpers at runtime, the server schema lives in `events.ts`.
+ */
+/** Largest `detail` kept per occurrence (JSON characters); SDKs and the server trim to it. */
+declare const MAX_EXCEPTION_DETAIL_BYTES: number;
+/** A `detail` larger than this is dropped whole instead of trimmed (the event is still stored). */
+declare const MAX_EXCEPTION_DETAIL_RAW_BYTES: number;
+declare const MAX_BREADCRUMBS = 100;
+declare const MAX_EXCEPTION_CHAIN = 20;
+declare const MAX_DETAIL_FRAMES = 250;
+declare const MAX_DETAIL_THREADS = 100;
+declare const MAX_DEBUG_IMAGES = 500;
+declare const MAX_ERROR_TAGS = 50;
+type ErrorLevelName = "fatal" | "error" | "warning" | "info" | "debug";
+/** A Sentry-shaped frame (oldest call first in a stack, the crashing frame last). */
+interface DetailFrame {
+    function?: string;
+    module?: string;
+    package?: string;
+    filename?: string;
+    abs_path?: string;
+    lineno?: number;
+    colno?: number;
+    in_app?: boolean;
+    instruction_addr?: string;
+    image_addr?: string;
+    symbol_addr?: string;
+    platform?: string;
+    context_line?: string;
+    pre_context?: string[];
+    post_context?: string[];
+    vars?: Record<string, unknown>;
+    [k: string]: unknown;
+}
+interface DetailMechanism {
+    type?: string;
+    handled?: boolean;
+    synthetic?: boolean;
+    source?: string;
+    exception_id?: number;
+    parent_id?: number;
+    data?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+    [k: string]: unknown;
+}
+interface DetailException {
+    type?: string;
+    value?: string;
+    module?: string;
+    thread_id?: number | string;
+    mechanism?: DetailMechanism;
+    stacktrace?: {
+        frames?: DetailFrame[];
+        registers?: Record<string, string>;
+    };
+}
+interface Breadcrumb {
+    /** Unix seconds (fractional). */
+    timestamp?: number;
+    type?: string;
+    category?: string;
+    message?: string;
+    level?: ErrorLevelName | string;
+    data?: Record<string, unknown>;
+}
+interface ExceptionDetail {
+    level?: ErrorLevelName;
+    exception?: {
+        values: DetailException[];
+    };
+    threads?: {
+        values: Array<{
+            id?: number | string;
+            name?: string;
+            crashed?: boolean;
+            current?: boolean;
+            main?: boolean;
+            stacktrace?: {
+                frames?: DetailFrame[];
+            };
+        }>;
+    };
+    breadcrumbs?: {
+        values: Breadcrumb[];
+    };
+    contexts?: Record<string, Record<string, unknown>>;
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+    user?: {
+        id?: string;
+        email?: string;
+        username?: string;
+        ip_address?: string;
+        [k: string]: unknown;
+    };
+    fingerprint?: string[];
+    debug_meta?: {
+        images: Array<Record<string, unknown>>;
+    };
+    request?: {
+        url?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        query_string?: string;
+        data?: unknown;
+        [k: string]: unknown;
+    };
+    transaction?: string;
+    server_name?: string;
+    logger?: string;
+    dist?: string;
+    environment?: string;
+    platform?: string;
+    [k: string]: unknown;
+}
+/** Tags as Sentry keeps them: at most 50, keys ≤ 32 and values ≤ 200 characters, values stringified. */
+declare function normalizeTags(tags: Record<string, unknown> | null | undefined): Record<string, string>;
+/**
+ * Trims a detail to `max` JSON characters, in the order the contract fixes: oldest breadcrumbs, then
+ * frame variables and source context, then threads other than the crashed one, then extra, then
+ * frames from the middle of long stacks. Mutates and returns `detail`.
+ */
+declare function trimExceptionDetail<T extends ExceptionDetail>(detail: T, max?: number): T;
+/** An `ignoreErrors` / `denyUrls` / `allowUrls` entry: a substring, or a pattern. */
+type ErrorFilterPattern = string | RegExp;
+/**
+ * True when the SDK's filters drop an error: `ignoreErrors` matches `"<type>: <message>"` or the
+ * message; `denyUrls` matches the innermost frame file; a non-empty `allowUrls` that doesn't match
+ * it drops the error too. Errors without a frame file pass the URL filters. Shared by every SDK
+ * (conformance vectors `errorFilters`).
+ */
+declare function errorFilterDrops(e: {
+    type?: string;
+    message?: string;
+    file?: string | null;
+}, opts: {
+    ignoreErrors?: readonly ErrorFilterPattern[];
+    denyUrls?: readonly ErrorFilterPattern[];
+    allowUrls?: readonly ErrorFilterPattern[];
+}): boolean;
+
+/**
+ * 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`, `performance`) 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;
+}
+/**
+ * Performance tracing in Guidely's own SDKs: pageload / navigation transactions with Web Vitals,
+ * resource and long-task spans, and fetch/XHR spans with trace propagation. Sentry SDKs are controlled
+ * by their own `tracesSampleRate`, so this doesn't affect them. Optional in `CaptureSettings` for older
+ * stored settings; `resolveCaptureSettings` always fills it.
+ */
+interface PerformanceSettings {
+    enabled: boolean;
+    /** Percentage of page loads traced (0–100), decided once per page load. SDK `tracesSampleRate` can only lower it. */
+    sampleRate: number;
+}
+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;
+    performance?: PerformanceSettings;
+}
+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 PerformanceSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    sampleRate: z.ZodOptional<z.ZodNumber>;
+}, 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>>;
+    appVersion: z.ZodOptional<z.ZodString>;
+}, 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;
+        /** Performance tracing (Guidely SDK); absent from servers that predate it (no tracing). */
+        performance?: PerformanceSettings;
+        /** `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;
+    };
+}
+
+/** Bug report (user feedback) types and limits shared by the server and the SDK (zod-free). */
+declare const MAX_BUG_REPORT_LENGTH = 4000;
+/** Largest screenshot a bug report may carry (Sentry's feedback widget allows about the same). */
+declare const MAX_BUG_REPORT_SCREENSHOT_BYTES: number;
+/** `guidely.captureFeedback(...)`. Only `message` is required. */
+interface BugReportInput {
+    message: string;
+    email?: string | null;
+    name?: string | null;
+    /** The error the report is about: an exception event id (defaults to the last error this page reported). */
+    associatedEventId?: string | null;
+    /** Free-form tags shown with the report (strings, at most 20). */
+    tags?: Record<string, string>;
+    /** One image (png, jpeg, webp or gif) as a File/Blob, or already base64-encoded. */
+    screenshot?: Blob | {
+        fileName: string;
+        data: string;
+    } | null;
+}
+/** What `POST /v1/sdk/bug-reports` answers. */
+interface BugReportResponse {
+    id: string;
+    /** Linked to an error issue already (the associated error arrived first). */
+    linked: boolean;
+}
+
+/**
+ * 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 { CapturedElementSchema 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, type Breadcrumb as J, type BugReportInput as K, type BugReportResponse as L, ButtonSchema as M, CAPTURE_PARAM as N, CAPTURE_SCREENSHOT_MAX_BYTES as O, COMMON_LOCALES as P, COMPLAINT_EVENTS as Q, type RuleGroup as R, COMPLAINT_FIELD_TYPES as S, COMPLAINT_STATUSES as T, CONTROL_VARIANT_ID as U, type CaptureSessionInfo as V, type CaptureSettings as W, type CaptureStep as X, type CaptureStepInput as Y, CaptureStepSchema as Z, type CapturedElement as _, type Rule as a, type GuideExperimentGoal as a$, type ChecklistConfig as a0, ChecklistConfigSchema as a1, type ChecklistProgressRequest as a2, ChecklistProgressRequestSchema as a3, type ChecklistTask as a4, ChecklistTaskSchema as a5, type ClickFacts as a6, type ComplaintEvent as a7, type ComplaintField as a8, type ComplaintFieldType as a9, FEATURE_ATTRIBUTE_PATTERN as aA, FEATURE_RULE_LIMITS as aB, FEEDBACK_EVENTS as aC, FEEDBACK_PRIORITIES as aD, FEEDBACK_PRIORITY_LABEL as aE, FEEDBACK_PRIORITY_WEIGHT as aF, FEEDBACK_STATUSES as aG, FEEDBACK_STATUS_LABEL as aH, FILE_LINK_CLASS as aI, type FeatureRule as aJ, type FeedbackEvent as aK, type FeedbackPriority as aL, type FeedbackStatus as aM, type FeedbackUpdate as aN, type FeedbackUpdatesResponse as aO, type FileComplaintResponse as aP, type FrequencyConfig as aQ, FrequencySchema as aR, GUIDELY_ID_ATTRIBUTE as aS, GUIDE_EXPERIMENT_GOALS as aT, GUIDE_EXPERIMENT_GOAL_LABELS as aU, GUIDE_EXPERIMENT_STATUSES as aV, GUIDE_KINDS as aW, GUIDE_STATUSES as aX, GUIDE_VISIBILITIES as aY, type GuideConfig as aZ, GuideConfigSchema as a_, type ComplaintStatus as aa, type ComplexSelector as ab, type Compound as ac, type ContrastIssue as ad, type ConversationLookupResponse as ae, ConversationLookupSchema as af, type ConversationMessagesResponse as ag, ConversationRatingSchema as ah, type ConversationStatus as ai, DEFAULT_CAPTURE_SETTINGS as aj, DEFAULT_FEATURE_ATTRIBUTE as ak, DEFAULT_LOCALE as al, DEFAULT_PLATFORMS as am, type DetailException as an, type DetailFrame as ao, type DetailMechanism as ap, EMBED_IFRAME_ATTRS as aq, type ElementNode as ar, type ElementSnapshot as as, type EmbedProvider as at, type ErrorFilterPattern as au, type ErrorLevelName as av, type ErrorTrackingSettings as aw, ErrorTrackingSettingsSchema as ax, type ExceptionDetail as ay, type ExceptionProperties as az, type GuideConfigInput as b, MEDIA_MAX_BYTES as b$, type GuideExperimentGoalKind as b0, type GuideExperimentStatus as b1, type GuideExperimentVariant as b2, type GuideHoldout as b3, type GuideLocalization as b4, GuideLocalizationSchema as b5, type GuideSchedule as b6, GuideScheduleSchema as b7, GuideStateUpdateSchema as b8, type GuideStatus as b9, MAX_BUG_REPORT_LENGTH as bA, MAX_BUG_REPORT_SCREENSHOT_BYTES as bB, MAX_COLLECTION_DEPTH as bC, MAX_COMPLAINT_ANSWER_LENGTH as bD, MAX_COMPLAINT_ATTACHMENT_BYTES as bE, MAX_COMPLAINT_CHOICES as bF, MAX_COMPLAINT_FIELDS as bG, MAX_COMPLAINT_LENGTH as bH, MAX_CUSTOM_CSS as bI, MAX_DEBUG_IMAGES as bJ, MAX_DETAIL_FRAMES as bK, MAX_DETAIL_THREADS as bL, MAX_ERROR_TAGS as bM, MAX_EXCEPTION_CHAIN as bN, MAX_EXCEPTION_DETAIL_BYTES as bO, MAX_EXCEPTION_DETAIL_RAW_BYTES as bP, MAX_FEEDBACK_COMMENT as bQ, MAX_FEEDBACK_DESCRIPTION as bR, MAX_FEEDBACK_NOTE as bS, MAX_FEEDBACK_TITLE as bT, MAX_MESSAGE_LENGTH as bU, MAX_PROPERTY_BYTES as bV, MAX_STACK_FRAMES as bW, MEDIA_FILE_MAX_BYTES as bX, MEDIA_FILE_TYPES as bY, MEDIA_IMAGE_MAX_BYTES as bZ, MEDIA_IMAGE_TYPES as b_, type GuideStep as ba, type GuideStepInput as bb, GuideThrottlingSchema as bc, type GuideThrottlingSettings as bd, type GuideVisibility as be, HEATMAP_VIEWPORTS as bf, HOWTO_ACTIONS as bg, HOWTO_STEP_KINDS as bh, type HeatmapPoint as bi, type HeatmapProperties as bj, type HeatmapViewport as bk, type HowToAction as bl, type HowToAnnotation as bm, HowToAnnotationSchema as bn, type HowToStepKind as bo, type IdentifyRequest as bp, IdentifyRequestSchema as bq, type IdentifyResponse as br, LOCALE_PATTERN as bs, LOGGED_IN_AUDIENCE as bt, LocaleSchema as bu, type LocalizationSettings as bv, LocalizationSettingsSchema as bw, MAX_ANNOTATIONS as bx, MAX_APP_VERSION_LENGTH as by, MAX_BREADCRUMBS as bz, AGENT_METADATA_MAX_BYTES as c, REPLY_TIMES as c$, MEDIA_VIDEO_MAX_BYTES as c0, MEDIA_VIDEO_TYPES as c1, MESSAGE_AUTHORS as c2, type MediaContentType as c3, type MediaKind as c4, type MessageAuthor as c5, type MessengerCitation as c6, type MessengerComplaint as c7, type MessengerComplaintCategory as c8, type MessengerComplaintOffer as c9, PDF_MAX_PAGES as cA, PDF_PAGES_CLASS as cB, PLACEMENTS as cC, PLATFORMS as cD, type PageContext as cE, type PagePattern as cF, type PageRule as cG, type PerformanceSettings as cH, PerformanceSettingsSchema as cI, type Placement as cJ, type Platform as cK, PostMessageSchema as cL, type ProjectTheme as cM, ProjectThemeSchema as cN, type PublicFeedbackComment as cO, type PublicFeedbackList as cP, type PublicFeedbackRequest as cQ, type PublicFeedbackRequestDetail as cR, type PublishedGuide as cS, PublishedGuideSchema as cT, type QueryParamCondition as cU, type QueryParamOp as cV, RC_MODULE_IDS as cW, RC_MODULE_LABELS as cX, RECORDING_LEVELS as cY, REPLAY_MAX_COMPRESSED_BYTES as cZ, REPLAY_MAX_RAW_BYTES as c_, type MessengerComplaintsConfig as ca, type MessengerConfig as cb, type MessengerConversation as cc, type MessengerHomeCards as cd, type MessengerHowToCitation as ce, type MessengerIdeaOffer as cf, type MessengerIdeasConfig as cg, type MessengerMessage as ch, type MessengerPageContent as ci, type MessengerPageRequest as cj, MessengerPageRequestSchema as ck, type MessengerPageSuggestion as cl, type MessengerStatus as cm, type MessengerSuggestedGuide as cn, type MessengerTeammate as co, NETWORK_PLUGIN as cp, NOISY_DATA_ATTR as cq, type NetworkPluginPayload as cr, type NetworkRequest as cs, type NetworkRequestType as ct, NormalizedPointSchema as cu, type NormalizedRect as cv, NormalizedRectSchema as cw, PAGE_RULE_LIMITS as cx, PATH_ID_PATTERN as cy, PDF_BLOCK_CLASS as cz, AGENT_METADATA_MAX_KEYS as d, type SurveyQuestion as d$, RULE_FIELDS as d0, RULE_OPERATORS as d1, type RcArticleLike as d2, type RcCollectionLike as d3, type RcSection as d4, type RecordingLevel as d5, type ReplayChunk as d6, ReplayChunkSchema as d7, type ReplaySettings as d8, ReplaySettingsSchema as d9, type ScoutStreamEvent as dA, type SdkArticleSummary as dB, type SdkArticlesResponse as dC, type SdkConfigResponse as dD, type SdkHowTo as dE, type SdkHowToStep as dF, type SdkHowToSummary as dG, type SdkHowTosResponse as dH, type SelectorOp as dI, type SelectorStrategy as dJ, SelectorStrategySchema as dK, SelectorSyntaxError as dL, type ShowWhen as dM, type StackFrame as dN, type StartConversationRequest as dO, type StartConversationResponse as dP, StartConversationSchema as dQ, type StatusLevel as dR, StepBranchSchema as dS, type StepButton as dT, StepSchema as dU, type StepTarget as dV, type StepType as dW, type SurveyAnswer as dX, type SurveyAnswers as dY, type SurveyConfig as dZ, SurveyConfigSchema as d_, type ReplyTime as da, type ResourceCenterAnnouncement as db, type ResourceCenterArticle as dc, type ResourceCenterCollection as dd, type ResourceCenterConfig as de, type ResourceCenterModule as df, type ResourceCenterModuleId as dg, type ResourceCenterTranslations as dh, type RuleField as di, type RuleOperator as dj, SCOUT_AGENT_ID as dk, SELECTOR_KINDS as dl, SENSITIVE_HEADER_PATTERN as dm, SENSITIVE_PARAM_PATTERN as dn, SENSITIVE_PROPERTY_PATTERN as dp, SERVER_ASSISTED_FIELDS as dq, SHOW_ME_CLASS as dr, SHOW_ME_HREF_PREFIX as ds, SNAPSHOT_ATTRS as dt, SNAPSHOT_LIMITS as du, SOURCEMAP_MAX_FILES_PER_UPLOAD as dv, SOURCEMAP_MAX_FILE_BYTES as dw, STATUS_LEVELS as dx, STEP_TYPES as dy, SURVEY_QUESTION_TYPES as dz, AGENT_OUTCOMES as e, guideTextEntries as e$, SurveyQuestionSchema as e0, type SurveyResponseRequest as e1, SurveyResponseRequestSchema as e2, TAG_PROPERTY_LIMITS as e3, TRIGGER_TYPES as e4, type TagPropertyConfig as e5, type TagPropertyDefinition as e6, type TaggingSdkConfig as e7, TargetSchema as e8, type TargetingContext as e9, compoundMatches as eA, contrastIssues as eB, contrastRatio as eC, cssSelectorError as eD, customFingerprint as eE, defaultGuideConfig as eF, defaultStep as eG, describeCaptureStep as eH, describeRule as eI, emptyRuleGroup as eJ, errorFilterDrops as eK, evaluateRule as eL, evaluateRules as eM, evenWeights as eN, experimentBucketRules as eO, experimentSalt as eP, featureCssSelectors as eQ, featureRuleError as eR, featureRuleMatchesClick as eS, feedbackReference as eT, fingerprintError as eU, firstNameFromTraits as eV, fnv1a as eW, foldPathIds as eX, getPath as eY, guideLocales as eZ, guidePlatforms as e_, type TextEntry as ea, type TextKind as eb, type TranslationCoverage as ec, type TranslationReviewMap as ed, type TranslationReviewState as ee, type TriggerConfig as ef, TriggerSchema as eg, VIDEO_ATTRS as eh, type ValidationIssue as ei, type VideoEmbed as ej, WCAG_AA_LARGE as ek, WCAG_AA_TEXT as el, WS_MAX_MESSAGES_PER_SOCKET as em, WS_MAX_MESSAGE_BYTES as en, type WebSocketMessage as eo, applyGuideTranslations as ep, articleHref as eq, articleIdFromHref as er, articleTextEntries as es, assignGuideVariant as et, baseLanguage as eu, clamp as ev, cleanLabel as ew, compare as ex, compareVersions as ey, complaintReference as ez, AGENT_TOOL_CALLS_PER_TURN as f, showMeKeys as f$, guidelyIdFromSelector as f0, hasVideoMedia as f1, isAllowedEmbedSrc as f2, isArticleListed as f3, isChecklistComplete as f4, isFileLink as f5, isMediaContentType as f6, isPlainObject as f7, isQuestionVisible as f8, isRuleGroup as f9, 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, reactNativeBundleUrl as fJ, readableTextOn as fK, recordingLevel as fL, relativeLuminance as fM, resolveCaptureSettings as fN, resolveLocale as fO, resourceCenterLocales as fP, resourceCenterSections as fQ, resourceCenterTextEntries as fR, rolloutBucket as fS, safeRegExp as fT, sanitizeCustomCss as fU, sanitizeProperties as fV, scopeCustomCss as fW, screenPath as fX, servedArticleAudiences as fY, showMeHref as fZ, showMeKeyFromHref as f_, isSafeMediaUrl as fa, isVideoContentType as fb, isVideoFileUrl as fc, localeName as fd, localizeAnnouncement as fe, localizeArticle as ff, localizeGuide as fg, localizeResourceCenter as fh, matchCssSelector as fi, matchUrlPattern as fj, matchesAudiences as fk, matchesHelpQuery as fl, mediaKind as fm, mediaMaxBytes as fn, needsReview as fo, normalizeAppVersion as fp, normalizeErrorMessage as fq, normalizeFrameFile as fr, normalizeLocale as fs, normalizeSnapshot as ft, normalizeTags as fu, orderedModules as fv, pageLabel as fw, pageName as fx, pagePattern as fy, pageRuleError as fz, AGENT_TOOL_STATUSES as g, slugify as g0, snapshotFromSelector as g1, stableStringify as g2, stepVideo as g3, stripOrigin as g4, supportsPlatform as g5, toEmbedUrl as g6, translationCoverage as g7, trimExceptionDetail as g8, unreadAnnouncements as g9, validateGuideConfig as ga, variantProblems as gb, variantRanges as gc, videoThumbnailUrl as gd, visibleAnnouncements as ge, visibleArticleIds as gf, visibleButtons as gg, visitorAudiences as gh, visitorLocales as gi, withExperimentBucket as gj, withRecordingLevel as gk, withVisibility as gl, 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 };