import * as vue from 'vue';
import { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
import { U as UseSeoReturn, G as GlobalSeoConfig } from './vitepressTransform-CZ_IB3dq.js';
export { A as AI_BOTS, y as BlogMeta, x as BreadcrumbCrumb, v as BuildLlmsParams, u as BuildRobotsParams, B as BuildSitemapParams, E as ContentConfig, C as CreateSeoTransformPageDataOptions, D as DcsRobotsOptions, F as FaqSource, X as HeadOverrides, P as PageSeoConfig, R as ResolvedPageOverrides, T as ResolvedPageSeo, z as ReviewSource, w as SchemaObject, O as SeoAlternateConfig, I as SeoAuthorConfig, H as SeoConfiguration, K as SeoImagesConfig, L as SeoOpenGraphConfig, S as SeoPageContext, r as SeoPageTypeRule, N as SeoSchemaConfig, J as SeoSocialConfig, M as SeoTwitterConfig, Q as SeoVerificationConfig, W as UseSeoConfig, t as VitePressHeadConfig, V as VitePressPageData, q as absolutizeUrl, j as breadcrumbTrailFromRoute, k as buildBlogPosting, h as buildBreadcrumbList, l as buildFaqPage, g as buildGlobalGraph, f as buildLlmsTxt, m as buildReviewSchemaParts, e as buildRobotsTxt, a as buildSitemapXml, b as buildVitePressSeoHead, c as createSeoTransformPageData, d as defaultRelativePathToRoute, o as filterRealFaq, n as filterRealReviews, p as findReviewItemsForPage, i as isRouteIndexable, s as slugToTitle } from './vitepressTransform-CZ_IB3dq.js';
export { l as HeadLinkTag, H as HeadMetaTag, m as HeadScriptTag, o as HeadTagOverrides, I as InstallSeoHeadOptions, R as ResolvedHeadTags, q as SeoHeadClientLike, t as SeoHeadEntryLike, u as SeoHeadInput, v as SeoHeadPageRoute, w as SeoHeadPagesManifest, x as SeoHeadResolution, y as SeoHeadResolutionReason, p as SeoHeadRouteLike, S as SeoHeadRouterLike, b as buildHeadTags, k as buildSeoHeadRouteMap, f as escapeJsonLd, g as generateJsonLd, a as generateOpenGraphMeta, c as generateTwitterMeta, j as installSeoHead, h as isManagedLinkRel, i as isManagedMetaTag, n as normalizeSeoHeadPath, d as renderHeadTags, r as resolvePageSeo, s as spliceHeadHtml, e as stripManagedHeadTags } from './installSeoHead-CuVdVCis.js';
import { ImageContext, ResponsiveImageResult } from '@duffcloudservices/cms-core';
export { ImageContext, ResponsiveImageOptions, ResponsiveImageResult, ResponsiveSource, isCdnAssetUrl, resolveResponsiveImage } from '@duffcloudservices/cms-core';

/**
 * Types for .dcs/content.yaml structure
 */
/**
 * Root structure of .dcs/content.yaml
 */
interface DcsContentFile {
    /** Schema version */
    version: number;
    /** ISO timestamp of last update */
    lastUpdated: string;
    /** Email or identifier of who made the update */
    updatedBy?: string;
    /** Global text content shared across all pages */
    global?: Record<string, string>;
    /** Page-specific text content keyed by page slug */
    pages?: Record<string, Record<string, string>>;
}
/**
 * Configuration for useTextContent composable
 */
interface TextContentConfig {
    /** Page slug matching entry in content.yaml */
    pageSlug: string;
    /** Default text values for all keys used by this page */
    defaults: Record<string, string>;
    /** Whether to fetch runtime overrides (default: true, but only if mode is 'runtime') */
    fetchOnMount?: boolean;
    /** Custom cache key for deduplication */
    cacheKey?: string;
    /** Cache TTL in milliseconds (default: 60000) */
    cacheTtl?: number;
}
/**
 * Return type of useTextContent composable
 */
interface TextContentReturn {
    /** Get text by key with optional fallback */
    t: (key: string, fallback?: string) => string;
    /** Get array of objects from indexed keys (e.g., items.1.title, items.2.title) */
    getArray: (arrayKey: string) => Array<Record<string, unknown> & {
        _index: number;
    }>;
    /** All resolved texts (defaults merged with overrides) */
    texts: vue.ComputedRef<Record<string, string>>;
    /** Raw overrides from build-time or API */
    overrides: vue.Ref<Record<string, string>>;
    /** Loading state for runtime fetch */
    isLoading: vue.Ref<boolean>;
    /** Error message if fetch failed */
    error: vue.Ref<string | null>;
    /** Manually refresh overrides */
    refresh: () => Promise<void>;
    /** Check if a key has an override */
    hasOverride: (key: string) => boolean;
    /** Whether build-time content was available */
    hasBuildTimeContent: boolean;
    /** Current mode: 'commit' (build-time) or 'runtime' (API fetch) */
    mode: 'commit' | 'runtime';
}

/**
 * useTextContent Composable
 *
 * Provides text content management with build-time injection support and optional
 * runtime API overrides for DCS-managed customer sites.
 *
 * Content resolution order:
 * 1. Runtime API overrides (premium tier only, if mode is 'runtime')
 * 2. Build-time content from .dcs/content.yaml (injected via dcsContentPlugin)
 * 3. Hardcoded defaults passed to the composable
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { useTextContent } from '@duffcloudservices/cms'
 *
 * const { t, isLoading, error } = useTextContent({
 *   pageSlug: 'home',
 *   defaults: {
 *     'hero.title': 'Welcome to Our Site',
 *     'hero.subtitle': 'Build something amazing',
 *     'cta.primary': 'Get Started'
 *   }
 * })
 * </script>
 *
 * <template>
 *   <h1>{{ t('hero.title') }}</h1>
 *   <p>{{ t('hero.subtitle') }}</p>
 *   <button>{{ t('cta.primary') }}</button>
 * </template>
 * ```
 */

/**
 * useTextContent composable for DCS-managed text content.
 *
 * @param config - Configuration object
 * @returns Text content helpers and state
 */
declare function useTextContent(config: TextContentConfig): TextContentReturn;

/**
 * useSEO Composable
 *
 * Provides SEO configuration with build-time injection support from .dcs/seo.yaml.
 * Generates meta tags, Open Graph, Twitter Cards, and JSON-LD structured data.
 *
 * The actual tag resolution lives in the framework-agnostic `../seo/headTags`
 * module so that the build-time static-HTML emitter (`dcsSeoPlugin`) produces
 * byte-identical output. This composable is a thin Vue/unhead wrapper over it.
 *
 * THE HEAD-AUTHORITY CONTRACT (C-356). `.dcs/seo.yaml` is the ONLY writer of
 * the managed head fields. `applyHead()` RE-ASSERTS the baked head at runtime;
 * it never AUTHORS one, so it takes no arguments. Full text + reasoning:
 * `.docs/plans/dynamic-site-resolution/README.md` § "The head-authority
 * contract (C-356)".
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { useSEO } from '@duffcloudservices/cms'
 *
 * const { applyHead, getSchema, config } = useSEO('home')
 *
 * // Re-assert the baked head for this route. No arguments — ever.
 * applyHead()
 * </script>
 * ```
 *
 * Need a different title? Change it in `.dcs/seo.yaml` (or in the portal SEO
 * editor, which writes it). A value hardcoded here is a SECOND writer, and a
 * second writer is a divergence by construction — whether or not today's two
 * values happen to agree.
 */

/**
 * useSEO composable for DCS-managed SEO configuration.
 *
 * @param pageSlug - Page slug matching entry in seo.yaml
 * @param pagePath - Optional page path for canonical URL generation
 * @returns SEO helpers and state
 */
declare function useSEO(pageSlug: string, pagePath?: string): UseSeoReturn;
/**
 * Create a typed useSEO function with site-specific defaults.
 * Useful for creating a site-wide wrapper.
 *
 * @example
 * ```ts
 * // composables/useSiteSeo.ts
 * import { createSiteSEO } from '@duffcloudservices/cms'
 *
 * export const useSiteSeo = createSiteSEO({
 *   siteName: 'My Site',
 *   siteUrl: 'https://example.com'
 * })
 * ```
 */
declare function createSiteSEO(_siteDefaults: Partial<GlobalSeoConfig>): (pageSlug: string, pagePath?: string) => UseSeoReturn;

/**
 * Types for release notes API
 */
/**
 * Release note data from the API
 */
interface ReleaseNote {
    /** Semantic version (e.g., "1.2.0") */
    version: string;
    /** Release title */
    title: string;
    /** Brief summary for listings */
    summary: string;
    /** Full markdown content */
    notesMarkdown: string;
    /** Number of changes in release */
    changeCount: number;
    /** ISO timestamp of release date */
    releaseDate: string;
}
/**
 * Return type of useReleaseNotes composable
 */
interface ReleaseNotesReturn {
    /** The loaded release note */
    releaseNote: vue.Ref<ReleaseNote | null>;
    /** Loading state */
    isLoading: vue.Ref<boolean>;
    /** Error message */
    error: vue.Ref<string | null>;
    /** Refresh from API */
    refresh: () => Promise<void>;
}
/**
 * Return type of useSiteVersion composable
 */
interface SiteVersionReturn {
    /** Current site version */
    version: vue.Ref<string | null>;
    /** Loading state */
    isLoading: vue.Ref<boolean>;
    /** Full release notes link */
    releaseNotesUrl: vue.ComputedRef<string>;
}

/**
 * useReleaseNotes Composable
 *
 * Fetches and displays versioned release notes from the DCS Portal API.
 * Supports fetching specific versions or the latest release.
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { useReleaseNotes } from '@duffcloudservices/cms'
 * import { useRoute } from 'vue-router'
 *
 * const route = useRoute()
 * const version = route.params.version as string || 'latest'
 *
 * const { releaseNote, isLoading, error } = useReleaseNotes(version)
 * </script>
 *
 * <template>
 *   <div v-if="isLoading">Loading...</div>
 *   <div v-else-if="error">{{ error }}</div>
 *   <article v-else-if="releaseNote">
 *     <h1>{{ releaseNote.title }}</h1>
 *     <p>{{ releaseNote.summary }}</p>
 *     <div v-html="renderedMarkdown" />
 *   </article>
 * </template>
 * ```
 */

/**
 * useReleaseNotes composable for fetching release notes from the DCS API.
 *
 * @param version - Semantic version (e.g., "1.2.0") or "latest"
 * @param options - Optional configuration
 * @returns Release notes data and state
 */
declare function useReleaseNotes(version: string, options?: {
    fetchOnMount?: boolean;
}): ReleaseNotesReturn;

/**
 * useSiteVersion Composable
 *
 * Gets the current site version for footer badges and version displays.
 * Fetches the latest release version from the DCS Portal API.
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { useSiteVersion } from '@duffcloudservices/cms'
 *
 * const { version, releaseNotesUrl } = useSiteVersion()
 * </script>
 *
 * <template>
 *   <footer>
 *     <a v-if="version" :href="releaseNotesUrl" class="version-badge">
 *       v{{ version }}
 *     </a>
 *   </footer>
 * </template>
 * ```
 */

/**
 * useSiteVersion composable for displaying the current site version.
 *
 * @param options - Optional configuration
 * @returns Site version data and computed URL
 */
declare function useSiteVersion(options?: {
    fetchOnMount?: boolean;
}): SiteVersionReturn;

/**
 * useMediaCarousel Composable
 *
 * Extracts media carousel items from text content keys following the pattern:
 * `{prefix}.{N}.url`, `{prefix}.{N}.type`, `{prefix}.{N}.alt`
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { useTextContent, useMediaCarousel } from '@duffcloudservices/cms'
 *
 * const { t } = useTextContent({
 *   pageSlug: 'bio-mackenzie',
 *   defaults: {
 *     'hero.media-carousel.0.url': '/images/staff/mackenzie.webp',
 *     'hero.media-carousel.0.type': 'image',
 *     'hero.media-carousel.0.alt': 'Mackenzie Kowalick',
 *     'hero.media-carousel.1.url': '/videos/intro.mp4',
 *     'hero.media-carousel.1.type': 'video',
 *     'hero.media-carousel.1.alt': 'Introduction video',
 *   }
 * })
 *
 * const { items } = useMediaCarousel({
 *   prefix: 'hero.media-carousel',
 *   t,
 *   defaults: [
 *     { url: '/images/staff/mackenzie.webp', type: 'image', alt: 'Mackenzie Kowalick' }
 *   ]
 * })
 * </script>
 *
 * <template>
 *   <MediaCarousel :items="items" />
 * </template>
 * ```
 */

/**
 * Media carousel item representing an image, video, or embed
 */
interface MediaCarouselItem {
    /** URL to the image, video file, or embed URL */
    url: string;
    /**
     * Type of media: 'image', 'video' (direct file), 'youtube', or 'instagram'.
     * Render `youtube`/`instagram` items through the click-to-load facade
     * `LiteMediaEmbed` (`@duffcloudservices/cms/lite-media-embed`) so the heavy
     * player iframe loads only on user interaction — never eagerly.
     */
    type: 'image' | 'video' | 'youtube' | 'instagram';
    /** Accessibility alt text */
    alt?: string;
    /**
     * Whether this image has responsive CDN variants available.
     * Automatically set to `true` when the URL matches the DCS CDN asset pattern.
     * Components rendering the carousel should use `<ResponsiveImage>` when this is `true`.
     */
    responsive?: boolean;
}
/**
 * Configuration for useMediaCarousel composable
 */
interface UseMediaCarouselConfig {
    /** Key prefix for carousel items (e.g., 'hero.media-carousel') */
    prefix: string;
    /** The t() function from useTextContent */
    t: (key: string, fallback?: string) => string;
    /** Default items to use if no content keys are found */
    defaults?: MediaCarouselItem[];
    /** Maximum number of items to look for (default: 10) */
    maxItems?: number;
}
/**
 * Return type for useMediaCarousel composable
 */
interface UseMediaCarouselReturn {
    /** Computed array of media carousel items */
    items: ComputedRef<MediaCarouselItem[]>;
    /** Whether any items were found from content keys */
    hasItems: ComputedRef<boolean>;
    /** Number of items in the carousel */
    count: ComputedRef<number>;
}
/**
 * Extract media carousel items from text content keys.
 *
 * Looks for keys in the format:
 * - `{prefix}.{N}.url` - Required URL for the media
 * - `{prefix}.{N}.type` - Type: 'image' or 'video' (defaults to 'image')
 * - `{prefix}.{N}.alt` - Alt text for accessibility
 *
 * Items are sorted by index (0, 1, etc.) and only included if they have a valid URL.
 *
 * @param config - Configuration object
 * @returns Media carousel helpers and state
 */
declare function useMediaCarousel(config: UseMediaCarouselConfig): UseMediaCarouselReturn;

/**
 * Vue 3 composable that resolves responsive image variants for DCS CDN-hosted assets.
 *
 * Wraps the framework-agnostic `resolveResponsiveImage` from `@duffcloudservices/cms-core`
 * with reactive Vue refs so it can be used directly in `<script setup>` blocks.
 *
 * @example
 * ```vue
 * <script setup lang="ts">
 * import { useResponsiveImage } from '@duffcloudservices/cms'
 *
 * const hero = useResponsiveImage({
 *   src: 'https://files.duffcloudservices.com/kept/assets/hero/abc-123.jpg',
 *   alt: 'Hero image',
 *   context: 'hero',
 * })
 * </script>
 *
 * <template>
 *   <picture v-if="hero.hasVariants">
 *     <source
 *       v-for="source in hero.sources"
 *       :key="source.type"
 *       :srcset="source.srcset"
 *       :type="source.type"
 *       :sizes="source.sizes"
 *     />
 *     <img v-bind="hero.imgProps" class="w-full h-full object-cover" />
 *   </picture>
 *   <img v-else v-bind="hero.imgProps" class="w-full h-full object-cover" />
 * </template>
 * ```
 */

interface UseResponsiveImageOptions {
    /** Source URL — can be a reactive ref, getter, or plain string. */
    src: MaybeRefOrGetter<string>;
    /** Alt text — can be a reactive ref, getter, or plain string. */
    alt: MaybeRefOrGetter<string>;
    /** Sizing context — determines which variants to include. */
    context?: MaybeRefOrGetter<ImageContext | undefined>;
    /** Optional `sizes` attribute override. */
    sizes?: MaybeRefOrGetter<string | undefined>;
    /** Skip variant resolution and use the original URL only. */
    original?: MaybeRefOrGetter<boolean | undefined>;
    /** Intrinsic width — emitted as a layout-shift hint when paired with `height`. */
    width?: MaybeRefOrGetter<number | undefined>;
    /** Intrinsic height — emitted as a layout-shift hint when paired with `width`. */
    height?: MaybeRefOrGetter<number | undefined>;
}
/**
 * Reactively resolves responsive image metadata for a DCS CDN URL.
 *
 * The returned object is a computed ref that recomputes whenever any
 * of the input refs change. Spread `imgProps` onto an `<img>` or
 * combine with `sources` inside a `<picture>` element.
 */
declare function useResponsiveImage(options: UseResponsiveImageOptions): ResponsiveImageResult;

/**
 * Composable for reading curated review selections from DCS content.
 * Reviews are stored in content.yaml by the visual editor's ReviewPickerSheet.
 */

interface ReviewItem {
    id: string;
    platform: 'google' | 'meta' | string;
    rating: number;
    authorName: string;
    authorPhotoUrl?: string;
    text?: string;
    date?: string;
    replyText?: string;
    locationName?: string;
    sourceLocationName?: string;
    sourceUrl?: string;
}
interface UseReviewContentConfig {
    /** The section key matching the data-dcs-reviews attribute value */
    sectionKey: string;
    /** Page slug for page-specific content lookup (defaults to current page) */
    pageSlug?: string;
    /** Fallback reviews when no content is available */
    defaults?: ReviewItem[];
}
interface UseReviewContentReturn {
    /** The curated review items from content */
    reviews: ComputedRef<ReviewItem[]>;
    /** Whether any reviews are available */
    hasReviews: ComputedRef<boolean>;
    /** Number of reviews */
    count: ComputedRef<number>;
}
declare function useReviewContent(config: UseReviewContentConfig): UseReviewContentReturn;

/** How a clicked element was classified. */
type ConversionInteractionType = 'booking' | 'phone' | 'email' | 'form_submit' | 'social' | 'external' | 'internal' | 'button';
/**
 * The interaction types that ARE the money moment — the ones an owner report counts.
 *
 * Everything else (`social`, `external`, `internal`, `button`) is navigation telemetry and
 * is still captured, but it must never be summed into "conversions". Keeping the set here,
 * rather than in each report's query, means one edit changes every consumer.
 */
declare const CONVERSION_INTERACTION_TYPES: readonly ConversionInteractionType[];
/** Whether an interaction type counts as a conversion. */
declare function isConversionType(type: ConversionInteractionType): boolean;
/** A captured conversion event, in App Insights `trackEvent` shape. */
interface ConversionEvent {
    /** Event name — `site_interaction` by default (see {@link ConversionTrackingOptions.eventName}). */
    name: string;
    /** Flat string properties; App Insights `customDimensions`. */
    properties: {
        interaction_type: ConversionInteractionType;
        /**
         * `'true'` when {@link isConversionType} holds. A string, not a boolean, because App
         * Insights `customDimensions` and GA4 event params are both string maps — so the
         * owner-report query is one predicate (`is_conversion == "true"`) instead of an
         * interaction-type IN-list that every new report has to remember to keep in sync.
         */
        is_conversion: string;
        /** Visible label / aria-label of the clicked element, truncated. */
        label: string;
        /**
         * Destination, query string and fragment stripped, and REDACTED for contact schemes:
         * a `tel:` / `sms:` / `mailto:` href becomes `tel:#<digest>` — never the raw number or
         * address. See {@link redactHref}. Empty for buttons and form submits.
         */
        href: string;
        /** URL scheme of the destination including the colon (`tel:`, `https:`), or `''`. */
        href_scheme: string;
        /** Host of the destination, or `''` for buttons, form submits and contact schemes. */
        href_host: string;
        /**
         * Short digest of the contact target (the phone number / email address), or `''` for
         * everything else. Lets a report say "CTA A got 12 taps, CTA B got 3" without ever
         * storing the contact string itself.
         */
        href_hash: string;
        /** Path of the page the click happened on. */
        page_path: string;
        /** Host of the page the click happened on. */
        host: string;
        /** Schema version, so a report can tell old rows from new ones. */
        capture_version: string;
    };
}
/** A telemetry transport. Typically `(e) => telemetry.trackEvent(e)`. */
type ConversionSink = (event: ConversionEvent) => void;
interface ConversionTrackingOptions {
    /**
     * Where to send events. Optional on purpose — omit it when the telemetry SDK is
     * deferred, and call {@link attachConversionSink} once it has loaded. Events captured
     * in the meantime are buffered, not dropped.
     */
    sink?: ConversionSink;
    /**
     * Fire-and-forget transports that receive every event AS WELL AS `sink`, and that do NOT
     * count as "a sink exists" for buffering purposes.
     *
     * This distinction is load-bearing. GA4's `gtag` is a mirror: the deploy injects it as a
     * synchronous inline snippet, so it is either there when the click happens or the hit is
     * genuinely unavailable — there is nothing to wait for. App Insights is a `sink`: it boots
     * on an idle callback minutes later, which is exactly what the buffer exists to survive.
     * Treating GA4 as a `sink` would have satisfied the "do we have somewhere to send this?"
     * test on every site and quietly disabled the deferred-SDK interlock.
     */
    mirrors?: ConversionSink[];
    /**
     * Custom event name. Defaults to `site_interaction` — the name Just Posh has been
     * emitting since 2026-04, so its history stays one continuous series. Pass
     * `'dcs_conversion'` on a site with no existing history if you prefer the canonical name.
     */
    eventName?: string;
    /**
     * Extra hostnames to treat as booking destinations, on top of {@link DEFAULT_BOOKING_HOSTS}.
     * Matched on host suffix, so `vagaro.com` also matches `www.vagaro.com`.
     */
    bookingHosts?: string[];
    /**
     * Same-origin paths that mean "booking" (e.g. a self-hosted `/book`). Matched as a
     * prefix on the pathname.
     */
    bookingPaths?: string[];
    /** Extra social hostnames on top of {@link DEFAULT_SOCIAL_HOSTS}. */
    socialHosts?: string[];
    /** Max events held while no sink is attached. Default 50 — bounded so a bot cannot grow it. */
    bufferLimit?: number;
    /** Drop untrusted (script-dispatched) clicks. Default `false`. */
    requireTrusted?: boolean;
    /** Document to bind to. Defaults to the ambient `document`. Injected in tests. */
    target?: Document;
    /**
     * Also capture managed-form submissions as `form_submit`. Default `true`.
     *
     * A form submit is a conversion on every DCS site that has a form, and it is the one
     * affordance a click listener alone cannot see honestly: clicking "Send" on a form that
     * then fails validation is not a lead. So the `submit` event — not the click — is
     * authoritative, and clicks on submit controls are deliberately dropped to keep the two
     * from counting the same action twice.
     */
    captureFormSubmits?: boolean;
    /**
     * Honour the visitor's Do Not Track signal. Default `true`.
     *
     * With DNT on, `start()` binds nothing at all — no listener, no buffer, no event. This
     * is a measurement rail, not a consent platform: if a site ever grows a real consent
     * banner, gate {@link installConversionCapture} on it rather than weakening this.
     */
    respectDoNotTrack?: boolean;
    /**
     * Bind a second delegated listener even though one is already live on this document.
     *
     * Off by default and it should stay off. Two delegated listeners on one document count
     * every click twice — the same defect class C-288 measured as 52% duplicate page views
     * on a live customer site, which the portal then reported to the owner as traffic. If
     * you are reaching for this, you almost certainly want `stop()` on the existing tracker.
     */
    force?: boolean;
}
/**
 * Schema version stamped on every captured event. Bump on a breaking property change.
 *
 * `2` (C-326): `href` is redacted for `tel:`/`sms:`/`mailto:`, and `is_conversion`,
 * `href_scheme` + `href_hash` were added. Version `1` rows carry raw contact hrefs and no
 * conversion flag, so a report spanning the boundary must branch on this.
 */
declare const CONVERSION_CAPTURE_VERSION = "2";
/**
 * Booking/scheduling vendors seen across the DCS fleet plus the common SMB schedulers.
 * Host-suffix matched. Add per-site extras via `bookingHosts` rather than editing this.
 */
declare const DEFAULT_BOOKING_HOSTS: readonly string[];
/** Social destinations. Host-suffix matched. */
declare const DEFAULT_SOCIAL_HOSTS: readonly string[];
/**
 * FNV-1a (32-bit), base36. Synchronous on purpose: this runs inside a click handler, where
 * `crypto.subtle` — the only real hash a browser offers — is async and would force the
 * event to be built after the navigation has already started.
 *
 * BE HONEST ABOUT WHAT THIS IS. It is not anonymisation. A site publishes two or three
 * phone numbers, so anybody holding the site could brute-force the digest back in
 * milliseconds. What it buys is real but narrow: the contact string never lands in an
 * analytics store (GA4 forbids PII in event params outright), a support screenshot of the
 * events table cannot leak a customer's mailbox, and the value is still stable enough to
 * answer "which CTA did they tap". Do not describe it as anything more than that.
 */
declare function hashTarget(value: string): string;
/** The scheme of an href, including the colon (`tel:`, `https:`), or `''`. */
declare function hrefScheme(href: string, pageHost: string): string;
/**
 * Split an href into the parts that are safe to emit.
 *
 * For `tel:` / `sms:` / `mailto:` the target is a person's or business's contact string, so
 * it is replaced by `<scheme>#<digest>` and the digest is also surfaced on its own. For
 * everything else the href passes through {@link sanitizeUrl} unchanged — a booking URL's
 * path is the useful part and its query (which CAN carry a name or email) is already gone.
 */
declare function redactHref(href: string, pageHost: string): {
    href: string;
    scheme: string;
    hash: string;
};
/**
 * Whether this element is the control that submits a form.
 *
 * Clicks on these are dropped so the `submit` event can be the single source of truth —
 * see {@link ConversionTrackingOptions.captureFormSubmits}. Note the HTML default: a
 * `<button>` inside a form with no `type` IS a submit button, which is exactly how every
 * `<DcsForm>` renders its action.
 */
declare function isSubmitControl(el: Element): boolean;
/** Read the visitor's Do Not Track signal across the three places browsers have put it. */
declare function doNotTrackEnabled(): boolean;
/**
 * Classify a link.
 *
 * ORDER IS LOAD-BEARING and is asserted by tests. Protocol wins first (a `tel:` href has
 * no host to match on), then booking — *before* the same-origin and social checks — so a
 * self-hosted `/book` path and a booking vendor that also runs a social profile are both
 * attributed to revenue rather than to `internal` / `social`.
 */
declare function classifyHref(href: string, opts: {
    pageHost: string;
    bookingHosts: readonly string[];
    bookingPaths: readonly string[];
    socialHosts: readonly string[];
}): ConversionInteractionType;
/** The object returned by {@link createConversionTracker}. */
interface ConversionTracker {
    /** Bind the capture-phase click listener. Idempotent. */
    start(): void;
    /** Unbind and clear the buffer. Idempotent. */
    stop(): void;
    /** Attach (or replace) the sink and immediately drain anything buffered. */
    attachSink(sink: ConversionSink): void;
    /** Events currently held because no sink is attached. Read-only copy. */
    buffered(): ConversionEvent[];
    /** Capture a click target directly. Exposed for tests and manual instrumentation. */
    capture(element: Element): ConversionEvent | null;
}
/**
 * Attach a sink to every live tracker and drain their buffers.
 *
 * Call this from a deferred/lazy App Insights loader once the SDK is ready:
 *
 * ```ts
 * const { ApplicationInsights } = await import('@microsoft/applicationinsights-web')
 * const ai = new ApplicationInsights({ config })
 * ai.loadAppInsights()
 * attachConversionSink((e) => ai.trackEvent({ name: e.name, properties: e.properties }))
 * ```
 *
 * @returns how many trackers received the sink.
 */
declare function attachConversionSink(sink: ConversionSink): number;
/**
 * Framework-free conversion tracker. Vue callers usually want
 * {@link useConversionTracking} instead.
 */
declare function createConversionTracker(options?: ConversionTrackingOptions): ConversionTracker;
/**
 * Vue composable: start conversion capture for the lifetime of the calling component.
 *
 * YOU PROBABLY DO NOT NEED THIS ANY MORE. Since C-326, importing `@duffcloudservices/cms`
 * auto-installs a tracker (`installConversionCapture`), so every fleet site captures
 * conversions with no site-repo code at all. Calling this on top of that is a no-op with a
 * loud console warning — `start()` refuses to bind a second listener to a document that
 * already has one, because two listeners double every conversion count.
 *
 * It remains exported for the cases the auto-install deliberately does not cover: a site
 * that needs per-site `bookingHosts`/`bookingPaths`, or a non-cms consumer wiring capture
 * by hand. In the first case, prefer configuring the auto-installer:
 *
 * ```ts
 * import { installConversionCapture } from '@duffcloudservices/cms'
 * installConversionCapture({ bookingHosts: ['stridethera.com'], bookingPaths: ['/book'] })
 * ```
 *
 * Returns the tracker so a caller can attach a sink or inspect the buffer. Safe on the
 * server: with no `document`, `start()` is a no-op.
 */
declare function useConversionTracking(options?: ConversionTrackingOptions): ConversionTracker;

/**
 * Fleet-wide conversion capture, installed without asking the site.
 *
 * WHY THIS FILE EXISTS
 * --------------------
 * `useConversionTracking` shipped in @duffcloudservices/cms, was exported from the package
 * index, was documented with an example, and was adopted by ZERO of the eleven fleet sites.
 * Two independent reviews on 2026-07-26 measured what that cost (C-326):
 *
 *   - Bryan's Handyman Solutions exists to generate phone calls. It ships five `tel:` CTAs
 *     — hero, header, mobile icon, sticky call bar, footer — and every one of them fires
 *     nothing. `trackEvent` appears in the bundle exactly once: as the composable's own
 *     unused export. Its GA4 property was never created either, so the site has no
 *     measurement of any kind for the only action it is built to produce.
 *   - Kim Duff Homes, a flagship account, has 6 pageViews in App Insights across 365 days.
 *
 * The lesson is not "write better docs". A capability the site must remember to switch on
 * is a capability that is off. So capture is a SIDE EFFECT of importing the package every
 * fleet site already depends on, and it finds its own transport.
 *
 * HOW A SITE'S EVENTS GET OUT — three sinks, in the order they are usually available
 * ---------------------------------------------------------------------------------
 *  1. GA4 (`window.gtag`). The deploy workflow injects the gtag snippet into every built
 *     HTML file when `.dcs/site.yaml` carries a `google_analytics_id`. That means a site
 *     with GA4 configured captures conversions with LITERALLY no code change — which is
 *     precisely why the empty-`google_analytics_id` launch gate is the other half of C-326.
 *  2. `window.__dcsConversionAttach(sink)` — a one-line, import-free contract published by
 *     this module for any telemetry transport that boots later. `@duffcloudservices/telemetry`
 *     calls it automatically inside `initialize()`; a site with a bespoke App Insights boot
 *     adds the single line. Events captured before that arrive are buffered, not lost.
 *  3. `attachConversionSink(sink)` — the direct API, for callers holding the import.
 *
 * WHERE IT DELIBERATELY DOES NOTHING
 * ----------------------------------
 *  - No `document` (SSR, VitePress build, the Playwright prerender pass).
 *  - Inside an iframe — the DCS visual editor and preview surfaces frame the site, and
 *     an editor clicking around a customer's page is not a lead.
 *  - Do Not Track is on.
 *  - The page opted out via `window.__dcsConversionOptOut = true` or
 *    `<html data-dcs-analytics="off">`.
 *
 * In every one of those cases it binds no listener and buffers nothing.
 */

/** Options for {@link installConversionCapture}. */
interface InstallConversionCaptureOptions extends Omit<ConversionTrackingOptions, 'sink' | 'mirrors' | 'force'> {
    /**
     * Emit through GA4's `window.gtag` when it is present. Default `true`.
     *
     * Looked up at emit time, not install time: the gtag snippet is `async`, so on a fast
     * connection the site's JS can install this before Google's script has defined `gtag`.
     */
    gtag?: boolean;
}
/** Whether the page has explicitly asked not to be measured. */
declare function conversionOptedOut(): boolean;
/**
 * Whether this document is being rendered inside a frame.
 *
 * The DCS portal embeds customer sites in an iframe for the visual editor and preview
 * (`dcsEditorPlugin` keys off the same `window.parent !== window` test). Counting an
 * editor's clicks as customer conversions would inflate exactly the number the owner
 * report is supposed to make trustworthy.
 */
declare function inFrame(): boolean;
/** Reason the installer declined, or `null` when it installed. */
type ConversionInstallSkipReason = 'no-document' | 'already-installed' | 'in-frame' | 'do-not-track' | 'opted-out' | 'synthetic-capture';
/** Result of an {@link installConversionCapture} call. */
interface ConversionInstallResult {
    installed: boolean;
    reason: ConversionInstallSkipReason | null;
    tracker: ConversionTracker | null;
}
/**
 * Install fleet conversion capture. Idempotent; safe to call from anywhere, any number of
 * times, on the server or in a frame.
 *
 * Called for its side effect from the package index, so a site gets this by importing
 * `@duffcloudservices/cms` at all. Call it directly only to pass per-site configuration
 * (extra `bookingHosts`, a self-hosted `bookingPaths`) — do that BEFORE the first click,
 * i.e. at app entry, since the first call wins.
 */
declare function installConversionCapture(options?: InstallConversionCaptureOptions): ConversionInstallResult;
/** The installed tracker, or `null`. Exposed for tests and diagnostics. */
declare function installedConversionTracker(): ConversionTracker | null;
/**
 * Tear the auto-installed tracker down and clear the global flags.
 *
 * Exists for tests and for a site that genuinely needs to re-install with different
 * options. Not part of the normal runtime path.
 */
declare function resetConversionCapture(): void;

/** A signed-in site visitor. */
interface SiteVisitor {
    id?: string;
    email: string;
    name: string;
    picture?: string;
    createdAt?: string;
}
interface SiteVisitorSessionResult {
    /** The signed-in visitor, or `null` when signed out. */
    visitor: SiteVisitor | null;
    /** Convenience flag — `true` iff a visitor is present. */
    authenticated: boolean;
    /**
     * `true` when the probe did not reach the platform API at all — the response carried a
     * non-JSON body (C-298 layer 2), i.e. this host does not route `/api/v1/*` to the API.
     * Distinct from an ordinary signed-out visit: a site can render "sign-in temporarily
     * unavailable" instead of a login button that cannot possibly work. Absent/`false` on
     * every normal path, so existing consumers are unaffected.
     */
    apiUnreachable?: boolean;
}
interface FetchSiteVisitorSessionOptions {
    /** API base (default `/api/v1`, same-origin via Front Door). */
    apiBaseUrl?: string;
    /** Optional AbortSignal to cancel an in-flight probe. */
    signal?: AbortSignal;
}
/**
 * Normalize a parsed `/site-auth/session` BODY into a `SiteVisitor | null`.
 *
 * This is the payload-level answer to "is anyone signed in?" — the question the HTTP
 * status cannot answer, because an anonymous visitor gets `200 { "visitor": null }`
 * (A-35). Use it when your own code already parsed the body; use
 * {@link readSiteVisitorSessionResponse} when you are holding a `Response`.
 *
 * `null` means signed out. Deliberately fail-closed on every ambiguity:
 *  - a MISSING `visitor` key yields `null`, never a truthy `undefined` — the trap that
 *    made kept's `visitor.value = data.visitor` a latent defect (C-619);
 *  - an envelope claiming `authenticated: true` with no visitor object yields `null`;
 *  - a visitor object without an email is not a visitor.
 *
 * Accepts the primary/legacy `{ visitor: {...} | null }` envelope and the contracts-spec
 * `{ authenticated, user: {...} }` shape defensively.
 */
declare function siteVisitorFromSessionPayload(data: unknown): SiteVisitor | null;
/**
 * Decide "is a visitor signed in?" from a `/site-auth/session` `Response` you already
 * fetched yourself.
 *
 * THIS IS THE SEAM FOR HAND-ROLLED SESSION STORES. {@link useSiteVisitorSession} owns its
 * own fetch, which a site with an existing store (Pinia, caching, in-flight dedup, its own
 * authenticated `apiFetch`) cannot adopt — so it hand-rolls the gate and re-derives the
 * A-35 defect: `if (response.ok) return true`, which reports EVERY anonymous visitor as
 * authenticated because anonymous is `200 { "visitor": null }`. Measured cost when that
 * happened on kept: one member-gated 401 per page view, 346 in a day (C-619).
 *
 * Keep your fetch; hand the `Response` here and read the payload-derived answer:
 *
 * ```ts
 * const response = await apiFetch('/api/v1/site-auth/session')
 * const { visitor: v } = await readSiteVisitorSessionResponse(response)
 * visitor.value = v
 * return v !== null            // never `return response.ok`
 * ```
 *
 * Fails CLOSED everywhere: a non-2xx (incl. a legacy `401`), a missing response (your
 * fetch threw), an unparseable body, or a `null` visitor all resolve to signed-out. The
 * status can never on its own produce `authenticated: true` — only a real visitor object
 * in the body can.
 *
 * Silent on every anonymous path. LOUD exactly once when the body was not JSON at all
 * (`apiUnreachable: true`), because "this host does not route `/api/v1/*` to the API" must
 * not masquerade as "signed out" — that ambiguity is how kept ran with nine dead login
 * routes for ~2 weeks (C-261 / C-298 layer 2).
 *
 * Never throws.
 */
declare function readSiteVisitorSessionResponse(response: Response | null | undefined): Promise<SiteVisitorSessionResult>;
/**
 * Fetch the current site-visitor session. Never throws and never logs for the
 * anonymous case: any network error, non-OK status (incl. a legacy `401`), or
 * `{ visitor: null }` body resolves to a signed-out result.
 */
declare function fetchSiteVisitorSession(options?: FetchSiteVisitorSessionOptions): Promise<SiteVisitorSessionResult>;
interface UseSiteVisitorSessionOptions extends FetchSiteVisitorSessionOptions {
    /** Probe automatically on mount (browser only). Default `true`. */
    fetchOnMount?: boolean;
}
interface UseSiteVisitorSessionReturn {
    /** The signed-in visitor, or `null` when signed out / not yet loaded. */
    visitor: Ref<SiteVisitor | null>;
    /** `true` iff a visitor is present. */
    isAuthenticated: ComputedRef<boolean>;
    /** `true` while a probe is in flight. */
    isLoading: Ref<boolean>;
    /**
     * `true` when the last probe did not reach the platform API (non-JSON body — C-298
     * layer 2). Render "sign-in unavailable" rather than a login button that cannot work.
     */
    apiUnreachable: Ref<boolean>;
    /** Re-run the probe. */
    refresh: () => Promise<void>;
}
/**
 * Vue composable wrapper around {@link fetchSiteVisitorSession}. Reactive
 * `visitor` / `isAuthenticated` / `isLoading`, and probes on mount by default.
 */
declare function useSiteVisitorSession(options?: UseSiteVisitorSessionOptions): UseSiteVisitorSessionReturn;

/**
 * Synthetic-capture detection (C-614).
 *
 * WHY THIS EXISTS
 * ---------------
 * The fleet's post-deploy "Capture page snapshots" step drives real Chromium
 * against the LIVE production URL of the site it just deployed. The site's
 * telemetry boots exactly as it would for a visitor, so every page the capture
 * pass walked was recorded as a production pageView — during our own deploy run.
 *
 * Measured on coron8 (the smallest-traffic fleet site) over the 8 days to
 * 2026-08-11: 49 synthetic pageViews against 14 organic — 78% of the entire
 * store. All 49 landed on 08-11 across 5 deploys, against 3 real visits that
 * day, so the owner's chart read 52 where the truth was 3. Every site carrying
 * the C-589 telemetry sink plus a snapshot CI step has this.
 *
 * WHY SUPPRESSION AND NOT TAGGING
 * -------------------------------
 * The alternative was to tag the traffic with a synthetic-source dimension and
 * exclude it in every read path. That is precisely the C-430 preview/localhost
 * blend, which is a recorded UNSOLVED residual rather than a pattern worth
 * copying: it obliges every present and future consumer — the portal analytics
 * query, the MCP `analytics_summary` tool, ad-hoc KQL an owner runs — to
 * remember an exclusion, and a consumer that forgets reports the inflated
 * number with no signal that it did. Declining at the boundary keeps the
 * denominator honest in all of them at once, and matches the choice already
 * made for previews in C-601 (dev/preview telemetry points at the dev
 * component, not the production store).
 *
 * WHY THESE MARKERS
 * -----------------
 * `dcs-hide-ribbon` is not invented here. Every DCS capture tool already
 * appends it to suppress the preview ribbon in screenshots — the shared
 * `packages/cli/src/commands/capture-snapshots.ts`, each site's own
 * `scripts/capture-snapshots.*`, and the portfolio/CWV tooling that
 * `@duffcloudservices/agent-widget`'s suppression module documents. It is
 * consumed by `PreviewRibbon.vue`. Crucially, NO human-navigable link on a
 * fleet site produces it, so the fleet already emits an accurate
 * "this is a machine" marker everywhere and only the honoring half was missing.
 *
 * `dcs-no-telemetry` is the explicit, self-documenting name for the same
 * intent, so future tooling need not overload a presentational parameter. Its
 * second job is to make the fix self-validating: if a site's gate ever fails,
 * the rows that get recorded carry the parameter and say so.
 */
/** Query parameters that mark a document as an automated capture, not a visit. */
declare const SYNTHETIC_CAPTURE_PARAMS: readonly ["dcs-hide-ribbon", "dcs-no-telemetry"];
/** Reason {@link syntheticCaptureDetected} returned true, for logging and skip reporting. */
type SyntheticCaptureMarker = (typeof SYNTHETIC_CAPTURE_PARAMS)[number];
/**
 * The marker present on this document, or `null` when this looks like a real visit.
 *
 * Reads `window.location.search` on every call rather than caching: a site that
 * calls this after a client-side route change must see the CURRENT URL, and a
 * cached first-load verdict would either leak suppression into a real user's
 * later navigation or miss a capture pass that navigated in-app.
 *
 * Returns `null` on the server — server rendering emits no browser telemetry,
 * and answering "synthetic" there would be a claim this function cannot support.
 */
declare function syntheticCaptureMarker(): SyntheticCaptureMarker | null;
/**
 * Whether this document is an automated capture rather than a visit worth counting.
 *
 * Call this BEFORE loading an analytics SDK, so a capture pass never opens a
 * beacon at all:
 *
 * ```ts
 * if (syntheticCaptureDetected()) return false
 * const { ApplicationInsights } = await import('@microsoft/applicationinsights-web')
 * ```
 */
declare function syntheticCaptureDetected(): boolean;

export { CONVERSION_CAPTURE_VERSION, CONVERSION_INTERACTION_TYPES, type ConversionEvent, type ConversionInstallResult, type ConversionInstallSkipReason, type ConversionInteractionType, type ConversionSink, type ConversionTracker, type ConversionTrackingOptions, DEFAULT_BOOKING_HOSTS, DEFAULT_SOCIAL_HOSTS, type DcsContentFile, type FetchSiteVisitorSessionOptions, GlobalSeoConfig, type InstallConversionCaptureOptions, type MediaCarouselItem, type ReleaseNote, type ReleaseNotesReturn, type ReviewItem, SYNTHETIC_CAPTURE_PARAMS, type SiteVersionReturn, type SiteVisitor, type SiteVisitorSessionResult, type SyntheticCaptureMarker, type TextContentConfig, type TextContentReturn, type UseMediaCarouselConfig, type UseMediaCarouselReturn, type UseReviewContentConfig, type UseReviewContentReturn, UseSeoReturn, type UseSiteVisitorSessionOptions, type UseSiteVisitorSessionReturn, attachConversionSink, classifyHref, conversionOptedOut, createConversionTracker, createSiteSEO, doNotTrackEnabled, fetchSiteVisitorSession, hashTarget, hrefScheme, inFrame, installConversionCapture, installedConversionTracker, isConversionType, isSubmitControl, readSiteVisitorSessionResponse, redactHref, resetConversionCapture, siteVisitorFromSessionPayload, syntheticCaptureDetected, syntheticCaptureMarker, useConversionTracking, useMediaCarousel, useReleaseNotes, useResponsiveImage, useReviewContent, useSEO, useSiteVersion, useSiteVisitorSession, useTextContent };