//! Defines the core Document Object Model (DOM) structures.

//!

//! This module is responsible for representing the UI as a tree of nodes,

//! similar to the HTML DOM. It includes definitions for node types, event handling

//! and the main `Dom` and `CompactDom` structures.

#[cfg(not(feature = "std"))]

use alloc::string::ToString;

use alloc::{boxed::Box, collections::btree_map::BTreeMap, string::String, vec::Vec};

use core::{

    fmt,

    hash::{Hash, Hasher},

    iter::FromIterator,

    mem,

    sync::atomic::{AtomicUsize, Ordering},

};

use azul_css::{

    css::{BoxOrStatic, Css, NodeTypeTag},

    codegen::format::GetHash,

    props::{

        basic::{FloatValue, FontRef},

        layout::{LayoutDisplay, LayoutFloat, LayoutPosition},

        property::CssProperty,

    },

    AzString, OptionString,

};

// Re-exported from a11y.rs and events.rs

pub use crate::a11y::*;

pub use crate::events::{

    ApplicationEventFilter, ComponentEventFilter, EventFilter, FocusEventFilter, HoverEventFilter,

    WindowEventFilter,

};

pub use crate::id::{Node, NodeHierarchy, NodeId};

use crate::{

    callbacks::{

        CoreCallback, CoreCallbackData, CoreCallbackDataVec, CoreCallbackType, VirtualViewCallback,

        VirtualViewCallbackType,

    },

    geom::LogicalPosition,

    id::{NodeDataContainer, NodeDataContainerRef, NodeDataContainerRefMut},

    menu::Menu,

    prop_cache::{CssPropertyCache, CssPropertyCachePtr},

    refany::{OptionRefAny, RefAny},

    resources::{

        image_ref_get_hash, CoreImageCallback, ImageMask, ImageRef, ImageRefHash, RendererResources,

    },

    styled_dom::{

        CompactDom, NodeHierarchyItemId, StyleFontFamilyHash, StyledDom, StyledNode,

        StyledNodeState,

    },

    window::OptionVirtualKeyCodeCombo,

};

pub use azul_css::dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec};

static TAG_ID: AtomicUsize = AtomicUsize::new(1);

/// Strongly-typed input element types for HTML `<input>` elements.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub enum InputType {

    /// Text input (default)

    Text,

    /// Button

    Button,

    /// Checkbox

    Checkbox,

    /// Color picker

    Color,

    /// Date picker

    Date,

    /// Date and time picker

    Datetime,

    /// Date and time picker (local)

    DatetimeLocal,

    /// Email address input

    Email,

    /// File upload

    File,

    /// Hidden input

    Hidden,

    /// Image button

    Image,

    /// Month picker

    Month,

    /// Number input

    Number,

    /// Password input

    Password,

    /// Radio button

    Radio,

    /// Range slider

    Range,

    /// Reset button

    Reset,

    /// Search input

    Search,

    /// Submit button

    Submit,

    /// Telephone number input

    Tel,

    /// Time picker

    Time,

    /// URL input

    Url,

    /// Week picker

    Week,

}

impl InputType {

    /// Returns the HTML attribute value for this input type

        }

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub struct TagId {

    pub inner: u64,

}

impl ::core::fmt::Display for TagId {

}

impl_option!(

    TagId,

    OptionTagId,

    [Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash]

);

impl TagId {

    /// Creates a new, unique hit-testing tag ID.

    /// Wraps around to 1 on overflow (0 is reserved for "no tag").

    ///

    /// AUDIT: the wrap is only reachable after 2^64 - 1 allocations (a process

    /// running long enough to exhaust the counter is not realistic), but note

    /// that on wrap the freshly-issued id could theoretically collide with a

    /// still-live tag from very early in the process. This is left as a

    /// documented, non-triggerable limitation rather than adding a live-tag

    /// registry to detect collisions on every allocation. AUDIT-TODO: revisit

    /// if `TagId` is ever narrowed below 64 bits.

        loop {

        }

}

/// Same as the `TagId`, but only for scrollable nodes.

/// This provides a typed distinction for tags associated with scrolling containers.

