import{type PropertyValues,type TemplateResult}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import{type LyraClipboardWriteFailure,type LyraClipboardWriteSuccess}from'../../../internal/clipboard.js';import type{LyraToolbarAction}from'../../conversation/message-actions/toolbar-actions.js';export type{LyraClipboardWriteFailure,LyraClipboardWriteOutcome,LyraClipboardWriteSuccess,LyraCopyErrorReason,}from'../../../internal/clipboard.js';
/** When the copy button's tooltip is available. */
export type LyraCopyButtonTooltip='full'|'copy'|'none';
/** Side on which the copy button's tooltip appears. */
export type LyraCopyButtonTooltipPlacement='top'|'right'|'bottom'|'left';export interface LyraCopyButtonEventMap{'lr-copy':CustomEvent<LyraClipboardWriteSuccess>;'lr-error':CustomEvent<null>;'lr-toolbar-actions-change':Event;'lr-copy-error':CustomEvent<LyraClipboardWriteFailure>;}
/**
* `<lr-copy-button>` — a standalone icon-only copy-to-clipboard affordance for a plain
* single/multi-line text value in a layout the consumer controls (e.g. absolutely positioned in
* the corner of an `lr-textarea` or a read-only output field). Unlike `lr-code-block`'s or
* `lr-json-viewer`'s own built-in copy buttons, this takes no positioning opinion of its own and
* has no code/JSON content model to adopt just to reuse the copy affordance.
*
* When `from` is set it takes precedence over `value`: an element id copies `textContent`,
* `id[attribute]` copies an attribute, and `id.property` copies a property. An empty value, a
* missing source, or a rejected Clipboard API call enters the error state. Native `dir` and
* `lang` remain inherited global attributes. Renderer bookkeeping and manifest-inferred form
* metadata are deliberately not component properties; this control is not form-associated.
*
* The confirmation state is only entered once the clipboard write actually resolves; a rejected
* write (denied permission, insecure context, unfocused document) renders a distinct failure
* glyph, announces itself through the live region, and emits both `lr-error` and the retained,
* detailed `lr-copy-error` alias.
*
* This trigger has no `size` property of its own: it composes `<lr-icon-button>`, so the built-in
* trigger's hit area is that component's shared `--lr-icon-button-size` floor (2.5rem/40px), same
* as everywhere else in the library. For a dense action row (e.g. several copy buttons packed into
* a toolbar) where 40px is more than the layout can afford, lower `--lr-icon-button-size-scope`
* (the subtree-scoped input) or `--lr-theme-icon-button-size` (the application-wide one) -- NOT
* `--lr-icon-button-size` itself, which every `LyraElement` re-declares on its own `:host` and so
* never reaches a composed child (`internal/tokens.test.ts` proves this) -- on this element or
* any ancestor of it; `::part(base__control)` also reaches the same composed native control
* directly for a one-off override. Either way the shrink is local to the elements it targets, not
* a library-wide floor change. A coarse-pointer/no-hover safety net (`internal/tokens.styles.ts`'s
* `baseTokens`) then floors the rendered hit area back at 2.75rem/44px regardless of how far the
* dense-row override lowered it, so an intentionally cramped desktop toolbar is still comfortably
* tappable the moment the pointer reaching it is a finger rather than a mouse.
*
* @customElement lr-copy-button
* @slot - A custom trigger. When present, it replaces the built-in icon button.
* @slot copy-icon - Resting copy icon for the built-in button.
* @slot success-icon - Confirmation icon for the built-in button.
* @slot error-icon - Failure icon for the built-in button.
* @event lr-copy - Clipboard writing fulfilled. The frozen shared outcome detail is
*   `{ ok: true, text }`. Failed writes emit `lr-copy-error` instead.
* @event lr-error - The source could not be resolved or clipboard writing failed. A bubbling,
*   composed, non-cancelable `CustomEvent` with no detail, matching the mapped notification.
* @event lr-copy-error - Source resolution or clipboard writing failed. The frozen detail is
*   `{ ok: false, text, reason, error }`, where
*   `reason` is `'unsupported' | 'denied' | 'failed'` and `error` is the platform error (a
*   `DOMException` for a real rejection) or a component-created source error. Retained as a
*   richer Lyra compatibility alias for `lr-error`.
* @event lr-toolbar-actions-change - The logical action exposed to a parent toolbar changed its
*   disabled state or backing trigger. Bubbling, composed, and non-cancelable.
* @csspart base - The built-in trigger, which is a composed `<lr-icon-button>` rather than this
*   component's own `<button>` as of 16.0.0. It still owns the accessible name, the activation and
*   every part token below; its paint (background, radius, hover/press mixes, focus ring, hit-area
*   floor) now comes from `<lr-icon-button>`'s own `--lr-icon-button-*` contract, so a rule that
*   set `background`/`border`/`padding` through `::part(base)` must move to `base__control` or to
*   the token.
* @csspart button - Mapped alias for `base` on the same composed trigger.
* @csspart base__control - The composed `<lr-icon-button>`'s own native control, forwarded so the
*   painted surface stays reachable across the extra shadow boundary.
* @csspart base-success - The trigger while the copied confirmation is showing.
* @csspart base-error - The trigger while the failure state is showing.
* @csspart copy-icon - The resting copy glyph.
* @csspart success-icon - The confirmation glyph.
* @csspart error-icon - The failure glyph.
* @csspart feedback - Visually hidden, `aria-hidden` mirror of the outcome text. The announcement
* uses the shared light-DOM polite region because live regions inside shadow roots are not reliable;
* style the composed tooltip through its `tooltip__*` parts.
* @csspart tooltip__base - The nested tooltip's base wrapper.
* @csspart tooltip__base__popup - The nested tooltip's popup wrapper.
* @csspart tooltip__base__arrow - The nested tooltip's arrow.
* @csspart tooltip__body - The nested tooltip's content wrapper.
* @cssprop [--error-color=var(--lr-color-danger)] - Error-state icon color.
* @cssprop [--success-color=var(--lr-color-success)] - Success-state icon color.
* @cssstate success - The clipboard write completed.
* @cssstate error - Source resolution or clipboard writing failed.
* @status stable
* @since 4.0.0
*/
export declare class LyraCopyButton extends LyraElement<LyraCopyButtonEventMap>{static styles:import("lit").CSSResultGroup[];
/** The plain text to copy. */
value:string;
/** Id-based source expression. Takes precedence over `value`; supports `id`, `id[attr]`, and
* `id.property`. */
from:string;
/** Accessible name and resting tooltip text. Empty uses the localized Copy string. */
copyLabel:string;
/** Confirmation accessible name and tooltip text. Empty uses the localized Copied string. */
successLabel:string;
/** Failure accessible name and tooltip text. Empty uses the localized failure string. */
errorLabel:string;
/** Tooltip behavior: normal hover/focus plus feedback, feedback only, or disabled. */
tooltip:LyraCopyButtonTooltip;
/** Side on which the tooltip appears. */
tooltipPlacement:LyraCopyButtonTooltipPlacement;
/** Use fixed positioning for the tooltip so it can escape clipped containers. */
hoist:boolean;
/** Accessible name forwarded from the host to the internal button. When unset or blank, the
* localized Copy/Copied/failure state provides the name so the icon-only trigger never becomes
* unnamed. */
accessibleLabel:string|null;
/** Prevent activation and remove the internal button from the tab order. */
disabled:boolean;
/** How long, in milliseconds, the copied confirmation or failure state remains visible. */
feedbackDuration:number;private status;
/** Handle on the shared light-DOM live region outcomes actually announce through -- a region
*  rendered inside this shadow root is not reliably announced (JAWS with Firefox ignores one
*  outright), so `[part="feedback"]` is only an `aria-hidden` mirror. */
private sink?;private hasCustomTrigger;
/** Whether the default slot's assignment has been read at least once, and (when it has) the
*  custom-trigger element that read found -- `undefined` for "no custom trigger", distinct from
*  "never collected". Lets `onDefaultSlotChangeFromSlot()` identity-diff a later call against
*  the previous one, so a real browser's initial `slotchange` landing on top of `firstUpdated()`'s
*  own collection (see below) for the exact same assignment is a silent no-op rather than a
*  duplicate `lr-toolbar-actions-change`. */
private triggerCollected;private lastObservedTrigger;private buttonEl?;private defaultSlot?;private readonly internals;private readonly toolbarAction;constructor();private copyTimer?;
/** Bumped by every activation, every source change, and every disconnect, so an in-flight
*  clipboard promise that settles late can tell whether its outcome still describes the text
*  the button is currently showing. */
private copyGeneration;protected willUpdate(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;protected firstUpdated(changed:PropertyValues):void;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;private cancelFeedbackTimer;private resetFeedback;private setStatus;private customTrigger;private activeTrigger;
/** The built-in trigger's OWN logical action. A roving toolbar has to lease the tab stop of the
*  native control inside the composed `<lr-icon-button>`: writing `tabindex` on that custom
*  element host neither adds nor removes its shadow-internal button's stop, so a host-level lease
*  would leave every copy button permanently tabbable. `undefined` while a consumer's own custom
*  trigger is in use -- that element IS the native control, and the lease below applies to it
*  directly. */
private composedTriggerAction;private createToolbarAction;
/** The stable logical copy action exposed to an enclosing composite toolbar. Its optional
*  release method restores an untouched authored trigger tabindex when the parent leaves. */
getToolbarActions():readonly LyraToolbarAction[];focus(options?:FocusOptions):void;blur():void;
/** Activates the native button, matching the host focus/blur forwarding contract. */
click():void;private sourceById;private resolveCopyText;private showStatus;private reportFailure;private copy;private isCurrentCopy;private onClick;private onDefaultSlotChange;
/**
* Reads the default slot's currently assigned elements and updates `hasCustomTrigger` --
* wired as the `slotchange` handler (via `onDefaultSlotChange`) for every later mutation, and
* called once more from `firstUpdated()` (see `collectInitialSlotAssignment`) to cover an
* environment, or a real-browser timing race, where the slot's initial assignment never fires
* `slotchange`. Idempotent over an unchanged assignment: `lastObservedTrigger` is the identity
* of the trigger element the previous call resolved (or `undefined` for "no custom trigger"), so
* a second call that resolves the exact same element finds nothing new and is a silent no-op.
*/
private onDefaultSlotChangeFromSlot;private onCustomTriggerClick;private stopInternalTooltipEvent;private statusLabel;private renderIcon;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-copy-button':LyraCopyButton;}}