import{LitElement,type CSSResultGroup,type PropertyDeclaration,type PropertyValues}from'lit';import type{LyraLocaleStrings}from'./localization.js';export interface LyraEmitOptions{
/** Set only for events whose listener may veto an operation before it runs. */
cancelable?:boolean;}export type LyraEventMap=Record<string,Event>;
/**
* Public event-detail view: collection paths and their containing records are recursively readonly.
* Components may construct a mutable local value before `emit()`; listeners always receive the
* detached, frozen runtime snapshot represented by this type.
*/
export type LyraEventDetailSnapshot<Value> =Value extends(...args:never[])=>unknown?Value:Value extends Element|Blob|AbortSignal|Error?Value:Value extends DOMRectReadOnly?Readonly<{x:number;y:number;width:number;height:number;top:number;right:number;bottom:number;left:number;}>:Value extends ReadonlyMap<infer Key,infer Entry> ?ReadonlyMap<LyraEventDetailSnapshot<Key>,LyraEventDetailSnapshot<Entry>>:Value extends ReadonlySet<infer Entry> ?ReadonlySet<LyraEventDetailSnapshot<Entry>>:Value extends readonly unknown[]?{readonly[Key in keyof Value]:LyraEventDetailSnapshot<Value[Key]>;}:Value extends object?{readonly[Key in keyof Value]:LyraEventDetailSnapshot<Value[Key]>;}:Value;
/**
* The trailing `emit()` arguments for one entry of a component's event map.
*
* The map entry is the single source of truth: `CustomEvent<{ id: string }>` makes `detail`
* **required** and typed, while `CustomEvent<null>` (or an optional detail) makes it omittable.
* The runtime normalizes an omitted detail to the platform's canonical `null`. Entries that are
* not `CustomEvent` at all — the native re-emits some components list
* as `input: Event` / `load: Event` — keep the permissive shape, since there is no declared detail
* to check against.
*
* The tuple wrappers (`[Events[K]] extends [CustomEvent<…>]`) stop the conditional from
* distributing over a union-typed map entry, which would otherwise turn one required `detail` into
* a union of argument lists that no call site can satisfy.
*/
export type LyraEmitArgs<Events,K extends keyof Events&string> =[Events[K]]extends[CustomEvent<infer Detail>]?null extends Detail?[detail?:Detail,options?:LyraEmitOptions]:undefined extends Detail?[detail?:Detail,options?:LyraEmitOptions]:[detail:Detail,options?:LyraEmitOptions]:[detail?:unknown,options?:LyraEmitOptions];
/** The `CustomEvent` `emit()` returns for one entry of a component's event map. */
export type LyraEmittedEvent<Events,K extends keyof Events&string> =[Events[K]]extends[CustomEvent<infer Detail>]?CustomEvent<Detail>:CustomEvent<unknown>;
/**
* Internal controller seam for browser-derived state that must not change a hydrating element's
* first render. A symbol keeps the hook out of the component API while allowing shared reactive
* controllers to use the same hydration decision as their host.
*/
export declare const SEED_FIRST_RENDER_STATE:unique symbol;
/** Internal query used by slot-presence controllers while SSR light DOM is unknowable. */
export declare const SLOT_PRESENCE_UNRESOLVED:unique symbol;
/**
* Shared base for every Lyra component. Supplies the design-token layer
* (`--lr-theme-*` theme-input properties with hardcoded `--lr-*` fallbacks).
* RTL is handled by components using CSS logical properties rather than a forced `dir`.
*/
export declare class LyraElement<Events=LyraEventMap>extends LitElement{static styles:CSSResultGroup;
/**
* Reactive public properties whose array/tuple assignments cross the shared immutable ownership
* boundary. Subclasses list only their own collection properties; the descriptor consults the
* concrete constructor at assignment time, after static initialization has completed.
*/
protected static readonly ownedCollectionProperties:readonly PropertyKey[];
/**
* Explicit exceptions whose item identity is itself part of the public contract (for example a
* generic virtual-list row or a command object returned to an imperative callback). The array
* sequence is still bounded, detached, and frozen; only its item references are retained.
*/
protected static readonly identityCollectionProperties:readonly PropertyKey[];
/** Exact opaque-object exceptions; unlike item-identity lists, no sequence claim is made. */
protected static readonly identityCollectionObjectProperties:readonly PropertyKey[];
/** Events whose collection-bearing detail is detached and recursively frozen before dispatch. */
protected static readonly immutableEventDetails:readonly string[];
/** Explicit root detail fields whose object identity is part of an enrolled event contract. */
protected static readonly identityEventDetailProperties:Readonly<Record<string,readonly PropertyKey[]>>;
/** Root event arrays whose sequence is owned while each generic/platform item retains identity. */
protected static readonly identityEventDetailCollectionItems:Readonly<Record<string,readonly PropertyKey[]>>;
/**
* Components commonly forward ARIA host attributes to an internal role and derive localization
* from `lang`/`dir`. These global attributes are not reactive Lit properties, so observe them
* centrally to keep post-render attribute changes in sync.
*
* `super.observedAttributes` is also what finalizes the class (Lit documents this getter as the
* finalization trigger), so it is the first moment every reactive accessor exists — and the one
* `customElements.define()` guarantees. The immutable-collection boundary is therefore installed
* here, right after finalization and before any instance can exist. See
* {@link installOwnedCollectionAccessors} for why it is no longer a `getPropertyDescriptor()`
* override.
*/
static get observedAttributes():string[];
/** Optional locale override. Otherwise the nearest `locale`/`lang` ancestor is used. */
locale:string;private stringsValue;
/**
* Immutable, bounded per-instance message overrides, useful for application-specific wording.
* Assignment snapshots own data-string/plural entries; malformed/accessor entries are omitted
* and later caller mutation cannot alter rendered copy without a new assignment.
*/
get strings():LyraLocaleStrings;set strings(value:LyraLocaleStrings);private stopLocaleSubscription?;private localeSubscriptionNeeded;private lastLocalizedCatalogVersion?;private pendingLoadController?;
/** Callbacks scheduled during the current update cycle, keyed so that two callers with
*  *different* purposes each keep a slot. A single boolean here meant the second caller in a
*  cycle was silently dropped. */
private afterUpdateCallbacks?;
/** Callbacks that came due while detached, replayed on reconnect. */
private deferredAfterUpdate?;private stopInheritedContextObservation?;
/** `undefined` until the first connect decides it, then true only between that connect and the
*  first update of an element whose shadow DOM a server already rendered. See
*  {@link seedFirstRenderState}. */
private hydratingServerShadow?;
/** Browser-only first-render reads coalesced behind one completed hydration update. */
private deferredFirstRenderSeeds?;constructor();
/**
* Lit caches one constructed `CSSStyleSheet` per class, built in this realm's global document.
* A shadow root created in another document (an element adopted into an iframe, or a child an
* adopted element renders later) cannot adopt those sheets: the engine rejects the assignment
* with `NotAllowedError`. Such roots receive inline `<style>` elements instead, the same
* fallback Lit itself takes where constructed stylesheets are unsupported. Every other root
* keeps the shared sheets.
*/
protected createRenderRoot():HTMLElement|DocumentFragment;connectedCallback():void;disconnectedCallback():void;
/**
* Shared adoption hook for components that retain owner-realm resources. Subclasses override
* this callback and call `super.adoptedCallback()` just as they do for connect/disconnect; the
* base invalidation prevents locale or direction state resolved in the former document from
* surviving until an unrelated update.
*/
adoptedCallback():void;
/**
* Every update cycle begins with at least one `requestUpdate()` call, and
* unlike `willUpdate()` (which subclasses routinely override without a
* `super` call) it cannot be bypassed — so this is the one reliable seam
* for dropping the memoized locale/direction. Resolution then happens at
* most once per update cycle no matter how many times a template loop calls
* `localize()`/`effectiveLocale`/`effectiveDirection`.
*/
requestUpdate(name?:PropertyKey,oldValue?:unknown,options?:PropertyDeclaration):void;protected performUpdate():void;protected update(changedProperties:PropertyValues):void;private ensureLocaleSubscription;attributeChangedCallback(name:string,oldValue:string|null,value:string|null):void;
/**
* Runs `seed` before the first render — except while hydrating a server-rendered shadow root,
* where it runs immediately *after* that first render instead.
*
* Several components read something only the browser can answer (their own light-DOM children,
* a browser global such as `EyeDropper`) before their first render, so declaratively slotted
* content never flashes the fallback for a frame. A server renderer can answer neither: Lit's
* server DOM hands an element no children, and installs no browser globals. Seeding
* unconditionally therefore makes the browser's first render disagree with the markup it is
* supposed to be hydrating, which fails the hydration outright and throws the whole
* server-rendered subtree away.
*
* Deferring by one update keeps both paths honest: a browser-only mount still seeds
* synchronously (no flash, unchanged behavior), and a hydrating mount reproduces the server's
* render, then corrects itself on the very next update.
*
* Call it from `willUpdate()` or `connectedCallback()`; it is a no-op once the element has
* updated, so the usual `if (!this.hasUpdated)` guard around the seed is not needed.
*/
protected seedFirstRenderState(seed:()=>void):void;
/**
* Applies browser-derived state immediately, except during a server-shadow hydration's first
* update. Unlike {@link seedFirstRenderState}, this remains active after the initial mount and
* is therefore suitable for `slotchange` and observer callbacks that can arrive while Lit is
* completing hydration.
*/
protected updateBrowserDerivedState(update:()=>void):void;
/** Keeps authored slot content visible in SSR/no-JS output until a browser can resolve it. */
protected renderSlotPresence(present:boolean):boolean;
/** Starts a component-owned cancellable load and aborts the previous one. */
protected beginAbortableLoad():AbortSignal|undefined;
/**
* Runs callbacks once, after the current update completes, coalesced **per `key`**.
*
* Repeated schedules under the same key collapse to the first one — that is the whole point for
* the default `'load'` key, where several property writes in one cycle must produce one fetch
* rather than one per write. But callers with *different* purposes need their own slot: several
* viewers schedule a `load()` and a locale-driven search recompute from the same `updated()`,
* and while this coalesced on a single boolean the second one was silently dropped, leaving
* search results collated for the previous locale. Pass a distinct `key` for distinct work.
*
* Lit still runs the update cycle while detached, so callbacks that come due then are held and
* replayed on reconnect rather than dropped.
*/
protected scheduleAfterUpdate(callback:()=>void,key?:string):void;
/** Resolve a localized message using this component's overrides and locale. */
protected localize(key:string,fallback?:string,values?:Record<string,string|number>):string;
/** The canonical public locale used for message-catalog lookup and propagation to child controls. */
protected get effectiveMessageLocale():string;
/** The canonical, structurally valid locale used for locale-sensitive platform APIs. */
protected get effectiveLocale():string;
/** Explicit alias for helpers whose locale role would otherwise be ambiguous. */
protected get effectiveIntlLocale():string;
/** The effective text direction, including inherited CSS direction. */
protected get effectiveDirection():'ltr'|'rtl';addEventListener<K extends keyof Events&string>(type:K,listener:(this:this,event:Events[K])=>unknown,options?:boolean|AddEventListenerOptions):void;addEventListener<K extends keyof HTMLElementEventMap>(type:K,listener:(this:this,event:HTMLElementEventMap[K])=>unknown,options?:boolean|AddEventListenerOptions):void;addEventListener(type:string,listener:EventListenerOrEventListenerObject,options?:boolean|AddEventListenerOptions):void;removeEventListener<K extends keyof Events&string>(type:K,listener:(this:this,event:Events[K])=>unknown,options?:boolean|EventListenerOptions):void;removeEventListener<K extends keyof HTMLElementEventMap>(type:K,listener:(this:this,event:HTMLElementEventMap[K])=>unknown,options?:boolean|EventListenerOptions):void;removeEventListener(type:string,listener:EventListenerOrEventListenerObject,options?:boolean|EventListenerOptions):void;
/**
* Dispatch a composed, bubbling custom event; notifications are not veto points by default.
*
* `name` and `detail` are both checked against the component's own `Events` map — the same map
* that types {@link addEventListener}. A misspelled event name, or a detail whose shape does not
* match the one the map (and therefore the JSDoc, the manifest and the docs) advertises, is a
* compile error rather than a silently-dispatched event nobody listens for. Components that do
* not declare an event map keep the permissive `LyraEventMap` default.
*/
protected emit<K extends keyof Events&string>(name:K,...args:LyraEmitArgs<Events,K>):LyraEmittedEvent<Events,K>;}