#[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]

#[repr(C)]

pub struct ScrollTagId {

    pub inner: TagId,

}

impl ::core::fmt::Display for ScrollTagId {

}

impl ::core::fmt::Debug for ScrollTagId {

}

impl ScrollTagId {

    /// Creates a new, unique scroll tag ID. Note that this should not

    /// be used for identifying nodes, use the `DomNodeHash` instead.

}

/// Orientation of a scrollbar.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub enum ScrollbarOrientation {

    Horizontal,

    Vertical,

}

/// Calculated hash of a DOM node, used for identifying identical DOM

/// nodes across frames for efficient diffing and state preservation.

#[derive(Copy, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]

#[repr(C)]

pub struct DomNodeHash {

    pub inner: u64,

}

impl ::core::fmt::Debug for DomNodeHash {

}

/// List of core DOM node types built into `azul`.

/// This enum defines the building blocks of the UI, similar to HTML tags.

#[derive(Debug, Clone, PartialEq, Hash, Eq, PartialOrd, Ord)]

#[repr(C, u8)]

pub enum NodeType {

    // Root and container elements

    /// Root HTML element.

    Html,

    /// Document head (metadata container).

    Head,

    /// Root element of the document body.

    Body,

    /// Generic block-level container.

    Div,

    /// Paragraph.

    P,

    /// Article content.

    Article,

    /// Section of a document.

    Section,

    /// Navigation links.

    Nav,

    /// Sidebar/tangential content.

    Aside,

    /// Header section.

    Header,

    /// Footer section.

    Footer,

    /// Main content.

    Main,

    /// Figure with optional caption.

    Figure,

    /// Caption for figure element.

    FigCaption,

    /// Headings.

    H1,

    H2,

    H3,

    H4,

    H5,

    H6,

    /// Line break.

    Br,

    /// Horizontal rule.

    Hr,

    /// Preformatted text.

    Pre,

    /// Block quote.

    BlockQuote,

    /// Address.

    Address,

    /// Details disclosure widget.

    Details,

    /// Summary for details element.

    Summary,

    /// Dialog box or window.

    Dialog,

    // List elements

    /// Unordered list.

    Ul,

    /// Ordered list.

    Ol,

    /// List item.

    Li,

    /// Definition list.

    Dl,

    /// Definition term.

    Dt,

    /// Definition description.

    Dd,

    /// Menu list.

    Menu,

    /// Menu item.

    MenuItem,

    /// Directory list (deprecated).

    Dir,

    // Table elements

    /// Table container.

    Table,

    /// Table caption.

    Caption,

    /// Table header.

    THead,

    /// Table body.

    TBody,

    /// Table footer.

    TFoot,

    /// Table row.

    Tr,

    /// Table header cell.

    Th,

    /// Table data cell.

    Td,

    /// Table column group.

    ColGroup,

    /// Table column.

    Col,

    // Form elements

    /// Form container.

    Form,

    /// Form fieldset.

    FieldSet,

    /// Fieldset legend.

    Legend,

    /// Label for form controls.

    Label,

    /// Input control.

    Input,

    /// Button control.

    Button,

    /// Select dropdown.

    Select,

    /// Option group.

    OptGroup,

    /// Select option.

    SelectOption,

    /// Multiline text input.

    TextArea,

    /// Form output element.

    Output,

    /// Progress indicator.

    Progress,

    /// Scalar measurement within a known range.

    Meter,

    /// List of predefined options for input.

    DataList,

    // Inline elements

    /// Generic inline container.

    Span,

    /// Anchor/hyperlink.

    A,

    /// Emphasized text.

    Em,

    /// Strongly emphasized text.

    Strong,

    /// Bold text (deprecated - use `Dom::create_strong()` for semantic importance).

    B,

    /// Italic text (deprecated - use `Dom::create_em()` for emphasis or `Dom::create_cite()` for citations).

    I,

    /// Underline text.

    U,

    /// Strikethrough text.

    S,

    /// Marked/highlighted text.

    Mark,

    /// Deleted text.

    Del,

    /// Inserted text.

