import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import{type LyraSearchChangeDetail,type LyraTextViewerTargetEventMap}from'../../../internal/text-viewer-target.js';import{type LyraIncludeMode}from'./include-resource.js';import type{AnchorResultDetail,TextSelectDetail}from'../document-viewer/anchors.js';export type{LyraIncludeMode}from'./include-resource.js';
/**
* Why a `lr-include-error` fired instead of a successful `lr-load`:
* - `'blocked-url'` — `src` failed the shared `safeFetchUrl()` scheme
*   allowlist; `fetch()` was never called.
* - `'network'` — `fetch()` itself rejected (DNS/CORS/connection failure).
* - `'http'` — the fetch completed but the response was not `ok`.
* - `'missing-sanitizer'` — the fetch succeeded but the optional `dompurify`
*   peer failed to load, so the fragment could not be sanitized.
* - `'resource-too-large'` — the source markup exceeded Include's 2 MiB
*   size cap.
* - `'missing-fragment'` — a requested same-page or remote fragment id was
*   not present after sanitization.
*/
export type LyraIncludeErrorReason='blocked-url'|'network'|'http'|'missing-sanitizer'|'resource-too-large'|'missing-fragment';
/** The detail both spellings of Include's failure notification carry. */
export interface LyraIncludeErrorDetail{status:number;reason:LyraIncludeErrorReason;error?:unknown;}export interface LyraIncludeEventMap extends LyraTextViewerTargetEventMap{'lr-load':CustomEvent<{src:string;}>;'lr-include-error':CustomEvent<LyraIncludeErrorDetail>;
/**
* Shoelace spells this failure `sl-error` where Web Awesome spells it `wa-include-error`, so
* both migrated spellings resolve here. Neither is deprecated.
*/
'lr-error':CustomEvent<LyraIncludeErrorDetail>;'lr-search-change':CustomEvent<LyraSearchChangeDetail>;'lr-anchor-result':CustomEvent<AnchorResultDetail>;'lr-text-select':CustomEvent<TextSelectDetail>;}declare class LyraIncludeBase extends LyraElement<LyraIncludeEventMap>{}declare const LyraInclude_base:Omit<typeof LyraIncludeBase,'prototype'> &(new(...args:ConstructorParameters<typeof LyraIncludeBase>)=>InstanceType<typeof LyraIncludeBase> &import("../../../lyra.js").LyraTextViewerTarget&{renderAnchorLiveRegion():unknown;});
/**
* `<lr-include>` loads an HTML fragment from `src` and transcludes it into
* the page as sanitized light-DOM content, so the fragment participates in
* the surrounding page's CSS cascade exactly like a native server-side
* include — unlike `<lr-html-viewer>`, which renders a foreign document
* inside an isolated preview card.
*
* Loaded markup always passes through the shared DOMPurify-backed
* sanitizer (`loadHtmlSanitizer()`, the same loader `<lr-html-viewer>`
* uses) before it ever touches `innerHTML` — there is no `allow-scripts`
* escape hatch here, unlike the Web Awesome/Shoelace components this element
* otherwise mirrors: their raw, unsanitized injection (with an opt-in to
* actually re-execute embedded `<script>` tags) is incompatible with this
* library's sanitize-always contract, so that option is simply omitted
* rather than shipped as a documented no-op.
* The post-sanitization transclusion profile is network-silent and non-interactive: anchors are
* retained, but only resolvable same-document `#fragment` links survive and those ids are rebased
* per include instance. Other navigation and resource attributes such as `href`, `src`, `srcset`,
* `action`, `ping`, and `poster` are removed, so images never load. Form controls and custom
* elements cannot remain interactive; their wrappers are unwrapped when their ordinary children
* are safe, while elements such as inputs that have no passive content are removed.
* A `src` beginning with `#` clones the matching same-page element's children
* without fetching. A remote URL may carry the same kind of fragment; the
* fragmentless response is byte-capped and sanitized before the target is
* selected. The passive profile covers nested template contents before cache retention as well
* as live insertion; template text and supported fragment selection remain available.
* Cloned ids are rebased per instance so repeated includes do not
* introduce duplicate document ids.
*
* `mode` deliberately defaults to `'same-origin'` rather than the `'cors'`
* default those upstream components document — a same-origin-only fetch
* fails closed unless a consumer explicitly opts in to cross-origin fetching
* with `mode="cors"` (and the remote server cooperates via CORS headers).
* `'no-cors'` is accepted for enum completeness but is rarely useful: it
* always yields an opaque response (`status` `0`, unreadable body), a Fetch
* API platform limitation rather than a bug here.
*
* A failure is announced twice under two names that always carry the same
* detail object and always fire together: `lr-include-error` (Web Awesome
* spells it `wa-include-error`) and `lr-error` (Shoelace spells it
* `sl-error`, and it is the name every other Lyra component uses for a load
* failure). The two upstreams disagree, so both spellings are supported and
* neither is deprecated — listen to whichever one your migration produced.
*
* This is a deliberately bare transclusion primitive with no label/hint/
* error chrome — its interaction idiom (silently swapping light-DOM content)
* is incompatible with a generic label/hint/error frame. Listen for
* `lr-include-error` to build your own error UI, and author meaningful
* fallback content inside `<lr-include>` for when the source never
* succeeds; that fallback (and any previously successful include) is left
* untouched on failure. No live region wraps the slot either: the
* fragment can contain its own landmarks and nested content, and forcing the
* whole host into a live region would re-announce all of it on every load.
*
* No implicit ARIA role and no computed accessible name are applied around
* the transcluded content — the fragment's own semantics (headings,
* landmarks, its own `role`/`aria-*` attributes) surface directly and
* unmodified, exactly as they would in a native include. The host carries an
* explicit `aria-busy` state: `"true"` while a source is being loaded and
* sanitized, and
* `"false"` otherwise.
*
* @customElement lr-include
* @slot - Fallback content shown until (or unless) a fetch succeeds; overwritten with the sanitized fragment once one does.
* @event lr-load - The source fragment was sanitized and written into the light DOM.
* @event lr-include-error - Loading, selecting, or sanitizing the fragment failed; see `LyraIncludeErrorReason` for `detail.reason`. Mirrors Web Awesome's `wa-include-error`.
* @event lr-error - The same failure under the spelling Shoelace's `sl-error` migrates to; it always fires alongside `lr-include-error` with the identical detail object. Neither spelling is deprecated.
* @event {CustomEvent<LyraSearchChangeDetail>} lr-search-change -
*   Fired whenever included-content search state changes. `matchCountExact=false` makes the
*   retained count a lower bound. Bubbling, composed, and non-cancelable.
* @event {CustomEvent<AnchorResultDetail>} lr-anchor-result - Fired after an `anchor` assignment or
*   `scrollToAnchor()` call is applied. `detail: { found: boolean }`. Bubbling, composed, and
*   non-cancelable.
* @event {CustomEvent<TextSelectDetail>} lr-text-select - Fired after a selection ends inside the
*   included content. `detail: { text: string; anchor: LyraAnchor | null; rects: DOMRect[] }`.
*   Bubbling, composed, and non-cancelable.
* @csspart base - The non-layout (`display: contents`) wrapper around the default slot.
* @status stable
* @since 4.0.0
*/
export declare class LyraInclude extends LyraInclude_base{static styles:import("lit").CSSResultGroup[];
/**
* HTML fragment source. Remote URLs are validated through the shared
* `safeFetchUrl()` allowlist (`http:`, `https:`, `blob:`, `data:`). Use
* `#id` to clone a same-page source's children or `/partial.html#id` to
* select children from a sanitized remote document.
* An empty/falsy value is a no-op: no fetch, no events, existing content
* untouched.
*/
src:string;
/**
* Forwarded to `fetch(url, { mode })`. Deliberately defaults to
* `'same-origin'` rather than the `'cors'` default documented by the
* Web Awesome/Shoelace components this element otherwise mirrors — a
* consumer opts in to cross-origin fetching explicitly. An invalid/typo'd
* attribute value is defensively normalized back to `'same-origin'`
* rather than letting `fetch()` throw synchronously for an invalid
* `RequestMode`.
*/
private _mode;get mode():LyraIncludeMode;set mode(next:LyraIncludeMode);
/** Shares bounded, sanitized remote resources with matching Include requests. Set to false to
*  opt out of both retained values and in-flight deduplication. */
cache:boolean;
/** Shared text search and anchor-target API for sanitized light-DOM includes. */
search(query:string):Promise<number>;searchNext():Promise<boolean>;searchPrevious():Promise<boolean>;clearSearch():void;private generation;private resourceLease?;private readonly clonePrefix;protected textContentRoot():Element|null;protected updated(changed:PropertyValues):void;connectedCallback():void;disconnectedCallback():void;
/** Invalidates this remote source's retained value and loads it again. Same-page fragments are
*  simply cloned again from their current source DOM. */
reload():Promise<void>;private get effectiveMode();private resolveSource;private releaseResourceLease;private sanitizeSamePage;private fragmentFromSanitized;private rebaseFragmentIds;private load;private fail;
/**
* Announces one failure under both supported spellings. The two upstreams disagree on the name
* (`wa-include-error` vs `sl-error`), so a migrated listener finds whichever it was written
* against; the *same* detail object is dispatched to both so a consumer reading `detail.reason`
* cannot observe a difference between them.
*/
private emitError;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-include':LyraInclude;}}