mellie

-module(attr).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/attr.gleam").
-export([aria/2, accept/1, accept_charset/1, accesskey/1, action/1, align/1, allow/1, alpha/1, alt/1, as_/1, async/1, autocapitalize/1, autocomplete/1, autoplay/1, background/1, bgcolor/1, border/1, capture/1, charset/1, checked/1, cite/1, class/1, color/1, colorspace/1, cols/1, colspan/1, content/1, contenteditable/1, controls/1, coords/1, crossorigin/1, csp/1, data/1, datetime/1, decoding/1, default/1, defer/1, dir/1, dirname/1, disabled/1, download/1, draggable/1, enctype/1, enterkeyhint/1, elementtiming/1, fetchpriority/1, for/1, form/1, formaction/1, formenctype/1, formmethod/1, formnovalidate/1, formtarget/1, headers/1, height/1, hidden/1, high/1, href/1, hreflang/1, http_equiv/1, id/1, integrity/1, inputmode/1, ismap/1, itemprop/1, kind/1, label/1, lang/1, language/1, loading/1, list/1, loop/1, low/1, max/1, maxlength/1, minlength/1, media/1, method/1, min/1, multiple/1, muted/1, name/1, novalidate/1, open/1, optimum/1, pattern/1, ping/1, placeholder/1, playsinline/1, poster/1, preload/1, readonly/1, referrerpolicy/1, rel/1, required/1, reversed/1, role/1, rows/1, rowspan/1, sandbox/1, scope/1, selected/1, shape/1, size/1, sizes/1, slot/1, span/1, spellcheck/1, src/1, srcdoc/1, srclang/1, srcset/1, start/1, step/1, style/1, summary/1, tabindex/1, target/1, title/1, translate/1, type_/1, usemap/1, value/1, width/1, wrap/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Element creation functions scraped from https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes\n"
    " This list automatically excludes any elements or attributes that are deprecated\n"
).

-file("src/attr.gleam", 8).
-spec aria(binary(), EKC) -> {binary(), EKC}.
aria(Name, Value) ->
    mellie:attribute(<<"aria-"/utf8, Name/binary>>, Value).

-file("src/attr.gleam", 13).
?DOC(" List of types the server accepts, typically a file type.\n").
-spec accept(EKE) -> {binary(), EKE}.
accept(Value) ->
    mellie:attribute(<<"accept"/utf8>>, Value).

-file("src/attr.gleam", 18).
?DOC(" The character set, which if provided must be \"UTF-8\" .\n").
-spec accept_charset(EKG) -> {binary(), EKG}.
accept_charset(Value) ->
    mellie:attribute(<<"accept-charset"/utf8>>, Value).

-file("src/attr.gleam", 23).
?DOC(" Keyboard shortcut to activate or add focus to the element.\n").
-spec accesskey(EKI) -> {binary(), EKI}.
accesskey(Value) ->
    mellie:attribute(<<"accesskey"/utf8>>, Value).

-file("src/attr.gleam", 28).
?DOC(" The URI of a program that processes the information submitted via the form.\n").
-spec action(EKK) -> {binary(), EKK}.
action(Value) ->
    mellie:attribute(<<"action"/utf8>>, Value).

-file("src/attr.gleam", 33).
?DOC(" Specifies the horizontal alignment of the element.\n").
-spec align(EKM) -> {binary(), EKM}.
align(Value) ->
    mellie:attribute(<<"align"/utf8>>, Value).

-file("src/attr.gleam", 38).
?DOC(" Specifies a feature-policy for the iframe.\n").
-spec allow(EKO) -> {binary(), EKO}.
allow(Value) ->
    mellie:attribute(<<"allow"/utf8>>, Value).

-file("src/attr.gleam", 43).
?DOC(" Allow the user to select a color's opacity on a type=\"color\" input.\n").
-spec alpha(EKQ) -> {binary(), EKQ}.
alpha(Value) ->
    mellie:attribute(<<"alpha"/utf8>>, Value).

-file("src/attr.gleam", 48).
?DOC(" Alternative text in case an image can't be displayed.\n").
-spec alt(EKS) -> {binary(), EKS}.
alt(Value) ->
    mellie:attribute(<<"alt"/utf8>>, Value).

-file("src/attr.gleam", 53).
?DOC(" Specifies the type of content being loaded by the link.\n").
-spec as_(EKU) -> {binary(), EKU}.
as_(Value) ->
    mellie:attribute(<<"as"/utf8>>, Value).

-file("src/attr.gleam", 58).
?DOC(" Executes the script asynchronously.\n").
-spec async(EKW) -> {binary(), EKW}.
async(Value) ->
    mellie:attribute(<<"async"/utf8>>, Value).

-file("src/attr.gleam", 63).
?DOC(" Sets whether input is automatically capitalized when entered by user\n").
-spec autocapitalize(EKY) -> {binary(), EKY}.
autocapitalize(Value) ->
    mellie:attribute(<<"autocapitalize"/utf8>>, Value).

-file("src/attr.gleam", 68).
?DOC(" Indicates whether controls in this form can by default have their values automatically completed by the browser.\n").
-spec autocomplete(ELA) -> {binary(), ELA}.
autocomplete(Value) ->
    mellie:attribute(<<"autocomplete"/utf8>>, Value).

-file("src/attr.gleam", 73).
?DOC(" The audio or video should play as soon as possible.\n").
-spec autoplay(ELC) -> {binary(), ELC}.
autoplay(Value) ->
    mellie:attribute(<<"autoplay"/utf8>>, Value).

-file("src/attr.gleam", 78).
?DOC(" Specifies the URL of an image file. Note: Although browsers and email clients may still support this attribute, it is obsolete. Use CSS background-image instead.\n").
-spec background(ELE) -> {binary(), ELE}.
background(Value) ->
    mellie:attribute(<<"background"/utf8>>, Value).

-file("src/attr.gleam", 83).
?DOC(" Background color of the element. Note: This is a legacy attribute. Please use the CSS background-color property instead.\n").
-spec bgcolor(ELG) -> {binary(), ELG}.
bgcolor(Value) ->
    mellie:attribute(<<"bgcolor"/utf8>>, Value).

-file("src/attr.gleam", 88).
?DOC(" The border width. Note: This is a legacy attribute. Please use the CSS border property instead.\n").
-spec border(ELI) -> {binary(), ELI}.
border(Value) ->
    mellie:attribute(<<"border"/utf8>>, Value).

-file("src/attr.gleam", 93).
?DOC(" From the Media Capture specification , specifies a new file can be captured.\n").
-spec capture(ELK) -> {binary(), ELK}.
capture(Value) ->
    mellie:attribute(<<"capture"/utf8>>, Value).

-file("src/attr.gleam", 98).
?DOC(" Declares the character encoding of the page or script.\n").
-spec charset(ELM) -> {binary(), ELM}.
charset(Value) ->
    mellie:attribute(<<"charset"/utf8>>, Value).

-file("src/attr.gleam", 103).
?DOC(" Indicates whether the element should be checked on page load.\n").
-spec checked(ELO) -> {binary(), ELO}.
checked(Value) ->
    mellie:attribute(<<"checked"/utf8>>, Value).

-file("src/attr.gleam", 108).
?DOC(" Contains a URI which points to the source of the quote or change.\n").
-spec cite(ELQ) -> {binary(), ELQ}.
cite(Value) ->
    mellie:attribute(<<"cite"/utf8>>, Value).

-file("src/attr.gleam", 113).
?DOC(" Often used with CSS to style elements with common properties.\n").
-spec class(ELS) -> {binary(), ELS}.
class(Value) ->
    mellie:attribute(<<"class"/utf8>>, Value).

-file("src/attr.gleam", 118).
?DOC(" This attribute sets the text color using either a named color or a color specified in the hexadecimal #RRGGBB format. Note: This is a legacy attribute. Please use the CSS color property instead.\n").
-spec color(ELU) -> {binary(), ELU}.
color(Value) ->
    mellie:attribute(<<"color"/utf8>>, Value).

-file("src/attr.gleam", 123).
?DOC(" Defines the color space that is used by a type=\"color\" input.\n").
-spec colorspace(ELW) -> {binary(), ELW}.
colorspace(Value) ->
    mellie:attribute(<<"colorspace"/utf8>>, Value).

-file("src/attr.gleam", 128).
?DOC(" Defines the number of columns in a textarea.\n").
-spec cols(ELY) -> {binary(), ELY}.
cols(Value) ->
    mellie:attribute(<<"cols"/utf8>>, Value).

-file("src/attr.gleam", 133).
?DOC(" The colspan attribute defines the number of columns a cell should span.\n").
-spec colspan(EMA) -> {binary(), EMA}.
colspan(Value) ->
    mellie:attribute(<<"colspan"/utf8>>, Value).

-file("src/attr.gleam", 138).
?DOC(" A value associated with http-equiv or name depending on the context.\n").
-spec content(EMC) -> {binary(), EMC}.
content(Value) ->
    mellie:attribute(<<"content"/utf8>>, Value).

-file("src/attr.gleam", 143).
?DOC(" Indicates whether the element's content is editable.\n").
-spec contenteditable(EME) -> {binary(), EME}.
contenteditable(Value) ->
    mellie:attribute(<<"contenteditable"/utf8>>, Value).

-file("src/attr.gleam", 148).
?DOC(" Indicates whether the browser should show playback controls to the user.\n").
-spec controls(EMG) -> {binary(), EMG}.
controls(Value) ->
    mellie:attribute(<<"controls"/utf8>>, Value).

-file("src/attr.gleam", 153).
?DOC(" A set of values specifying the coordinates of the hot-spot region.\n").
-spec coords(EMI) -> {binary(), EMI}.
coords(Value) ->
    mellie:attribute(<<"coords"/utf8>>, Value).

-file("src/attr.gleam", 158).
?DOC(" How the element handles cross-origin requests\n").
-spec crossorigin(EMK) -> {binary(), EMK}.
crossorigin(Value) ->
    mellie:attribute(<<"crossorigin"/utf8>>, Value).

-file("src/attr.gleam", 163).
?DOC(" Specifies the Content Security Policy that an embedded document must agree to enforce upon itself.\n").
-spec csp(EMM) -> {binary(), EMM}.
csp(Value) ->
    mellie:attribute(<<"csp"/utf8>>, Value).

-file("src/attr.gleam", 168).
?DOC(" Specifies the URL of the resource.\n").
-spec data(EMO) -> {binary(), EMO}.
data(Value) ->
    mellie:attribute(<<"data"/utf8>>, Value).

-file("src/attr.gleam", 173).
?DOC(" Indicates the date and time associated with the element.\n").
-spec datetime(EMQ) -> {binary(), EMQ}.
datetime(Value) ->
    mellie:attribute(<<"datetime"/utf8>>, Value).

-file("src/attr.gleam", 178).
?DOC(" Indicates the preferred method to decode the image.\n").
-spec decoding(EMS) -> {binary(), EMS}.
decoding(Value) ->
    mellie:attribute(<<"decoding"/utf8>>, Value).

-file("src/attr.gleam", 183).
?DOC(" Indicates that the track should be enabled unless the user's preferences indicate something different.\n").
-spec default(EMU) -> {binary(), EMU}.
default(Value) ->
    mellie:attribute(<<"default"/utf8>>, Value).

-file("src/attr.gleam", 188).
?DOC(" Indicates that the script should be executed after the page has been parsed.\n").
-spec defer(EMW) -> {binary(), EMW}.
defer(Value) ->
    mellie:attribute(<<"defer"/utf8>>, Value).

-file("src/attr.gleam", 193).
?DOC(" Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)\n").
-spec dir(EMY) -> {binary(), EMY}.
dir(Value) ->
    mellie:attribute(<<"dir"/utf8>>, Value).

-file("src/attr.gleam", 197).
-spec dirname(ENA) -> {binary(), ENA}.
dirname(Value) ->
    mellie:attribute(<<"dirname"/utf8>>, Value).

-file("src/attr.gleam", 202).
?DOC(" Indicates whether the user can interact with the element.\n").
-spec disabled(ENC) -> {binary(), ENC}.
disabled(Value) ->
    mellie:attribute(<<"disabled"/utf8>>, Value).

-file("src/attr.gleam", 207).
?DOC(" Indicates that the hyperlink is to be used for downloading a resource.\n").
-spec download(ENE) -> {binary(), ENE}.
download(Value) ->
    mellie:attribute(<<"download"/utf8>>, Value).

-file("src/attr.gleam", 212).
?DOC(" Defines whether the element can be dragged.\n").
-spec draggable(ENG) -> {binary(), ENG}.
draggable(Value) ->
    mellie:attribute(<<"draggable"/utf8>>, Value).

-file("src/attr.gleam", 217).
?DOC(" Defines the content type of the form data when the method is POST.\n").
-spec enctype(ENI) -> {binary(), ENI}.
enctype(Value) ->
    mellie:attribute(<<"enctype"/utf8>>, Value).

-file("src/attr.gleam", 222).
?DOC(" The enterkeyhint specifies what action label (or icon) to present for the enter key on virtual keyboards. The attribute can be used with form controls (such as the value of textarea elements), or in elements in an editing host (e.g., using contenteditable attribute).\n").
-spec enterkeyhint(ENK) -> {binary(), ENK}.
enterkeyhint(Value) ->
    mellie:attribute(<<"enterkeyhint"/utf8>>, Value).

-file("src/attr.gleam", 227).
?DOC(" Indicates that an element is flagged for tracking by PerformanceObserver objects using the \"element\" type. For more details, see the PerformanceElementTiming interface.\n").
-spec elementtiming(ENM) -> {binary(), ENM}.
elementtiming(Value) ->
    mellie:attribute(<<"elementtiming"/utf8>>, Value).

-file("src/attr.gleam", 232).
?DOC(" Signals that fetching a particular image early in the loading process has more or less impact on user experience than a browser can reasonably infer when assigning an internal priority.\n").
-spec fetchpriority(ENO) -> {binary(), ENO}.
fetchpriority(Value) ->
    mellie:attribute(<<"fetchpriority"/utf8>>, Value).

-file("src/attr.gleam", 237).
?DOC(" Describes elements which belongs to this one.\n").
-spec for(ENQ) -> {binary(), ENQ}.
for(Value) ->
    mellie:attribute(<<"for"/utf8>>, Value).

-file("src/attr.gleam", 242).
?DOC(" Indicates the form that is the owner of the element.\n").
-spec form(ENS) -> {binary(), ENS}.
form(Value) ->
    mellie:attribute(<<"form"/utf8>>, Value).

-file("src/attr.gleam", 247).
?DOC(" Indicates the action of the element, overriding the action defined in the <form> .\n").
-spec formaction(ENU) -> {binary(), ENU}.
formaction(Value) ->
    mellie:attribute(<<"formaction"/utf8>>, Value).

-file("src/attr.gleam", 252).
?DOC(" If the button/input is a submit button (e.g., type=\"submit\" ), this attribute sets the encoding type to use during form submission. If this attribute is specified, it overrides the enctype attribute of the button's form owner.\n").
-spec formenctype(ENW) -> {binary(), ENW}.
formenctype(Value) ->
    mellie:attribute(<<"formenctype"/utf8>>, Value).

-file("src/attr.gleam", 257).
?DOC(" If the button/input is a submit button (e.g., type=\"submit\" ), this attribute sets the submission method to use during form submission ( GET , POST , etc.). If this attribute is specified, it overrides the method attribute of the button's form owner.\n").
-spec formmethod(ENY) -> {binary(), ENY}.
formmethod(Value) ->
    mellie:attribute(<<"formmethod"/utf8>>, Value).

-file("src/attr.gleam", 262).
?DOC(" If the button/input is a submit button (e.g., type=\"submit\" ), this boolean attribute specifies that the form is not to be validated when it is submitted. If this attribute is specified, it overrides the novalidate attribute of the button's form owner.\n").
-spec formnovalidate(EOA) -> {binary(), EOA}.
formnovalidate(Value) ->
    mellie:attribute(<<"formnovalidate"/utf8>>, Value).

-file("src/attr.gleam", 267).
?DOC(" If the button/input is a submit button (e.g., type=\"submit\" ), this attribute specifies the browsing context (for example, tab, window, or inline frame) in which to display the response that is received after submitting the form. If this attribute is specified, it overrides the target attribute of the button's form owner.\n").
-spec formtarget(EOC) -> {binary(), EOC}.
formtarget(Value) ->
    mellie:attribute(<<"formtarget"/utf8>>, Value).

-file("src/attr.gleam", 272).
?DOC(" IDs of the <th> elements which applies to this element.\n").
-spec headers(EOE) -> {binary(), EOE}.
headers(Value) ->
    mellie:attribute(<<"headers"/utf8>>, Value).

-file("src/attr.gleam", 277).
?DOC(" Specifies the height of elements listed here. For all other elements, use the CSS height property. Note: In some instances, such as <div> , this is a legacy attribute, in which case the CSS height property should be used instead.\n").
-spec height(EOG) -> {binary(), EOG}.
height(Value) ->
    mellie:attribute(<<"height"/utf8>>, Value).

-file("src/attr.gleam", 282).
?DOC(" Prevents rendering of given element, while keeping child elements, e.g. script elements, active.\n").
-spec hidden(EOI) -> {binary(), EOI}.
hidden(Value) ->
    mellie:attribute(<<"hidden"/utf8>>, Value).

-file("src/attr.gleam", 287).
?DOC(" Indicates the lower bound of the upper range.\n").
-spec high(EOK) -> {binary(), EOK}.
high(Value) ->
    mellie:attribute(<<"high"/utf8>>, Value).

-file("src/attr.gleam", 292).
?DOC(" The URL of a linked resource.\n").
-spec href(EOM) -> {binary(), EOM}.
href(Value) ->
    mellie:attribute(<<"href"/utf8>>, Value).

-file("src/attr.gleam", 297).
?DOC(" Specifies the language of the linked resource.\n").
-spec hreflang(EOO) -> {binary(), EOO}.
hreflang(Value) ->
    mellie:attribute(<<"hreflang"/utf8>>, Value).

-file("src/attr.gleam", 302).
?DOC(" Defines a pragma directive.\n").
-spec http_equiv(EOQ) -> {binary(), EOQ}.
http_equiv(Value) ->
    mellie:attribute(<<"http-equiv"/utf8>>, Value).

-file("src/attr.gleam", 307).
?DOC(" Often used with CSS to style a specific element. The value of this attribute must be unique.\n").
-spec id(EOS) -> {binary(), EOS}.
id(Value) ->
    mellie:attribute(<<"id"/utf8>>, Value).

-file("src/attr.gleam", 312).
?DOC(" This attribute contains one or more hashes of the resource, and is used to ensure that the content of the resource is what the developer expects it to be, and has not been replaced with a malicious copy in a supply chain attack . See Subresource Integrity .\n").
-spec integrity(EOU) -> {binary(), EOU}.
integrity(Value) ->
    mellie:attribute(<<"integrity"/utf8>>, Value).

-file("src/attr.gleam", 317).
?DOC(" Provides a hint as to the type of data that might be entered by the user while editing the element or its contents. The attribute can be used with form controls (such as the value of textarea elements), or in elements in an editing host (e.g., using contenteditable attribute).\n").
-spec inputmode(EOW) -> {binary(), EOW}.
inputmode(Value) ->
    mellie:attribute(<<"inputmode"/utf8>>, Value).

-file("src/attr.gleam", 322).
?DOC(" Indicates that the image is part of a server-side image map.\n").
-spec ismap(EOY) -> {binary(), EOY}.
ismap(Value) ->
    mellie:attribute(<<"ismap"/utf8>>, Value).

-file("src/attr.gleam", 326).
-spec itemprop(EPA) -> {binary(), EPA}.
itemprop(Value) ->
    mellie:attribute(<<"itemprop"/utf8>>, Value).

-file("src/attr.gleam", 331).
?DOC(" Specifies the kind of text track.\n").
-spec kind(EPC) -> {binary(), EPC}.
kind(Value) ->
    mellie:attribute(<<"kind"/utf8>>, Value).

-file("src/attr.gleam", 336).
?DOC(" Specifies a user-readable title of the element.\n").
-spec label(EPE) -> {binary(), EPE}.
label(Value) ->
    mellie:attribute(<<"label"/utf8>>, Value).

-file("src/attr.gleam", 341).
?DOC(" Defines the language used in the element.\n").
-spec lang(EPG) -> {binary(), EPG}.
lang(Value) ->
    mellie:attribute(<<"lang"/utf8>>, Value).

-file("src/attr.gleam", 346).
?DOC(" Defines the script language used in the element.\n").
-spec language(EPI) -> {binary(), EPI}.
language(Value) ->
    mellie:attribute(<<"language"/utf8>>, Value).

-file("src/attr.gleam", 351).
?DOC(" Indicates if the element should be loaded lazily ( loading=\"lazy\" ) or loaded immediately ( loading=\"eager\" ).\n").
-spec loading(EPK) -> {binary(), EPK}.
loading(Value) ->
    mellie:attribute(<<"loading"/utf8>>, Value).

-file("src/attr.gleam", 356).
?DOC(" Identifies a list of pre-defined options to suggest to the user.\n").
-spec list(EPM) -> {binary(), EPM}.
list(Value) ->
    mellie:attribute(<<"list"/utf8>>, Value).

-file("src/attr.gleam", 361).
?DOC(" Indicates whether the media should start playing from the start when it's finished.\n").
-spec loop(EPO) -> {binary(), EPO}.
loop(Value) ->
    mellie:attribute(<<"loop"/utf8>>, Value).

-file("src/attr.gleam", 366).
?DOC(" Indicates the upper bound of the lower range.\n").
-spec low(EPQ) -> {binary(), EPQ}.
low(Value) ->
    mellie:attribute(<<"low"/utf8>>, Value).

-file("src/attr.gleam", 371).
?DOC(" Indicates the maximum value allowed.\n").
-spec max(EPS) -> {binary(), EPS}.
max(Value) ->
    mellie:attribute(<<"max"/utf8>>, Value).

-file("src/attr.gleam", 376).
?DOC(" Defines the maximum number of characters allowed in the element.\n").
-spec maxlength(EPU) -> {binary(), EPU}.
maxlength(Value) ->
    mellie:attribute(<<"maxlength"/utf8>>, Value).

-file("src/attr.gleam", 381).
?DOC(" Defines the minimum number of characters allowed in the element.\n").
-spec minlength(EPW) -> {binary(), EPW}.
minlength(Value) ->
    mellie:attribute(<<"minlength"/utf8>>, Value).

-file("src/attr.gleam", 386).
?DOC(" Specifies a hint of the media for which the linked resource was designed.\n").
-spec media(EPY) -> {binary(), EPY}.
media(Value) ->
    mellie:attribute(<<"media"/utf8>>, Value).

-file("src/attr.gleam", 391).
?DOC(" Defines which HTTP method to use when submitting the form. Can be GET (default) or POST .\n").
-spec method(EQA) -> {binary(), EQA}.
method(Value) ->
    mellie:attribute(<<"method"/utf8>>, Value).

-file("src/attr.gleam", 396).
?DOC(" Indicates the minimum value allowed.\n").
-spec min(EQC) -> {binary(), EQC}.
min(Value) ->
    mellie:attribute(<<"min"/utf8>>, Value).

-file("src/attr.gleam", 401).
?DOC(" Indicates whether multiple values can be entered in an input of the type email or file .\n").
-spec multiple(EQE) -> {binary(), EQE}.
multiple(Value) ->
    mellie:attribute(<<"multiple"/utf8>>, Value).

-file("src/attr.gleam", 406).
?DOC(" Indicates whether the audio will be initially silenced on page load.\n").
-spec muted(EQG) -> {binary(), EQG}.
muted(Value) ->
    mellie:attribute(<<"muted"/utf8>>, Value).

-file("src/attr.gleam", 411).
?DOC(" Name of the element. For example used by the server to identify the fields in form submits.\n").
-spec name(EQI) -> {binary(), EQI}.
name(Value) ->
    mellie:attribute(<<"name"/utf8>>, Value).

-file("src/attr.gleam", 416).
?DOC(" This attribute indicates that the form shouldn't be validated when submitted.\n").
-spec novalidate(EQK) -> {binary(), EQK}.
novalidate(Value) ->
    mellie:attribute(<<"novalidate"/utf8>>, Value).

-file("src/attr.gleam", 421).
?DOC(" Indicates whether the contents are currently visible (in the case of a <details> element) or whether the dialog is active and can be interacted with (in the case of a <dialog> element).\n").
-spec open(EQM) -> {binary(), EQM}.
open(Value) ->
    mellie:attribute(<<"open"/utf8>>, Value).

-file("src/attr.gleam", 426).
?DOC(" Indicates the optimal numeric value.\n").
-spec optimum(EQO) -> {binary(), EQO}.
optimum(Value) ->
    mellie:attribute(<<"optimum"/utf8>>, Value).

-file("src/attr.gleam", 431).
?DOC(" Defines a regular expression which the element's value will be validated against.\n").
-spec pattern(EQQ) -> {binary(), EQQ}.
pattern(Value) ->
    mellie:attribute(<<"pattern"/utf8>>, Value).

-file("src/attr.gleam", 436).
?DOC(" The ping attribute specifies a space-separated list of URLs to be notified if a user follows the hyperlink.\n").
-spec ping(EQS) -> {binary(), EQS}.
ping(Value) ->
    mellie:attribute(<<"ping"/utf8>>, Value).

-file("src/attr.gleam", 441).
?DOC(" Provides a hint to the user of what can be entered in the field.\n").
-spec placeholder(EQU) -> {binary(), EQU}.
placeholder(Value) ->
    mellie:attribute(<<"placeholder"/utf8>>, Value).

-file("src/attr.gleam", 446).
?DOC(" A Boolean attribute indicating that the video is to be played \"inline\"; that is, within the element's playback area. Note that the absence of this attribute does not imply that the video will always be played in fullscreen.\n").
-spec playsinline(EQW) -> {binary(), EQW}.
playsinline(Value) ->
    mellie:attribute(<<"playsinline"/utf8>>, Value).

-file("src/attr.gleam", 451).
?DOC(" A URL indicating a poster frame to show until the user plays or seeks.\n").
-spec poster(EQY) -> {binary(), EQY}.
poster(Value) ->
    mellie:attribute(<<"poster"/utf8>>, Value).

-file("src/attr.gleam", 456).
?DOC(" Indicates whether the whole resource, parts of it or nothing should be preloaded.\n").
-spec preload(ERA) -> {binary(), ERA}.
preload(Value) ->
    mellie:attribute(<<"preload"/utf8>>, Value).

-file("src/attr.gleam", 461).
?DOC(" Indicates whether the element can be edited.\n").
-spec readonly(ERC) -> {binary(), ERC}.
readonly(Value) ->
    mellie:attribute(<<"readonly"/utf8>>, Value).

-file("src/attr.gleam", 466).
?DOC(" Specifies which referrer is sent when fetching the resource.\n").
-spec referrerpolicy(ERE) -> {binary(), ERE}.
referrerpolicy(Value) ->
    mellie:attribute(<<"referrerpolicy"/utf8>>, Value).

-file("src/attr.gleam", 471).
?DOC(" Specifies the relationship of the target object to the link object.\n").
-spec rel(ERG) -> {binary(), ERG}.
rel(Value) ->
    mellie:attribute(<<"rel"/utf8>>, Value).

-file("src/attr.gleam", 476).
?DOC(" Indicates whether this element is required to fill out or not.\n").
-spec required(ERI) -> {binary(), ERI}.
required(Value) ->
    mellie:attribute(<<"required"/utf8>>, Value).

-file("src/attr.gleam", 481).
?DOC(" Indicates whether the list should be displayed in a descending order instead of an ascending order.\n").
-spec reversed(ERK) -> {binary(), ERK}.
reversed(Value) ->
    mellie:attribute(<<"reversed"/utf8>>, Value).

-file("src/attr.gleam", 486).
?DOC(" Defines an explicit role for an element for use by assistive technologies.\n").
-spec role(ERM) -> {binary(), ERM}.
role(Value) ->
    mellie:attribute(<<"role"/utf8>>, Value).

-file("src/attr.gleam", 491).
?DOC(" Defines the number of rows in a text area.\n").
-spec rows(ERO) -> {binary(), ERO}.
rows(Value) ->
    mellie:attribute(<<"rows"/utf8>>, Value).

-file("src/attr.gleam", 496).
?DOC(" Defines the number of rows a table cell should span over.\n").
-spec rowspan(ERQ) -> {binary(), ERQ}.
rowspan(Value) ->
    mellie:attribute(<<"rowspan"/utf8>>, Value).

-file("src/attr.gleam", 501).
?DOC(" Stops a document loaded in an iframe from using certain features (such as submitting forms or opening new windows).\n").
-spec sandbox(ERS) -> {binary(), ERS}.
sandbox(Value) ->
    mellie:attribute(<<"sandbox"/utf8>>, Value).

-file("src/attr.gleam", 506).
?DOC(" Defines the cells that the header test (defined in the th element) relates to.\n").
-spec scope(ERU) -> {binary(), ERU}.
scope(Value) ->
    mellie:attribute(<<"scope"/utf8>>, Value).

-file("src/attr.gleam", 511).
?DOC(" Defines a value which will be selected on page load.\n").
-spec selected(ERW) -> {binary(), ERW}.
selected(Value) ->
    mellie:attribute(<<"selected"/utf8>>, Value).

-file("src/attr.gleam", 515).
-spec shape(ERY) -> {binary(), ERY}.
shape(Value) ->
    mellie:attribute(<<"shape"/utf8>>, Value).

-file("src/attr.gleam", 520).
?DOC(" Defines the width of the element (in pixels). If the element's type attribute is text or password then it's the number of characters.\n").
-spec size(ESA) -> {binary(), ESA}.
size(Value) ->
    mellie:attribute(<<"size"/utf8>>, Value).

-file("src/attr.gleam", 524).
-spec sizes(ESC) -> {binary(), ESC}.
sizes(Value) ->
    mellie:attribute(<<"sizes"/utf8>>, Value).

-file("src/attr.gleam", 529).
?DOC(" Assigns a slot in a shadow DOM shadow tree to an element.\n").
-spec slot(ESE) -> {binary(), ESE}.
slot(Value) ->
    mellie:attribute(<<"slot"/utf8>>, Value).

-file("src/attr.gleam", 533).
-spec span(ESG) -> {binary(), ESG}.
span(Value) ->
    mellie:attribute(<<"span"/utf8>>, Value).

-file("src/attr.gleam", 538).
?DOC(" Indicates whether spell checking is allowed for the element.\n").
-spec spellcheck(ESI) -> {binary(), ESI}.
spellcheck(Value) ->
    mellie:attribute(<<"spellcheck"/utf8>>, Value).

-file("src/attr.gleam", 543).
?DOC(" The URL of the embeddable content.\n").
-spec src(ESK) -> {binary(), ESK}.
src(Value) ->
    mellie:attribute(<<"src"/utf8>>, Value).

-file("src/attr.gleam", 547).
-spec srcdoc(ESM) -> {binary(), ESM}.
srcdoc(Value) ->
    mellie:attribute(<<"srcdoc"/utf8>>, Value).

-file("src/attr.gleam", 551).
-spec srclang(ESO) -> {binary(), ESO}.
srclang(Value) ->
    mellie:attribute(<<"srclang"/utf8>>, Value).

-file("src/attr.gleam", 556).
?DOC(" One or more responsive image candidates.\n").
-spec srcset(ESQ) -> {binary(), ESQ}.
srcset(Value) ->
    mellie:attribute(<<"srcset"/utf8>>, Value).

-file("src/attr.gleam", 561).
?DOC(" Defines the first number if other than 1.\n").
-spec start(ESS) -> {binary(), ESS}.
start(Value) ->
    mellie:attribute(<<"start"/utf8>>, Value).

-file("src/attr.gleam", 565).
-spec step(ESU) -> {binary(), ESU}.
step(Value) ->
    mellie:attribute(<<"step"/utf8>>, Value).

-file("src/attr.gleam", 570).
?DOC(" Defines CSS styles which will override styles previously set.\n").
-spec style(ESW) -> {binary(), ESW}.
style(Value) ->
    mellie:attribute(<<"style"/utf8>>, Value).

-file("src/attr.gleam", 574).
-spec summary(ESY) -> {binary(), ESY}.
summary(Value) ->
    mellie:attribute(<<"summary"/utf8>>, Value).

-file("src/attr.gleam", 579).
?DOC(" Overrides the browser's default tab order and follows the one specified instead.\n").
-spec tabindex(ETA) -> {binary(), ETA}.
tabindex(Value) ->
    mellie:attribute(<<"tabindex"/utf8>>, Value).

-file("src/attr.gleam", 584).
?DOC(" Specifies where to open the linked document (in the case of an <a> element) or where to display the response received (in the case of a <form> element)\n").
-spec target(ETC) -> {binary(), ETC}.
target(Value) ->
    mellie:attribute(<<"target"/utf8>>, Value).

-file("src/attr.gleam", 589).
?DOC(" Text to be displayed in a tooltip when hovering over the element.\n").
-spec title(ETE) -> {binary(), ETE}.
title(Value) ->
    mellie:attribute(<<"title"/utf8>>, Value).

-file("src/attr.gleam", 594).
?DOC(" Specify whether an element's attribute values and the values of its Text node children are to be translated when the page is localized, or whether to leave them unchanged.\n").
-spec translate(ETG) -> {binary(), ETG}.
translate(Value) ->
    mellie:attribute(<<"translate"/utf8>>, Value).

-file("src/attr.gleam", 599).
?DOC(" Defines the type of the element.\n").
-spec type_(ETI) -> {binary(), ETI}.
type_(Value) ->
    mellie:attribute(<<"type"/utf8>>, Value).

-file("src/attr.gleam", 603).
-spec usemap(ETK) -> {binary(), ETK}.
usemap(Value) ->
    mellie:attribute(<<"usemap"/utf8>>, Value).

-file("src/attr.gleam", 608).
?DOC(" Defines a default value which will be displayed in the element on page load.\n").
-spec value(ETM) -> {binary(), ETM}.
value(Value) ->
    mellie:attribute(<<"value"/utf8>>, Value).

-file("src/attr.gleam", 613).
?DOC(" For the elements listed here, this establishes the element's width. Note: For all other instances, such as <div> , this is a legacy attribute, in which case the CSS width property should be used instead.\n").
-spec width(ETO) -> {binary(), ETO}.
width(Value) ->
    mellie:attribute(<<"width"/utf8>>, Value).

-file("src/attr.gleam", 618).
?DOC(" Indicates whether the text should be wrapped.\n").
-spec wrap(ETQ) -> {binary(), ETQ}.
wrap(Value) ->
    mellie:attribute(<<"wrap"/utf8>>, Value).