    Ins,

    /// Code.

    Code,

    /// Sample output.

    Samp,

    /// Keyboard input.

    Kbd,

    /// Variable.

    Var,

    /// Citation.

    Cite,

    /// Defining instance of a term.

    Dfn,

    /// Abbreviation.

    Abbr,

    /// Acronym.

    Acronym,

    /// Inline quotation.

    Q,

    /// Date/time.

    Time,

    /// Subscript.

    Sub,

    /// Superscript.

    Sup,

    /// Small text (deprecated - use CSS `font-size` instead).

    Small,

    /// Big text (deprecated - use CSS `font-size` instead).

    Big,

    /// Bi-directional override.

    Bdo,

    /// Bi-directional isolate.

    Bdi,

    /// Word break opportunity.

    Wbr,

    /// Ruby annotation.

    Ruby,

    /// Ruby text.

    Rt,

    /// Ruby text container.

    Rtc,

    /// Ruby parenthesis.

    Rp,

    /// Machine-readable data.

    Data,

    // Embedded content

    /// Canvas for graphics.

    Canvas,

    /// Embedded object.

    Object,

    /// Embedded object parameter.

    Param,

    /// External resource embed.

    Embed,

    /// Audio content.

    Audio,

    /// Video content.

    Video,

    /// Media source.

    Source,

    /// Text track for media.

    Track,

    /// Image map.

    Map,

    /// Image map area.

    Area,

    // SVG elements — container

    /// SVG `<svg>` root graphics container.

    Svg,

    /// SVG `<g>` group element.

    SvgG,

    /// SVG `<defs>` — reusable definitions (not rendered directly).

    SvgDefs,

    /// SVG `<symbol>` — like defs but with its own viewBox.

    SvgSymbol,

    /// SVG `<use>` — references and instantiates a defs element.

    SvgUse,

    /// SVG `<switch>` — conditional processing.

    SvgSwitch,

    // SVG elements — shape

    /// SVG `<path>` element.

    SvgPath,

    /// SVG `<circle>` element.

    SvgCircle,

    /// SVG `<rect>` element.

    SvgRect,

    /// SVG `<ellipse>` element.

    SvgEllipse,

    /// SVG `<line>` element.

    SvgLine,

    /// SVG `<polygon>` element.

    SvgPolygon,

    /// SVG `<polyline>` element.

    SvgPolyline,

    // SVG elements — text

    /// SVG `<text>` element.

    SvgText(AzString),

    /// SVG `<tspan>` element.

    SvgTspan,

    /// SVG `<textPath>` element.

    SvgTextPath,

    // SVG elements — paint servers

    /// SVG `<linearGradient>` element.

    SvgLinearGradient,

    /// SVG `<radialGradient>` element.

    SvgRadialGradient,

    /// SVG `<stop>` gradient stop element.

    SvgStop,

    /// SVG `<pattern>` element.

    SvgPattern,

    // SVG elements — clipping / masking

    /// SVG `<clipPath>` element.

    SvgClipPathElement,

    /// SVG `<mask>` element.

    SvgMask,

    // SVG elements — filter

    /// SVG `<filter>` container element.

    SvgFilter,

    /// SVG `<feBlend>`.

    SvgFeBlend,

    /// SVG `<feColorMatrix>`.

    SvgFeColorMatrix,

    /// SVG `<feComponentTransfer>`.

    SvgFeComponentTransfer,

    /// SVG `<feComposite>`.

    SvgFeComposite,

    /// SVG `<feConvolveMatrix>`.

    SvgFeConvolveMatrix,

    /// SVG `<feDiffuseLighting>`.

    SvgFeDiffuseLighting,

    /// SVG `<feDisplacementMap>`.

    SvgFeDisplacementMap,

    /// SVG `<feDistantLight>`.

    SvgFeDistantLight,

    /// SVG `<feDropShadow>`.

    SvgFeDropShadow,

    /// SVG `<feFlood>`.

    SvgFeFlood,

    /// SVG `<feFuncR>`.

    SvgFeFuncR,

    /// SVG `<feFuncG>`.

    SvgFeFuncG,

    /// SVG `<feFuncB>`.

    SvgFeFuncB,

    /// SVG `<feFuncA>`.

    SvgFeFuncA,

    /// SVG `<feGaussianBlur>`.

    SvgFeGaussianBlur,

    /// SVG `<feImage>`.

    SvgFeImage,

    /// SVG `<feMerge>`.

    SvgFeMerge,

    /// SVG `<feMergeNode>`.

    SvgFeMergeNode,

    /// SVG `<feMorphology>`.

    SvgFeMorphology,

    /// SVG `<feOffset>`.

    SvgFeOffset,

    /// SVG `<fePointLight>`.

    SvgFePointLight,

    /// SVG `<feSpecularLighting>`.

    SvgFeSpecularLighting,

    /// SVG `<feSpotLight>`.

    SvgFeSpotLight,

    /// SVG `<feTile>`.

    SvgFeTile,

    /// SVG `<feTurbulence>`.

    SvgFeTurbulence,

    // SVG elements — marker / image / foreign

    /// SVG `<marker>` element (not the CSS `::marker` pseudo-element).

    SvgMarker,

    /// SVG `<image>` element (embedded raster image in SVG).

    SvgImage(ImageRef),

    /// SVG `<foreignObject>` element.

    SvgForeignObject,

    // SVG elements — descriptive / structural

    /// SVG `<title>` element (distinct from HTML `<title>`).

    SvgTitle,

    /// SVG `<desc>` element.

    SvgDesc,

    /// SVG `<metadata>` element.

    SvgMetadata,

    /// SVG `<a>` hyperlink element (distinct from HTML `<a>`).

    SvgA,

    /// SVG `<view>` element.

    SvgView,

    /// SVG `<style>` element (distinct from HTML `<style>`).

    SvgStyle,

    /// SVG `<script>` element (distinct from HTML `<script>`).

    SvgScript,

    // SVG elements — animation

    /// SVG `<animate>` element.

    SvgAnimate,

    /// SVG `<animateMotion>` element.

    SvgAnimateMotion,

    /// SVG `<animateTransform>` element.

    SvgAnimateTransform,

    /// SVG `<set>` element.

    SvgSet,

    /// SVG `<mpath>` element.

    SvgMpath,

    // Metadata elements

    /// Document title.

    Title,

    /// Metadata.

    Meta,

    /// External resource link.

    Link,

    /// Embedded or referenced script.

    Script,

    /// Style information.

    Style,

    /// Base URL for relative URLs.

    Base,

    // Pseudo-elements (transformed into real elements)

    /// `::before` pseudo-element.

    Before,

    /// `::after` pseudo-element.

    After,

    /// `::marker` pseudo-element.

    Marker,

    /// `::placeholder` pseudo-element.

    Placeholder,

    // Special content types

    /// Text content, `::text`.

    /// Uses `BoxOrStatic` to keep `NodeType` small (~16B vs ~72B with inline `AzString`)

    /// and to allow static text references in the future.

    Text(BoxOrStatic<AzString>),

    /// Image element, `::image`.

    /// Uses `BoxOrStatic` to keep `NodeType` small.

    Image(BoxOrStatic<ImageRef>),

    /// `VirtualView` (embedded content) - payload stored in `NodeDataExt.virtual_view`

    VirtualView,

    /// Icon element - resolved to actual content by `IconProvider`.

    /// The string is the icon name (e.g., "home", "settings", "search").

    /// Uses `BoxOrStatic` to keep `NodeType` small.

    Icon(BoxOrStatic<AzString>),

    /// Invisible probe node that signals "this subtree needs the user's

    /// GPS / network location". Zero-size in layout, skipped in the

    /// display list. The `GeolocationManager` walks the styled DOM for

    /// these at end-of-layout and starts / stops the matching native

    /// subscription. See `SUPER_PLAN_2.md` §1.5 + research/08.

    GeolocationProbe(crate::geolocation::GeolocationProbeConfig),

    /// THE canonical page-break element: an empty block the UA styles with

    /// `break-before: page`. The pagination estimator and a screen DOM

    /// treat it identically; sibling margins collapse through it, so

    /// materializing an estimated break does not move content. XML tag:

    /// `<pagebreak/>`; constructor: [`Dom::create_page_break`].

    PageBreak,

}

/// Type alias: `BoxOrStatic<ImageRef>` — used by `NodeType::Image` for FFI monomorphization.

pub type BoxOrStaticImageRef = BoxOrStatic<ImageRef>;

impl_option!(NodeType, OptionNodeType, copy = false, [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

impl NodeType {

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

        use self::NodeType::{Html, Head, Body, Div, P, Article, Section, Nav, Aside, Header, Footer, Main, Figure, FigCaption, H1, H2, H3, H4, H5, H6, Br, Hr, Pre, BlockQuote, Address, Details, Summary, Dialog, Ul, Ol, Li, Dl, Dt, Dd, Menu, MenuItem, Dir, Table, Caption, THead, TBody, TFoot, Tr, Th, Td, ColGroup, Col, Form, FieldSet, Legend, Label, Input, Button, Select, OptGroup, SelectOption, TextArea, Output, Progress, Meter, DataList, Span, A, Em, Strong, B, I, U, S, Mark, Del, Ins, Code, Samp, Kbd, Var, Cite, Dfn, Abbr, Acronym, Q, Time, Sub, Sup, Small, Big, Bdo, Bdi, Wbr, Ruby, Rt, Rtc, Rp, Data, Canvas, Object, Param, Embed, Audio, Video, Source, Track, Map, Area, Svg, SvgG, SvgDefs, SvgSymbol, SvgUse, SvgSwitch, SvgPath, SvgCircle, SvgRect, SvgEllipse, SvgLine, SvgPolygon, SvgPolyline, SvgText, SvgTspan, SvgTextPath, SvgLinearGradient, SvgRadialGradient, SvgStop, SvgPattern, SvgClipPathElement, SvgMask, SvgFilter, SvgFeBlend, SvgFeColorMatrix, SvgFeComponentTransfer, SvgFeComposite, SvgFeConvolveMatrix, SvgFeDiffuseLighting, SvgFeDisplacementMap, SvgFeDistantLight, SvgFeDropShadow, SvgFeFlood, SvgFeFuncR, SvgFeFuncG, SvgFeFuncB, SvgFeFuncA, SvgFeGaussianBlur, SvgFeImage, SvgFeMerge, SvgFeMergeNode, SvgFeMorphology, SvgFeOffset, SvgFePointLight, SvgFeSpecularLighting, SvgFeSpotLight, SvgFeTile, SvgFeTurbulence, SvgMarker, SvgImage, SvgForeignObject, SvgTitle, SvgDesc, SvgMetadata, SvgA, SvgView, SvgStyle, SvgScript, SvgAnimate, SvgAnimateMotion, SvgAnimateTransform, SvgSet, SvgMpath, Title, Meta, Link, Script, Style, Base, Before, After, Marker, Placeholder, Text, Image, VirtualView, Icon, GeolocationProbe};

            // SVG container

            // SVG shape

            // SVG text

            // SVG paint

            // SVG clip/mask

            // SVG filter

            // SVG marker/image/foreign

            // SVG descriptive/structural

            // SVG animation

            // HTML metadata

        }

        use self::NodeType::{Text, Image, VirtualView, Icon, GeolocationProbe};

        }

    /// Returns the `NodeTypeTag` for CSS selector matching.

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

            // SVG — all variants map 1:1 to NodeTypeTag

            // HTML metadata

        }

    /// Returns whether this node type is a semantic HTML element that should

    /// automatically generate an accessibility tree node.

    ///

    /// These are elements with inherent semantic meaning that assistive

    /// technologies should be aware of, even without explicit ARIA attributes.

            Self::Button

                | Self::Input

                | Self::TextArea

                | Self::Select

                | Self::A

                | Self::H1

                | Self::H2

                | Self::H3

                | Self::H4

                | Self::H5

                | Self::H6

                | Self::Article

                | Self::Section

                | Self::Nav

                | Self::Main

                | Self::Header

                | Self::Footer

                | Self::Aside

        )

}

/// Represents the CSS formatting context for an element

#[derive(Clone, Copy, PartialEq, Eq)]

// [g147f az-web-lift] `#[repr(C, u8)]` forces an explicit u8 discriminant at offset 0 instead of letting

// Rust niche-pack the other variants' discriminants into the payload variants' (Block{bool}/Float/OutOfFlow)

// invalid byte values. The remill lift mis-decodes that niche encoding: `Block` (byte 0/1) reads correctly

// but `Inline` (a niche value) reads as garbage → `match` falls to `_` → nested <div>text</div> dispatches

// to layout_bfc instead of layout_ifc and its text never lays out (g147 root cause). Same fix pattern as the

// text3 enums (InlineContent/LogicalItem/ShapedItem/FontStack/LayoutError). Harmless + correct for native.

#[repr(C, u8)]

// +spec:display-property:844893 - block-level box establishing a new formatting context (BFC) modeled here

pub enum FormattingContext {

    /// Block-level formatting context

    Block {

        /// Whether this element establishes a new block formatting context

        establishes_new_context: bool,

    },

    /// Inline-level formatting context

    Inline,

    /// Inline-block (participates in an IFC but creates a BFC)

    InlineBlock,

    /// Flex formatting context

    Flex,

    /// Float (left or right)

    Float(LayoutFloat),

    /// Absolutely positioned (out of flow)

    OutOfFlow(LayoutPosition),

    /// Table formatting context (container)

    Table,

    /// Table row group formatting context (thead, tbody, tfoot)

    TableRowGroup,

    /// Table row formatting context

    TableRow,

    /// Table cell formatting context (td, th)

    TableCell,

    /// Table column group formatting context

    TableColumnGroup,

    /// Table caption formatting context

    TableCaption,

    /// Grid formatting context

    Grid,

    /// display:contents - element generates no box, children promoted to parent

    Contents,

    /// No formatting context (display: none)

    None,

}

impl fmt::Debug for FormattingContext {

            Self::Block {

            ),

            }

        }

}

impl Default for FormattingContext {

}

/// Defines the type of event that can trigger a callback action.

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

#[repr(C)]

pub enum On {

    /// Mouse cursor is hovering over the element.

    MouseOver,

    /// Mouse cursor has is over element and is pressed

    /// (not good for "click" events - use `MouseUp` instead).

    MouseDown,

    /// (Specialization of `MouseDown`). Fires only if the left mouse button

    /// has been pressed while cursor was over the element.

    LeftMouseDown,

    /// (Specialization of `MouseDown`). Fires only if the middle mouse button

    /// has been pressed while cursor was over the element.

    MiddleMouseDown,

    /// (Specialization of `MouseDown`). Fires only if the right mouse button

    /// has been pressed while cursor was over the element.

    RightMouseDown,

    /// Mouse button has been released while cursor was over the element.

    MouseUp,

    /// (Specialization of `MouseUp`). Fires only if the left mouse button has

    /// been released while cursor was over the element.

    LeftMouseUp,

    /// (Specialization of `MouseUp`). Fires only if the middle mouse button has

    /// been released while cursor was over the element.

    MiddleMouseUp,

    /// (Specialization of `MouseUp`). Fires only if the right mouse button has

    /// been released while cursor was over the element.

    RightMouseUp,

    /// Mouse cursor has entered the element.

    MouseEnter,

    /// Mouse cursor has left the element.

    MouseLeave,

    /// Mousewheel / touchpad scrolling.

    Scroll,

    /// The window received a unicode character (also respects the system locale).

    /// Check `keyboard_state.current_char` to get the current pressed character.

    TextInput,

    /// A **virtual keycode** was pressed. Note: This is only the virtual keycode,

    /// not the actual char. If you want to get the character, use `TextInput` instead.

    /// A virtual key does not have to map to a printable character.

    ///

    /// You can get all currently pressed virtual keycodes in the

    /// `keyboard_state.current_virtual_keycodes` and / or just the last keycode in the

    /// `keyboard_state.latest_virtual_keycode`.

    VirtualKeyDown,

    /// A **virtual keycode** was release. See `VirtualKeyDown` for more info.

    VirtualKeyUp,

    /// A file has been dropped on the element.

    HoveredFile,

    /// A file is being hovered on the element.

    DroppedFile,

    /// A file was hovered, but has exited the window.

    HoveredFileCancelled,

    /// Equivalent to `onfocus`.

    FocusReceived,

    /// Equivalent to `onblur`.

    FocusLost,

    // Accessibility-specific events

    /// Default action triggered by screen reader (usually same as click/activate)

    Default,

    /// Element should collapse (e.g., accordion panel, tree node)

    Collapse,

    /// Element should expand (e.g., accordion panel, tree node)

    Expand,

    /// Increment value (e.g., number input, slider)

    Increment,

    /// Decrement value (e.g., number input, slider)

    Decrement,

    /// A structural document edit (split / merge / wrap / replace…) was

    /// recorded on (or under) this element and awaits the app's

    /// apply-and-ack (fires once per changeset; focus-scoped, bubbles to

    /// the contenteditable root). APPENDED at the enum tail for ABI

    /// stability.

    DocumentEdit,

}

/// Contains the necessary information to render an embedded `VirtualView` node.

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct VirtualViewNode {

    /// The callback function that returns the DOM for the virtualized view's content.

    pub callback: VirtualViewCallback,

    /// The application data passed to the virtualized view's layout callback.

    pub refany: RefAny,

}

/// An enum that holds either a CSS ID or a class name as a string.

#[repr(C, u8)]

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub enum IdOrClass {

    Id(AzString),

    Class(AzString),

}

impl_option!(

    IdOrClass,

    OptionIdOrClass,

    copy = false,

    [Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord]

);

impl_vec!(IdOrClass, IdOrClassVec, IdOrClassVecDestructor, IdOrClassVecDestructorType, IdOrClassVecSlice, OptionIdOrClass);

impl_vec_debug!(IdOrClass, IdOrClassVec);

impl_vec_partialord!(IdOrClass, IdOrClassVec);

impl_vec_ord!(IdOrClass, IdOrClassVec);

impl_vec_clone!(IdOrClass, IdOrClassVec, IdOrClassVecDestructor);

impl_vec_partialeq!(IdOrClass, IdOrClassVec);

impl_vec_eq!(IdOrClass, IdOrClassVec);

impl_vec_hash!(IdOrClass, IdOrClassVec);

impl IdOrClass {

        }

        }

}

/// Name-value pair for custom attributes (data-*, aria-*, etc.)

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct AttributeNameValue {

    pub attr_name: AzString,

    pub value: AzString,

}

/// Strongly-typed HTML attribute with type-safe values.

///

/// This enum provides a type-safe way to represent HTML attributes, ensuring that

/// values are validated at compile-time and properly converted to their string

/// representations at runtime.

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

pub enum AttributeType {

    /// Element ID attribute (`id="..."`)

    Id(AzString),

    /// CSS class attribute (`class="..."`)

    Class(AzString),

    /// Accessible name/label (`aria-label="..."`)

    AriaLabel(AzString),

    /// Element that labels this one (`aria-labelledby="..."`)

    AriaLabelledBy(AzString),

    /// Element that describes this one (`aria-describedby="..."`)

    AriaDescribedBy(AzString),

    /// Role for accessibility (`role="..."`)

    AriaRole(AzString),

    /// Current state of an element (`aria-checked`, `aria-selected`, etc.)

    AriaState(AttributeNameValue),

    /// ARIA property (`aria-*`)

    AriaProperty(AttributeNameValue),

    /// Hyperlink target URL (`href="..."`)

    Href(AzString),

    /// Link relationship (`rel="..."`)

    Rel(AzString),

    /// Link target frame (`target="..."`)

    Target(AzString),

    /// Image source URL (`src="..."`)

    Src(AzString),

    /// Alternative text for images (`alt="..."`)

    Alt(AzString),

    /// Image title (tooltip) (`title="..."`)

    Title(AzString),

    /// Form input name (`name="..."`)